windows-xp/Source/XPSP1/NT/base/hals/halacpi/amd64/ixclock.c

/*++

Copyright (c) 2000 Microsoft Corporation

Module Name:

    ixclock.c

Abstract:

    This module implements the code necessary to field and process the
    interval clock interrupts.

Author:

    Shie-Lin Tzong (shielint) 12-Jan-1990

Environment:

    Kernel mode only.

Revision History:

    bryanwi 20-Sep-90

        Add KiSetProfileInterval, KiStartProfileInterrupt,
        KiStopProfileInterrupt procedures.
        KiProfileInterrupt ISR.
        KiProfileList, KiProfileLock are delcared here.

    shielint 10-Dec-90
        Add performance counter support.
        Move system clock to irq8, ie we now use RTC to generate system
          clock.  Performance count and Profile use timer 1 counter 0.
          The interval of the irq0 interrupt can be changed by
          KiSetProfileInterval.  Performance counter does not care about the
          interval of the interrupt as long as it knows the rollover count.
        Note: Currently I implemented 1 performance counter for the whole
        i386 NT.
 
    John Vert (jvert) 11-Jul-1991
        Moved from ke\i386 to hal\i386.  Removed non-HAL stuff
 
    shie-lin tzong (shielint) 13-March-92
        Move System clock back to irq0 and use RTC (irq8) to generate
        profile interrupt.  Performance counter and system clock use time1
        counter 0 of 8254.
 
    Landy Wang (corollary!landy) 04-Dec-92
        Move much code into separate modules for easy inclusion by various
        HAL builds.

    Forrest Foltz (forrestf) 24-Oct-2000
        Ported from ixclock.asm to ixclock.c
 
--*/

#include "halcmn.h"

#define COUNTER_TICKS_AVG_SHIFT       4
#define COUNTER_TICKS_FOR_AVG        16
#define FRAME_COPY_SIZE              64

//
// Convert the interval to rollover count for 8254 Timer1 device.
// Timer1 counts down a 16 bit value at a rate of 1.193181667M counts-per-sec.
// (The main crystal freq is 14.31818, and this is a divide by 12)
//
// The best fit value closest to 10ms is 10.0144012689ms:
//   ROLLOVER_COUNT      11949
//   TIME_INCREMENT      100144
//   Calculated error is -.0109472 s/day
//
//
// The following table contains 8254 values timer values to use at
// any given ms setting from 1ms - 15ms.  All values work out to the
// same error per day (-.0109472 s/day).
//

typedef struct _TIMER_TABLE_ENTRY {
    USHORT RolloverCount;
    ULONG TimeIncrement;
} TIMER_TABLE_ENTRY, *PTIMER_TABLE_ENTRY;

TIMER_TABLE_ENTRY HalpTimerTable[] = {
    {      0,       0 },    // dummy entry to zero-base array
    {   1197,   10032 },    //  1ms
    {   2394,   20064 },    //  2ms
    {   3591,   30096 },    //  3ms
    {   4767,   39952 },    //  4ms
    {   5964,   49984 },    //  5ms
    {   7161,   60016 },    //  6ms
    {   8358,   70048 },    //  7ms
    {   9555,   80080 },    //  8ms
    {  10731,   89936 },    //  9ms
    {  11949,  100144 }     // 10ms
};

#define MIN_TIMER_INCREMENT 1
#define MAX_TIMER_INCREMENT \
    (sizeof(HalpTimerTable) / sizeof(TIMER_TABLE_ENTRY) - 1)

#define HalpMinimumTimerTableEntry (&HalpTimerTable[MIN_TIMER_INCREMENT])
#define HalpMaximumTimerTableEntry (&HalpTimerTable[MAX_TIMER_INCREMENT])

//
// External function prototypes
//

VOID
HalpMcaQueueDpc(
    VOID
    );

//
// External declarations
//

extern ULONG HalpTimerWatchdogEnabled;

//
// Globals
//

ULONG64 HalpWatchdogCount;
ULONG64 HalpWatchdogTsc;
ULONG64 HalpTimeBias;
BOOLEAN HalpClockMcaQueueDpc;

PTIMER_TABLE_ENTRY HalpNextMSRate = NULL;
ULONG HalpCurrentMSRateTableIndex;

#define HalpCurrentMSRate (&HalpTimerTable[HalpCurrentMSRateTableIndex+1])

//
// Forward function declarations
//

VOID
HalpSetMSRate(
    IN PTIMER_TABLE_ENTRY TableEntry
    );

//
// Inline functions
//

__forceinline
VOID
HalpCalibrateWatchdog(
    VOID
    )
{
    if (HalpTimerWatchdogEnabled == 0) {
        return;
    }

    //
    // Initializethe timer latency watchdog
    //

    HalpWatchdogTsc = ReadTimeStampCounter();
    HalpWatchdogCount = 0;
}

__forceinline
VOID
HalpCheckWatchdog(
    VOID
    )
{
    if (HalpTimerWatchdogEnabled == 0) {
        return;
    }

    AMD64_IMPLEMENT;
}

//
// Module functions
//

VOID
HalpInitializeClock (
    VOID
    )

/*++

Routine Description:

    This routine initialize system time clock using 8254 timer1 counter 0
    to generate an interrupt at every 15ms interval at 8259 irq0.

    See the definitions of TIME_INCREMENT and ROLLOVER_COUNT if clock rate
    needs to be changed.

Arguments:

    None

Return Value:

    None

--*/

