2 Timer Architectural Protocol module using High Precesion Event Timer (HPET)
4 Copyright (c) 2011, Intel Corporation. All rights reserved.<BR>
5 This program and the accompanying materials
6 are licensed and made available under the terms and conditions of the BSD License
7 which accompanies this distribution. The full text of the license may be found at
8 http://opensource.org/licenses/bsd-license.php
10 THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,
11 WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.
17 #include <Protocol/Cpu.h>
18 #include <Protocol/Timer.h>
20 #include <Library/IoLib.h>
21 #include <Library/PcdLib.h>
22 #include <Library/BaseLib.h>
23 #include <Library/DebugLib.h>
24 #include <Library/UefiBootServicesTableLib.h>
25 #include <Library/LocalApicLib.h>
26 #include <Library/IoApicLib.h>
28 #include <Register/LocalApic.h>
29 #include <Register/IoApic.h>
30 #include <Register/Hpet.h>
33 /// Define value for an invalid HPET Timer index.
35 #define HPET_INVALID_TIMER_INDEX 0xff
38 /// Timer Architectural Protocol function prototypes.
42 This function registers the handler NotifyFunction so it is called every time
43 the timer interrupt fires. It also passes the amount of time since the last
44 handler call to the NotifyFunction. If NotifyFunction is NULL, then the
45 handler is unregistered. If the handler is registered, then EFI_SUCCESS is
46 returned. If the CPU does not support registering a timer interrupt handler,
47 then EFI_UNSUPPORTED is returned. If an attempt is made to register a handler
48 when a handler is already registered, then EFI_ALREADY_STARTED is returned.
49 If an attempt is made to unregister a handler when a handler is not registered,
50 then EFI_INVALID_PARAMETER is returned. If an error occurs attempting to
51 register the NotifyFunction with the timer interrupt, then EFI_DEVICE_ERROR
54 @param This The EFI_TIMER_ARCH_PROTOCOL instance.
55 @param NotifyFunction The function to call when a timer interrupt fires.
56 This function executes at TPL_HIGH_LEVEL. The DXE
57 Core will register a handler for the timer interrupt,
58 so it can know how much time has passed. This
59 information is used to signal timer based events.
60 NULL will unregister the handler.
62 @retval EFI_SUCCESS The timer handler was registered.
63 @retval EFI_UNSUPPORTED The platform does not support timer interrupts.
64 @retval EFI_ALREADY_STARTED NotifyFunction is not NULL, and a handler is already
66 @retval EFI_INVALID_PARAMETER NotifyFunction is NULL, and a handler was not
67 previously registered.
68 @retval EFI_DEVICE_ERROR The timer handler could not be registered.
73 TimerDriverRegisterHandler (
74 IN EFI_TIMER_ARCH_PROTOCOL
*This
,
75 IN EFI_TIMER_NOTIFY NotifyFunction
79 This function adjusts the period of timer interrupts to the value specified
80 by TimerPeriod. If the timer period is updated, then the selected timer
81 period is stored in EFI_TIMER.TimerPeriod, and EFI_SUCCESS is returned. If
82 the timer hardware is not programmable, then EFI_UNSUPPORTED is returned.
83 If an error occurs while attempting to update the timer period, then the
84 timer hardware will be put back in its state prior to this call, and
85 EFI_DEVICE_ERROR is returned. If TimerPeriod is 0, then the timer interrupt
86 is disabled. This is not the same as disabling the CPU's interrupts.
87 Instead, it must either turn off the timer hardware, or it must adjust the
88 interrupt controller so that a CPU interrupt is not generated when the timer
91 @param This The EFI_TIMER_ARCH_PROTOCOL instance.
92 @param TimerPeriod The rate to program the timer interrupt in 100 nS units.
93 If the timer hardware is not programmable, then
94 EFI_UNSUPPORTED is returned. If the timer is programmable,
95 then the timer period will be rounded up to the nearest
96 timer period that is supported by the timer hardware.
97 If TimerPeriod is set to 0, then the timer interrupts
100 @retval EFI_SUCCESS The timer period was changed.
101 @retval EFI_UNSUPPORTED The platform cannot change the period of the timer interrupt.
102 @retval EFI_DEVICE_ERROR The timer period could not be changed due to a device error.
107 TimerDriverSetTimerPeriod (
108 IN EFI_TIMER_ARCH_PROTOCOL
*This
,
109 IN UINT64 TimerPeriod
113 This function retrieves the period of timer interrupts in 100 ns units,
114 returns that value in TimerPeriod, and returns EFI_SUCCESS. If TimerPeriod
115 is NULL, then EFI_INVALID_PARAMETER is returned. If a TimerPeriod of 0 is
116 returned, then the timer is currently disabled.
118 @param This The EFI_TIMER_ARCH_PROTOCOL instance.
119 @param TimerPeriod A pointer to the timer period to retrieve in 100 ns units.
120 If 0 is returned, then the timer is currently disabled.
122 @retval EFI_SUCCESS The timer period was returned in TimerPeriod.
123 @retval EFI_INVALID_PARAMETER TimerPeriod is NULL.
128 TimerDriverGetTimerPeriod (
129 IN EFI_TIMER_ARCH_PROTOCOL
*This
,
130 OUT UINT64
*TimerPeriod
134 This function generates a soft timer interrupt. If the platform does not support soft
135 timer interrupts, then EFI_UNSUPPORTED is returned. Otherwise, EFI_SUCCESS is returned.
136 If a handler has been registered through the EFI_TIMER_ARCH_PROTOCOL.RegisterHandler()
137 service, then a soft timer interrupt will be generated. If the timer interrupt is
138 enabled when this service is called, then the registered handler will be invoked. The
139 registered handler should not be able to distinguish a hardware-generated timer
140 interrupt from a software-generated timer interrupt.
142 @param This The EFI_TIMER_ARCH_PROTOCOL instance.
144 @retval EFI_SUCCESS The soft timer interrupt was generated.
145 @retval EFI_UNSUPPORTEDT The platform does not support the generation of soft
151 TimerDriverGenerateSoftInterrupt (
152 IN EFI_TIMER_ARCH_PROTOCOL
*This
156 /// The handle onto which the Timer Architectural Protocol will be installed.
158 EFI_HANDLE mTimerHandle
= NULL
;
161 /// The Timer Architectural Protocol that this driver produces.
163 EFI_TIMER_ARCH_PROTOCOL mTimer
= {
164 TimerDriverRegisterHandler
,
165 TimerDriverSetTimerPeriod
,
166 TimerDriverGetTimerPeriod
,
167 TimerDriverGenerateSoftInterrupt
171 /// Pointer to the CPU Architectural Protocol instance.
173 EFI_CPU_ARCH_PROTOCOL
*mCpu
= NULL
;
176 /// The notification function to call on every timer interrupt.
178 EFI_TIMER_NOTIFY mTimerNotifyFunction
= NULL
;
181 /// The current period of the HPET timer interrupt in 100 ns units.
183 UINT64 mTimerPeriod
= 0;
186 /// The number of HPET timer ticks required for the current HPET rate specified by mTimerPeriod.
191 /// Mask used for counter and comparator calculations to adjust for a 32-bit or 64-bit counter.
196 /// The HPET main counter value from the most recent HPET timer interrupt.
198 volatile UINT64 mPreviousMainCounter
;
200 volatile UINT64 mPreviousComparator
;
203 /// The index of the HPET timer being managed by this driver.
208 /// The I/O APIC IRQ that the HPET Timer is mapped if I/O APIC mode is used.
213 /// Cached state of the HPET General Capabilities register managed by this driver.
214 /// Caching the state reduces the number of times the configuration register is read.
216 HPET_GENERAL_CAPABILITIES_ID_REGISTER mHpetGeneralCapabilities
;
219 /// Cached state of the HPET General Configuration register managed by this driver.
220 /// Caching the state reduces the number of times the configuration register is read.
222 HPET_GENERAL_CONFIGURATION_REGISTER mHpetGeneralConfiguration
;
225 /// Cached state of the Configuration register for the HPET Timer managed by
226 /// this driver. Caching the state reduces the number of times the configuration
227 /// register is read.
229 HPET_TIMER_CONFIGURATION_REGISTER mTimerConfiguration
;
232 /// Counts the number of HPET Timer interrupts processed by this driver.
233 /// Only required for debug.
235 volatile UINTN mNumTicks
;
238 Read a 64-bit register from the HPET
240 @param Offset Specifies the offset of the HPET register to read.
242 @return The 64-bit value read from the HPET register specified by Offset.
249 return MmioRead64 (PcdGet32 (PcdHpetBaseAddress
) + Offset
);
253 Write a 64-bit HPET register.
255 @param Offset Specifies the ofsfert of the HPET register to write.
256 @param Value Specifies the value to write to the HPET register specified by Offset.
258 @return The 64-bit value written to HPET register specified by Offset.
266 return MmioWrite64 (PcdGet32 (PcdHpetBaseAddress
) + Offset
, Value
);
270 Enable or disable the main counter in the HPET Timer.
272 @param Enable If TRUE, then enable the main counter in the HPET Timer.
273 If FALSE, then disable the main counter in the HPET Timer.
280 mHpetGeneralConfiguration
.Bits
.MainCounterEnable
= Enable
? 1 : 0;
281 HpetWrite (HPET_GENERAL_CONFIGURATION_OFFSET
, mHpetGeneralConfiguration
.Uint64
);
285 The interrupt handler for the HPET timer. This handler clears the HPET interrupt
286 and computes the amount of time that has passed since the last HPET timer interrupt.
287 If a notification function is registered, then the amount of time since the last
288 HPET interrupt is passed to that notification function in 100 ns units. The HPET
289 time is updated to generate another interrupt in the required time period.
291 @param InterruptType The type of interrupt that occured.
292 @param SystemContext A pointer to the system context when the interrupt occured.
296 TimerInterruptHandler (
297 IN EFI_EXCEPTION_TYPE InterruptType
,
298 IN EFI_SYSTEM_CONTEXT SystemContext
307 // Count number of ticks
309 DEBUG_CODE (mNumTicks
++;);
312 // Clear HPET timer interrupt status
314 HpetWrite (HPET_GENERAL_INTERRUPT_STATUS_OFFSET
, LShiftU64 (1, mTimerIndex
));
322 // Disable HPET timer when adjusting the COMPARATOR value to prevent a missed interrupt
327 // Capture main counter value
329 MainCounter
= HpetRead (HPET_MAIN_COUNTER_OFFSET
);
332 // Get the previous comparator counter
334 mPreviousComparator
= HpetRead (HPET_TIMER_COMPARATOR_OFFSET
+ mTimerIndex
* HPET_TIMER_STRIDE
);
337 // Set HPET COMPARATOR to the value required for the next timer tick
339 Comparator
= (mPreviousComparator
+ mTimerCount
) & mCounterMask
;
341 if ((mPreviousMainCounter
< MainCounter
) && (mPreviousComparator
> Comparator
)) {
343 // When comparator overflows
345 HpetWrite (HPET_TIMER_COMPARATOR_OFFSET
+ mTimerIndex
* HPET_TIMER_STRIDE
, Comparator
);
346 } else if ((mPreviousMainCounter
> MainCounter
) && (mPreviousComparator
< Comparator
)) {
348 // When main counter overflows
350 HpetWrite (HPET_TIMER_COMPARATOR_OFFSET
+ mTimerIndex
* HPET_TIMER_STRIDE
, (MainCounter
+ mTimerCount
) & mCounterMask
);
353 // When both main counter and comparator do not overflow or both do overflow
355 if (Comparator
> MainCounter
) {
356 HpetWrite (HPET_TIMER_COMPARATOR_OFFSET
+ mTimerIndex
* HPET_TIMER_STRIDE
, Comparator
);
358 HpetWrite (HPET_TIMER_COMPARATOR_OFFSET
+ mTimerIndex
* HPET_TIMER_STRIDE
, (MainCounter
+ mTimerCount
) & mCounterMask
);
363 // Enable the HPET counter once the new COMPARATOR value has been set.
368 // Check to see if there is a registered notification function
370 if (mTimerNotifyFunction
!= NULL
) {
372 // Compute time since last notification in 100 ns units (10 ^ -7)
374 if (MainCounter
> mPreviousMainCounter
) {
376 // Main counter does not overflow
378 Delta
= MainCounter
- mPreviousMainCounter
;
381 // Main counter overflows, first usb, then add
383 Delta
= (mCounterMask
- mPreviousMainCounter
) + MainCounter
;
385 TimerPeriod
= DivU64x32 (
387 Delta
& mCounterMask
,
388 mHpetGeneralCapabilities
.Bits
.CounterClockPeriod
394 // Call registered notification function passing in the time since the last
395 // interrupt in 100 ns units.
397 mTimerNotifyFunction (TimerPeriod
);
401 // Save main counter value
403 mPreviousMainCounter
= MainCounter
;
407 This function registers the handler NotifyFunction so it is called every time
408 the timer interrupt fires. It also passes the amount of time since the last
409 handler call to the NotifyFunction. If NotifyFunction is NULL, then the
410 handler is unregistered. If the handler is registered, then EFI_SUCCESS is
411 returned. If the CPU does not support registering a timer interrupt handler,
412 then EFI_UNSUPPORTED is returned. If an attempt is made to register a handler
413 when a handler is already registered, then EFI_ALREADY_STARTED is returned.
414 If an attempt is made to unregister a handler when a handler is not registered,
415 then EFI_INVALID_PARAMETER is returned. If an error occurs attempting to
416 register the NotifyFunction with the timer interrupt, then EFI_DEVICE_ERROR
419 @param This The EFI_TIMER_ARCH_PROTOCOL instance.
420 @param NotifyFunction The function to call when a timer interrupt fires.
421 This function executes at TPL_HIGH_LEVEL. The DXE
422 Core will register a handler for the timer interrupt,
423 so it can know how much time has passed. This
424 information is used to signal timer based events.
425 NULL will unregister the handler.
427 @retval EFI_SUCCESS The timer handler was registered.
428 @retval EFI_UNSUPPORTED The platform does not support timer interrupts.
429 @retval EFI_ALREADY_STARTED NotifyFunction is not NULL, and a handler is already
431 @retval EFI_INVALID_PARAMETER NotifyFunction is NULL, and a handler was not
432 previously registered.
433 @retval EFI_DEVICE_ERROR The timer handler could not be registered.
438 TimerDriverRegisterHandler (
439 IN EFI_TIMER_ARCH_PROTOCOL
*This
,
440 IN EFI_TIMER_NOTIFY NotifyFunction
444 // Check for invalid parameters
446 if (NotifyFunction
== NULL
&& mTimerNotifyFunction
== NULL
) {
447 return EFI_INVALID_PARAMETER
;
449 if (NotifyFunction
!= NULL
&& mTimerNotifyFunction
!= NULL
) {
450 return EFI_ALREADY_STARTED
;
454 // Cache the registered notification function
456 mTimerNotifyFunction
= NotifyFunction
;
462 This function adjusts the period of timer interrupts to the value specified
463 by TimerPeriod. If the timer period is updated, then the selected timer
464 period is stored in EFI_TIMER.TimerPeriod, and EFI_SUCCESS is returned. If
465 the timer hardware is not programmable, then EFI_UNSUPPORTED is returned.
466 If an error occurs while attempting to update the timer period, then the
467 timer hardware will be put back in its state prior to this call, and
468 EFI_DEVICE_ERROR is returned. If TimerPeriod is 0, then the timer interrupt
469 is disabled. This is not the same as disabling the CPU's interrupts.
470 Instead, it must either turn off the timer hardware, or it must adjust the
471 interrupt controller so that a CPU interrupt is not generated when the timer
474 @param This The EFI_TIMER_ARCH_PROTOCOL instance.
475 @param TimerPeriod The rate to program the timer interrupt in 100 nS units.
476 If the timer hardware is not programmable, then
477 EFI_UNSUPPORTED is returned. If the timer is programmable,
478 then the timer period will be rounded up to the nearest
479 timer period that is supported by the timer hardware.
480 If TimerPeriod is set to 0, then the timer interrupts
483 @retval EFI_SUCCESS The timer period was changed.
484 @retval EFI_UNSUPPORTED The platform cannot change the period of the timer interrupt.
485 @retval EFI_DEVICE_ERROR The timer period could not be changed due to a device error.
490 TimerDriverSetTimerPeriod (
491 IN EFI_TIMER_ARCH_PROTOCOL
*This
,
492 IN UINT64 TimerPeriod
497 UINT64 CurrentComparator
;
500 // Disable HPET timer when adjusting the timer period
504 if (TimerPeriod
== 0) {
505 if (mTimerPeriod
!= 0) {
507 // Check if there is possibly a pending interrupt
509 MainCounter
= HpetRead (HPET_MAIN_COUNTER_OFFSET
);
510 if (MainCounter
< mPreviousMainCounter
) {
511 Delta
= (mCounterMask
- mPreviousMainCounter
) + MainCounter
;
513 Delta
= MainCounter
- mPreviousMainCounter
;
515 if ((Delta
& mCounterMask
) >= mTimerCount
) {
517 // Interrupt still happens after disable HPET, wait to be processed
518 // Wait until interrupt is processed and comparator is increased
520 CurrentComparator
= HpetRead (HPET_TIMER_COMPARATOR_OFFSET
+ mTimerIndex
* HPET_TIMER_STRIDE
);
521 while (CurrentComparator
== mPreviousComparator
) {
522 CurrentComparator
= HpetRead (HPET_TIMER_COMPARATOR_OFFSET
+ mTimerIndex
* HPET_TIMER_STRIDE
);
529 // If TimerPeriod is 0, then mask HPET Timer interrupts
532 if (mTimerConfiguration
.Bits
.MsiInterruptCapablity
!= 0 && FeaturePcdGet (PcdHpetMsiEnable
)) {
534 // Disable HPET MSI interrupt generation
536 mTimerConfiguration
.Bits
.MsiInterruptEnable
= 0;
539 // Disable I/O APIC Interrupt
541 IoApicEnableInterrupt (mTimerIrq
, FALSE
);
545 // Disable HPET timer interrupt
547 mTimerConfiguration
.Bits
.InterruptEnable
= 0;
548 HpetWrite (HPET_TIMER_CONFIGURATION_OFFSET
+ mTimerIndex
* HPET_TIMER_STRIDE
, mTimerConfiguration
.Uint64
);
551 // Convert TimerPeriod to femtoseconds and divide by the number if femtoseconds
552 // per tick of the HPET counter to determine the number of HPET counter ticks
553 // in TimerPeriod 100 ns units.
555 mTimerCount
= DivU64x32 (
556 MultU64x32 (TimerPeriod
, 100000000),
557 mHpetGeneralCapabilities
.Bits
.CounterClockPeriod
561 // Program the HPET Comparator with the number of ticks till the next interrupt
563 MainCounter
= HpetRead (HPET_MAIN_COUNTER_OFFSET
);
564 if (MainCounter
> mPreviousMainCounter
) {
565 Delta
= MainCounter
- mPreviousMainCounter
;
567 Delta
= (mCounterMask
- mPreviousMainCounter
) + MainCounter
;
569 if ((Delta
& mCounterMask
) >= mTimerCount
) {
570 HpetWrite (HPET_TIMER_COMPARATOR_OFFSET
+ mTimerIndex
* HPET_TIMER_STRIDE
, (MainCounter
+ 1) & mCounterMask
);
572 HpetWrite (HPET_TIMER_COMPARATOR_OFFSET
+ mTimerIndex
* HPET_TIMER_STRIDE
, (mPreviousMainCounter
+ mTimerCount
) & mCounterMask
);
576 // Enable HPET Timer interrupt generation
578 if (mTimerConfiguration
.Bits
.MsiInterruptCapablity
!= 0 && FeaturePcdGet (PcdHpetMsiEnable
)) {
580 // Enable HPET MSI Interrupt
582 mTimerConfiguration
.Bits
.MsiInterruptEnable
= 1;
585 // Enable timer interrupt through I/O APIC
587 IoApicEnableInterrupt (mTimerIrq
, TRUE
);
591 // Enable HPET Interrupt Generation
593 mTimerConfiguration
.Bits
.InterruptEnable
= 1;
594 HpetWrite (HPET_TIMER_CONFIGURATION_OFFSET
+ mTimerIndex
* HPET_TIMER_STRIDE
, mTimerConfiguration
.Uint64
);
598 // Save the new timer period
600 mTimerPeriod
= TimerPeriod
;
603 // Enable the HPET counter once new timer period has been established
604 // The HPET counter should run even if the HPET Timer interrupts are
605 // disabled. This is used to account for time passed while the interrupt
614 This function retrieves the period of timer interrupts in 100 ns units,
615 returns that value in TimerPeriod, and returns EFI_SUCCESS. If TimerPeriod
616 is NULL, then EFI_INVALID_PARAMETER is returned. If a TimerPeriod of 0 is
617 returned, then the timer is currently disabled.
619 @param This The EFI_TIMER_ARCH_PROTOCOL instance.
620 @param TimerPeriod A pointer to the timer period to retrieve in 100 ns units.
621 If 0 is returned, then the timer is currently disabled.
623 @retval EFI_SUCCESS The timer period was returned in TimerPeriod.
624 @retval EFI_INVALID_PARAMETER TimerPeriod is NULL.
629 TimerDriverGetTimerPeriod (
630 IN EFI_TIMER_ARCH_PROTOCOL
*This
,
631 OUT UINT64
*TimerPeriod
634 if (TimerPeriod
== NULL
) {
635 return EFI_INVALID_PARAMETER
;
638 *TimerPeriod
= mTimerPeriod
;
644 This function generates a soft timer interrupt. If the platform does not support soft
645 timer interrupts, then EFI_UNSUPPORTED is returned. Otherwise, EFI_SUCCESS is returned.
646 If a handler has been registered through the EFI_TIMER_ARCH_PROTOCOL.RegisterHandler()
647 service, then a soft timer interrupt will be generated. If the timer interrupt is
648 enabled when this service is called, then the registered handler will be invoked. The
649 registered handler should not be able to distinguish a hardware-generated timer
650 interrupt from a software-generated timer interrupt.
652 @param This The EFI_TIMER_ARCH_PROTOCOL instance.
654 @retval EFI_SUCCESS The soft timer interrupt was generated.
655 @retval EFI_UNSUPPORTEDT The platform does not support the generation of soft
661 TimerDriverGenerateSoftInterrupt (
662 IN EFI_TIMER_ARCH_PROTOCOL
*This
671 // Disable interrupts
673 Tpl
= gBS
->RaiseTPL (TPL_HIGH_LEVEL
);
676 // Capture main counter value
678 MainCounter
= HpetRead (HPET_MAIN_COUNTER_OFFSET
);
681 // Check to see if there is a registered notification function
683 if (mTimerNotifyFunction
!= NULL
) {
685 // Compute time since last interrupt in 100 ns units (10 ^ -7)
687 if (MainCounter
> mPreviousMainCounter
) {
689 // Main counter does not overflow
691 Delta
= MainCounter
- mPreviousMainCounter
;
694 // Main counter overflows, first usb, then add
696 Delta
= (mCounterMask
- mPreviousMainCounter
) + MainCounter
;
699 TimerPeriod
= DivU64x32 (
701 Delta
& mCounterMask
,
702 mHpetGeneralCapabilities
.Bits
.CounterClockPeriod
708 // Call registered notification function passing in the time since the last
709 // interrupt in 100 ns units.
711 mTimerNotifyFunction (TimerPeriod
);
715 // Save main counter value
717 mPreviousMainCounter
= MainCounter
;
720 // Restore interrupts
722 gBS
->RestoreTPL (Tpl
);
728 Initialize the Timer Architectural Protocol driver
730 @param ImageHandle ImageHandle of the loaded driver
731 @param SystemTable Pointer to the System Table
733 @retval EFI_SUCCESS Timer Architectural Protocol created
734 @retval EFI_OUT_OF_RESOURCES Not enough resources available to initialize driver.
735 @retval EFI_DEVICE_ERROR A device error occured attempting to initialize the driver.
740 TimerDriverInitialize (
741 IN EFI_HANDLE ImageHandle
,
742 IN EFI_SYSTEM_TABLE
*SystemTable
748 HPET_TIMER_MSI_ROUTE_REGISTER HpetTimerMsiRoute
;
750 DEBUG ((DEBUG_INFO
, "Init HPET Timer Driver\n"));
753 // Make sure the Timer Architectural Protocol is not already installed in the system
755 ASSERT_PROTOCOL_ALREADY_INSTALLED (NULL
, &gEfiTimerArchProtocolGuid
);
758 // Find the CPU architectural protocol.
760 Status
= gBS
->LocateProtocol (&gEfiCpuArchProtocolGuid
, NULL
, (VOID
**) &mCpu
);
761 ASSERT_EFI_ERROR (Status
);
764 // Retrieve HPET Capabilities and Configuration Information
766 mHpetGeneralCapabilities
.Uint64
= HpetRead (HPET_GENERAL_CAPABILITIES_ID_OFFSET
);
767 mHpetGeneralConfiguration
.Uint64
= HpetRead (HPET_GENERAL_CONFIGURATION_OFFSET
);
770 // If Revision is not valid, then ASSERT() and unload the driver because the HPET
771 // device is not present.
773 ASSERT (mHpetGeneralCapabilities
.Uint64
!= 0);
774 ASSERT (mHpetGeneralCapabilities
.Uint64
!= 0xFFFFFFFFFFFFFFFFULL
);
775 if (mHpetGeneralCapabilities
.Uint64
== 0 || mHpetGeneralCapabilities
.Uint64
== 0xFFFFFFFFFFFFFFFFULL
) {
776 DEBUG ((DEBUG_ERROR
, "HPET device is not present. Unload HPET driver.\n"));
777 return EFI_DEVICE_ERROR
;
781 // Force the HPET timer to be disabled while setting everything up
786 // Dump HPET Configuration Information
789 DEBUG ((DEBUG_INFO
, "HPET Base Address = 0x%08x\n", PcdGet32 (PcdHpetBaseAddress
)));
790 DEBUG ((DEBUG_INFO
, " HPET_GENERAL_CAPABILITIES_ID = 0x%016lx\n", mHpetGeneralCapabilities
));
791 DEBUG ((DEBUG_INFO
, " HPET_GENERAL_CONFIGURATION = 0x%016lx\n", mHpetGeneralConfiguration
.Uint64
));
792 DEBUG ((DEBUG_INFO
, " HPET_GENERAL_INTERRUPT_STATUS = 0x%016lx\n", HpetRead (HPET_GENERAL_INTERRUPT_STATUS_OFFSET
)));
793 DEBUG ((DEBUG_INFO
, " HPET_MAIN_COUNTER = 0x%016lx\n", HpetRead (HPET_MAIN_COUNTER_OFFSET
)));
794 DEBUG ((DEBUG_INFO
, " HPET Main Counter Period = %d (fs)\n", mHpetGeneralCapabilities
.Bits
.CounterClockPeriod
));
795 for (TimerIndex
= 0; TimerIndex
<= mHpetGeneralCapabilities
.Bits
.NumberOfTimers
; TimerIndex
++) {
796 DEBUG ((DEBUG_INFO
, " HPET_TIMER%d_CONFIGURATION = 0x%016lx\n", TimerIndex
, HpetRead (HPET_TIMER_CONFIGURATION_OFFSET
+ TimerIndex
* HPET_TIMER_STRIDE
)));
797 DEBUG ((DEBUG_INFO
, " HPET_TIMER%d_COMPARATOR = 0x%016lx\n", TimerIndex
, HpetRead (HPET_TIMER_COMPARATOR_OFFSET
+ TimerIndex
* HPET_TIMER_STRIDE
)));
798 DEBUG ((DEBUG_INFO
, " HPET_TIMER%d_MSI_ROUTE = 0x%016lx\n", TimerIndex
, HpetRead (HPET_TIMER_MSI_ROUTE_OFFSET
+ TimerIndex
* HPET_TIMER_STRIDE
)));
803 // Capture the current HPET main counter value.
805 mPreviousMainCounter
= HpetRead (HPET_MAIN_COUNTER_OFFSET
);
808 // Determine the interrupt mode to use for the HPET Timer.
809 // Look for MSI first, then unused PIC mode interrupt, then I/O APIC mode interrupt
811 MsiTimerIndex
= HPET_INVALID_TIMER_INDEX
;
812 mTimerIndex
= HPET_INVALID_TIMER_INDEX
;
813 for (TimerIndex
= 0; TimerIndex
<= mHpetGeneralCapabilities
.Bits
.NumberOfTimers
; TimerIndex
++) {
815 // Read the HPET Timer Capabilities and Configuration register
817 mTimerConfiguration
.Uint64
= HpetRead (HPET_TIMER_CONFIGURATION_OFFSET
+ TimerIndex
* HPET_TIMER_STRIDE
);
820 // Check to see if this HPET Timer supports MSI
822 if (mTimerConfiguration
.Bits
.MsiInterruptCapablity
!= 0) {
824 // Save the index of the first HPET Timer that supports MSI interrupts
826 if (MsiTimerIndex
== HPET_INVALID_TIMER_INDEX
) {
827 MsiTimerIndex
= TimerIndex
;
832 // Check to see if this HPET Timer supports I/O APIC interrupts
834 if (mTimerConfiguration
.Bits
.InterruptRouteCapability
!= 0) {
836 // Save the index of the first HPET Timer that supports I/O APIC interrupts
838 if (mTimerIndex
== HPET_INVALID_TIMER_INDEX
) {
839 mTimerIndex
= TimerIndex
;
840 mTimerIrq
= (UINT32
)LowBitSet32 (mTimerConfiguration
.Bits
.InterruptRouteCapability
);
845 if (FeaturePcdGet (PcdHpetMsiEnable
) && MsiTimerIndex
!= HPET_INVALID_TIMER_INDEX
) {
847 // Use MSI interrupt if supported
849 mTimerIndex
= MsiTimerIndex
;
852 // Program MSI Address and MSI Data values in the selected HPET Timer
854 HpetTimerMsiRoute
.Bits
.Address
= GetApicMsiAddress ();
855 HpetTimerMsiRoute
.Bits
.Value
= (UINT32
)GetApicMsiValue (PcdGet8 (PcdHpetLocalApicVector
), LOCAL_APIC_DELIVERY_MODE_LOWEST_PRIORITY
, FALSE
, FALSE
);
856 HpetWrite (HPET_TIMER_MSI_ROUTE_OFFSET
+ mTimerIndex
* HPET_TIMER_STRIDE
, HpetTimerMsiRoute
.Uint64
);
859 // Read the HPET Timer Capabilities and Configuration register and initialize for MSI mode
860 // Clear LevelTriggeredInterrupt to use edge triggered interrupts when in MSI mode
862 mTimerConfiguration
.Uint64
= HpetRead (HPET_TIMER_CONFIGURATION_OFFSET
+ mTimerIndex
* HPET_TIMER_STRIDE
);
863 mTimerConfiguration
.Bits
.LevelTriggeredInterrupt
= 0;
866 // If no HPET timers support MSI or I/O APIC modes, then ASSERT() and unload the driver.
868 ASSERT (mTimerIndex
!= HPET_INVALID_TIMER_INDEX
);
869 if (mTimerIndex
== HPET_INVALID_TIMER_INDEX
) {
870 DEBUG ((DEBUG_ERROR
, "No HPET timers support MSI or I/O APIC mode. Unload HPET driver.\n"));
871 return EFI_DEVICE_ERROR
;
875 // Initialize I/O APIC entry for HPET Timer Interrupt
876 // Fixed Delivery Mode, Level Triggered, Asserted Low
878 IoApicConfigureInterrupt (mTimerIrq
, PcdGet8 (PcdHpetLocalApicVector
), IO_APIC_DELIVERY_MODE_LOWEST_PRIORITY
, TRUE
, FALSE
);
881 // Read the HPET Timer Capabilities and Configuration register and initialize for I/O APIC mode
882 // Clear MsiInterruptCapability to force rest of driver to use I/O APIC mode
883 // Set LevelTriggeredInterrupt to use level triggered interrupts when in I/O APIC mode
884 // Set InterruptRoute field based in mTimerIrq
886 mTimerConfiguration
.Uint64
= HpetRead (HPET_TIMER_CONFIGURATION_OFFSET
+ mTimerIndex
* HPET_TIMER_STRIDE
);
887 mTimerConfiguration
.Bits
.LevelTriggeredInterrupt
= 1;
888 mTimerConfiguration
.Bits
.InterruptRoute
= mTimerIrq
;
892 // Configure the selected HPET Timer with settings common to both MSI mode and I/O APIC mode
893 // Clear InterruptEnable to keep interrupts disabled until full init is complete
894 // Clear PeriodicInterruptEnable to use one-shot mode
895 // Configure as a 32-bit counter
897 mTimerConfiguration
.Bits
.InterruptEnable
= 0;
898 mTimerConfiguration
.Bits
.PeriodicInterruptEnable
= 0;
899 mTimerConfiguration
.Bits
.CounterSizeEnable
= 1;
900 HpetWrite (HPET_TIMER_CONFIGURATION_OFFSET
+ mTimerIndex
* HPET_TIMER_STRIDE
, mTimerConfiguration
.Uint64
);
903 // Read the HPET Timer Capabilities and Configuration register back again.
904 // CounterSizeEnable will be read back as a 0 if it is a 32-bit only timer
906 mTimerConfiguration
.Uint64
= HpetRead (HPET_TIMER_CONFIGURATION_OFFSET
+ mTimerIndex
* HPET_TIMER_STRIDE
);
907 if ((mTimerConfiguration
.Bits
.CounterSizeEnable
== 1) && (sizeof (UINTN
) == sizeof (UINT64
))) {
908 DEBUG ((DEBUG_INFO
, "Choose 64-bit HPET timer.\n"));
910 // 64-bit BIOS can use 64-bit HPET timer
912 mCounterMask
= 0xffffffffffffffffULL
;
914 // Set timer back to 64-bit
916 mTimerConfiguration
.Bits
.CounterSizeEnable
= 0;
917 HpetWrite (HPET_TIMER_CONFIGURATION_OFFSET
+ mTimerIndex
* HPET_TIMER_STRIDE
, mTimerConfiguration
.Uint64
);
919 DEBUG ((DEBUG_INFO
, "Choose 32-bit HPET timer.\n"));
920 mCounterMask
= 0x00000000ffffffffULL
;
924 // Install interrupt handler for selected HPET Timer
926 Status
= mCpu
->RegisterInterruptHandler (mCpu
, PcdGet8 (PcdHpetLocalApicVector
), TimerInterruptHandler
);
927 ASSERT_EFI_ERROR (Status
);
928 if (EFI_ERROR (Status
)) {
929 DEBUG ((DEBUG_ERROR
, "Unable to register HPET interrupt with CPU Arch Protocol. Unload HPET driver.\n"));
930 return EFI_DEVICE_ERROR
;
934 // Force the HPET Timer to be enabled at its default period
936 Status
= TimerDriverSetTimerPeriod (&mTimer
, PcdGet64 (PcdHpetDefaultTimerPeriod
));
937 ASSERT_EFI_ERROR (Status
);
938 if (EFI_ERROR (Status
)) {
939 DEBUG ((DEBUG_ERROR
, "Unable to set HPET default timer rate. Unload HPET driver.\n"));
940 return EFI_DEVICE_ERROR
;
944 // Show state of enabled HPET timer
947 if (mTimerConfiguration
.Bits
.MsiInterruptCapablity
!= 0 && FeaturePcdGet (PcdHpetMsiEnable
)) {
948 DEBUG ((DEBUG_INFO
, "HPET Interrupt Mode MSI\n"));
950 DEBUG ((DEBUG_INFO
, "HPET Interrupt Mode I/O APIC\n"));
951 DEBUG ((DEBUG_INFO
, "HPET I/O APIC IRQ = 0x%02x\n", mTimerIrq
));
953 DEBUG ((DEBUG_INFO
, "HPET Interrupt Vector = 0x%02x\n", PcdGet8 (PcdHpetLocalApicVector
)));
954 DEBUG ((DEBUG_INFO
, "HPET Counter Mask = 0x%016lx\n", mCounterMask
));
955 DEBUG ((DEBUG_INFO
, "HPET Timer Period = %d\n", mTimerPeriod
));
956 DEBUG ((DEBUG_INFO
, "HPET Timer Count = 0x%016lx\n", mTimerCount
));
957 DEBUG ((DEBUG_INFO
, "HPET_TIMER%d_CONFIGURATION = 0x%016lx\n", mTimerIndex
, HpetRead (HPET_TIMER_CONFIGURATION_OFFSET
+ mTimerIndex
* HPET_TIMER_STRIDE
)));
958 DEBUG ((DEBUG_INFO
, "HPET_TIMER%d_COMPARATOR = 0x%016lx\n", mTimerIndex
, HpetRead (HPET_TIMER_COMPARATOR_OFFSET
+ mTimerIndex
* HPET_TIMER_STRIDE
)));
959 DEBUG ((DEBUG_INFO
, "HPET_TIMER%d_MSI_ROUTE = 0x%016lx\n", mTimerIndex
, HpetRead (HPET_TIMER_MSI_ROUTE_OFFSET
+ mTimerIndex
* HPET_TIMER_STRIDE
)));
962 // Wait for a few timer interrupts to fire before continuing
964 while (mNumTicks
< 10);
968 // Install the Timer Architectural Protocol onto a new handle
970 Status
= gBS
->InstallMultipleProtocolInterfaces (
972 &gEfiTimerArchProtocolGuid
, &mTimer
,
975 ASSERT_EFI_ERROR (Status
);