tsc.c File Reference

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

Include dependency graph for tsc.c:

Go to the source code of this file.

Macros
#define	NDEBUG
#define	RTC_MODE   6 /* Mode 6 is 1024 Hz */
#define	SAMPLE_FREQUENCY   ((32768 << 1) >> RTC_MODE)

Functions
static ULONG64	DoLinearRegression (ULONG XMax, ULONG64 *ArrayY)
VOID NTAPI	HalpInitializeTsc (VOID)
VOID NTAPI	HalpCalibrateStallExecution (VOID)
LARGE_INTEGER NTAPI	KeQueryPerformanceCounter (OUT PLARGE_INTEGER PerformanceFrequency OPTIONAL)
VOID NTAPI	KeStallExecutionProcessor (ULONG MicroSeconds)
VOID NTAPI	HalCalibratePerformanceCounter (IN volatile PLONG Count, IN ULONGLONG NewCount)

Variables
LARGE_INTEGER	HalpCpuClockFrequency = {{INITIAL_STALL_COUNT * 1000000}}
UCHAR	TscCalibrationPhase
ULONG64	TscCalibrationArray [NUM_SAMPLES]

Macro Definition Documentation

NDEBUG

#define NDEBUG

Definition at line 14 of file tsc.c.

RTC_MODE

#define RTC_MODE   6 /* Mode 6 is 1024 Hz */

Definition at line 22 of file tsc.c.

SAMPLE_FREQUENCY

#define SAMPLE_FREQUENCY   ((32768 << 1) >> RTC_MODE)

Definition at line 23 of file tsc.c.

Function Documentation

DoLinearRegression()

static ULONG64 DoLinearRegression ( ULONG  XMax, ULONG64 *  ArrayY  )

static

Definition at line 29 of file tsc.c.

{
    ULONG X, SumXX;
    ULONG64 SumXY;
 
    /* Calculate the sum of the squares of X */
    SumXX = (XMax * (XMax + 1) * (2*XMax + 1)) / 6;
 
    /* Calculate the sum of the differences to the first value
       weighted by x */
    for (SumXY = 0, X = 1; X <= XMax; X++)
    {
         SumXY += X * (ArrayY[X] - ArrayY[0]);
    }
 
    /* Account for sample frequency */
    SumXY *= SAMPLE_FREQUENCY;
 
    /* Return the quotient of the sums */
    return (SumXY + (SumXX/2)) / SumXX;
}

Referenced by HalpInitializeTsc().

HalCalibratePerformanceCounter()

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

Definition at line 171 of file tsc.c.

{
    UNIMPLEMENTED;
    ASSERT(FALSE);
}

HalpCalibrateStallExecution()

VOID NTAPI HalpCalibrateStallExecution

(

VOID

)

Definition at line 120 of file tsc.c.

{
    // Timer interrupt is now active
 
    HalpInitializeTsc();
 
    KeGetPcr()->StallScaleFactor = (ULONG)(HalpCpuClockFrequency.QuadPart / 1000000);
}

HalpInitializeTsc()

VOID NTAPI HalpInitializeTsc

(

VOID

)

Definition at line 55 of file tsc.c.

{
    ULONG_PTR Flags;
    PVOID PreviousHandler;
    UCHAR RegisterA, RegisterB;
 
    /* Check if the CPU supports RDTSC */
    if (!(KeGetCurrentPrcb()->FeatureBits & KF_RDTSC))
    {
        KeBugCheck(HAL_INITIALIZATION_FAILED);
    }
 
     /* Save flags and disable interrupts */
    Flags = __readeflags();
    _disable();
 
    /* Enable the periodic interrupt in the CMOS */
    RegisterB = HalpReadCmos(RTC_REGISTER_B);
    HalpWriteCmos(RTC_REGISTER_B, RegisterB | RTC_REG_B_PI);
 
    /* Modify register A to RTC_MODE to get SAMPLE_FREQUENCY */
    RegisterA = HalpReadCmos(RTC_REGISTER_A);
    RegisterA = (RegisterA & 0xF0) | RTC_MODE;
    HalpWriteCmos(RTC_REGISTER_A, RegisterA);
 
    /* Save old IDT entry */
    PreviousHandler = KeQueryInterruptHandler(APIC_CLOCK_VECTOR);
 
    /* Set the calibration ISR */
    KeRegisterInterruptHandler(APIC_CLOCK_VECTOR, TscCalibrationISR);
 
    /* Reset TSC value to 0 */
    __writemsr(MSR_RDTSC, 0);
 
    /* Enable the timer interrupt */
    HalEnableSystemInterrupt(APIC_CLOCK_VECTOR, CLOCK_LEVEL, Latched);
 
    /* Read register C, so that the next interrupt can happen */
    HalpReadCmos(RTC_REGISTER_C);
 
    /* Wait for completion */
    _enable();
    while (TscCalibrationPhase < NUM_SAMPLES) _ReadWriteBarrier();
    _disable();
 
    /* Disable the periodic interrupt in the CMOS */
    HalpWriteCmos(RTC_REGISTER_B, RegisterB & ~RTC_REG_B_PI);
 
    /* Disable the timer interrupt */
    HalDisableSystemInterrupt(APIC_CLOCK_VECTOR, CLOCK_LEVEL);
 
    /* Restore the previous handler */
    KeRegisterInterruptHandler(APIC_CLOCK_VECTOR, PreviousHandler);
 
    /* Calculate an average, using simplified linear regression */
    HalpCpuClockFrequency.QuadPart = DoLinearRegression(NUM_SAMPLES - 1,
                                                        TscCalibrationArray);
 
    /* Restore flags */
    __writeeflags(Flags);
 
}

Referenced by HalpCalibrateStallExecution().

KeQueryPerformanceCounter()

LARGE_INTEGER NTAPI KeQueryPerformanceCounter

(

OUT PLARGE_INTEGER PerformanceFrequency

OPTIONAL

)

Definition at line 133 of file tsc.c.

{
    LARGE_INTEGER Result;
 
    /* Make sure it's calibrated */
    ASSERT(HalpCpuClockFrequency.QuadPart != 0);
 
    /* Does the caller want the frequency? */
    if (PerformanceFrequency)
    {
        /* Return tsc frequency */
        *PerformanceFrequency = HalpCpuClockFrequency;
    }
 
    /* Return the current value */
    Result.QuadPart = __rdtsc();
    return Result;
}

KeStallExecutionProcessor()

VOID NTAPI KeStallExecutionProcessor

(

ULONG

MicroSeconds

)

Definition at line 155 of file tsc.c.

{
    ULONG64 StartTime, EndTime;
 
    /* Get the initial time */
    StartTime = __rdtsc();
 
    /* Calculate the ending time */
    EndTime = StartTime + KeGetPcr()->StallScaleFactor * MicroSeconds;
 
    /* Loop until time is elapsed */
    while (__rdtsc() < EndTime);
}

Variable Documentation

HalpCpuClockFrequency

LARGE_INTEGER HalpCpuClockFrequency = {{INITIAL_STALL_COUNT * 1000000}}

Definition at line 17 of file tsc.c.

Referenced by ApicSetTimerInterval(), HalpCalibrateStallExecution(), HalpInitializeTsc(), and KeQueryPerformanceCounter().

TscCalibrationArray

ULONG64 TscCalibrationArray[NUM_SAMPLES]

Definition at line 20 of file tsc.c.

Referenced by HalpInitializeTsc().

TscCalibrationPhase

UCHAR TscCalibrationPhase

Definition at line 19 of file tsc.c.

Referenced by HalpInitializeTsc().