{
    ULONG maxTimeIncrement;
    ULONG minTimeIncrement;

    //
    // Indicate to the kernel the minimum and maximum tick increments
    //

    minTimeIncrement = HalpMinimumTimerTableEntry->TimeIncrement;
    maxTimeIncrement = HalpMaximumTimerTableEntry->TimeIncrement;
    KeSetTimeIncrement(minTimeIncrement,maxTimeIncrement);

    //
    // Set the initial clock rate to the slowest permissible
    //

    HalpSetMSRate(HalpMaximumTimerTableEntry);
}


VOID
HalpAcpiTimerCalibratePerfCount (
    IN PLONG volatile Number,
    IN ULONG64 NewCount
    )

/*++

Routine Description:

    This routine resets the performance counter value for the current
    processor to zero. The reset is done such that the resulting value
    is closely synchronized with other processors in the configuration.

Arguments:

    Number - Supplies a pointer to count of the number of processors in
    the configuration.

    NewCount - Supplies the value to synchronize the counter too

Return Value:

    None.

--*/

{
    PKPCR pcr;
    ULONG64 perfCount;

    pcr = KeGetPcr();
    if (pcr->Number == 0) {

        //
        // Only execute on the boot processor.
        // 

        perfCount = QueryTimer().QuadPart;

        //
        // Compute how far the current count is from the target count,
        // and adjust TimerInfo.Bias accordingly.
        // 

        HalpTimeBias = NewCount - perfCount;
    }

    //
    // Wait for all processors to reach this point
    //

    InterlockedDecrement(Number); 
    while (*Number != 0) {
        PAUSE_PROCESSOR
    }
}


VOID
HalpSetMSRate(
    IN PTIMER_TABLE_ENTRY TableEntry
    )

/*++

Routine Description

    This routine programs the 8254 with a new rollover count.

Artuments

    TableEntry - Supplies a pointer to an entry within HalpTimerTable.

Return value:

    None.

--*/

{
    USHORT rollover;
    ULONG interruptsEnabled;

    //
    // Program the 8254 to generate the new timer interrupt rate.
    //

    rollover = TableEntry->RolloverCount;
    interruptsEnabled = HalpDisableInterrupts();

    WRITE_PORT_UCHAR(TIMER1_CONTROL_PORT,
                     TIMER_COMMAND_COUNTER0 +
                     TIMER_COMMAND_RW_16BIT +
                     TIMER_COMMAND_MODE2);
    IO_DELAY();

    WRITE_PORT_USHORT_PAIR (TIMER1_DATA_PORT0,
                            TIMER1_DATA_PORT0,
                            rollover);
    IO_DELAY();

    HalpRestoreInterrupts(interruptsEnabled);

    //
    // Recalibrate the timer watchdog
    // 

    HalpCalibrateWatchdog();

    //
    // Update the global representing the timer rate
    // 

    HalpCurrentMSRateTableIndex = (ULONG)(TableEntry - HalpTimerTable) - 1;
}

BOOLEAN
HalpClockInterrupt (
    IN PKINTERRUPT Interrupt,
    IN PVOID ServiceContext
    )

/*++

Routine Description

    This routine is entered as the result of an interrupt generated by CLOCK.
    Its function is to dismiss the interrupt, raise system Irql to
    CLOCK2_LEVEL, update performance counter and transfer control to the
    standard system routine to update the system time and the execution
    time of the current thread
    and process.

Arguments:

    Interrupt - Supplies a pointer to the interrupt object

    ServiceContext - Not used

Return value:

--*/

{
    ULONG timeIncrement;

    //
    // Capture the time increment for the now-occuring tick.  This is
    // done here because HalpCurrentMSRate will change if a rate change
    // is pending.
    //

    timeIncrement = HalpCurrentMSRate->TimeIncrement;

    //
    // Give the watchdog timer a chance to do its work
    //

    HalpCheckWatchdog();

    //
    // Check whether an MCA dpc should be queued
    //

    if (HalpClockMcaQueueDpc != FALSE) {
        HalpClockMcaQueueDpc = FALSE;
        HalpMcaQueueDpc();
    }

    //
    // Check whether the clock interrupt frequency should be changed.
    //

    if (HalpNextMSRate != NULL) {
        HalpNextMSRate = NULL;
        HalpSetMSRate(HalpNextMSRate);
    }

    //
    // Indicate to the kernel that a clock tick has occured.
    //

    KeUpdateSystemTime(Interrupt->TrapFrame,timeIncrement);

    return TRUE;
}

ULONG
HalpAcpiTimerSetTimeIncrement (
    IN ULONG DesiredIncrement
    )

/*++

Routine Description:

   This routine initialize system time clock to generate an
   interrupt at every DesiredIncrement interval.

Arguments:

    DesiredIncrement - desired interval between every timer tick (in
                       100ns unit.)

Return Value:

    The *REAL* time increment set.

--*/

{
    ULONG incMs;
    PTIMER_TABLE_ENTRY tableEntry;

    //
    // Convert the desired time inecrement to milliseconds
    //

    incMs = DesiredIncrement / 10000;

    //
    // Place the value within the range supported by this hal
    //

    if (incMs > MAX_TIMER_INCREMENT) {
        incMs = MAX_TIMER_INCREMENT;
    } else if (incMs < MIN_TIMER_INCREMENT) {
        incMs = MIN_TIMER_INCREMENT;
    }

    //
    // If the new rate is different than the current rate, indicate via
    // a non-null HalpNextMSRate that a new timer rate is expected.  This
    // will be done at the next timer ISR.
    // 

    tableEntry = &HalpTimerTable[incMs];
    if (tableEntry != HalpCurrentMSRate) {
        HalpNextMSRate = tableEntry;
    }

    //
    // Finally, return the timer increment that will actually be used.
    //

    return tableEntry->TimeIncrement;
}