2 Timer Architectural Protocol module using High Precision Event Timer (HPET)
4 Copyright (c) 2011 - 2018, Intel Corporation. All rights reserved.<BR>
5 SPDX-License-Identifier: BSD-2-Clause-Patent
11 #include <Protocol/Cpu.h>
12 #include <Protocol/Timer.h>
14 #include <Library/IoLib.h>
15 #include <Library/PcdLib.h>
16 #include <Library/BaseLib.h>
17 #include <Library/DebugLib.h>
18 #include <Library/UefiBootServicesTableLib.h>
19 #include <Library/LocalApicLib.h>
20 #include <Library/IoApicLib.h>
22 #include <Register/LocalApic.h>
23 #include <Register/IoApic.h>
24 #include <Register/Hpet.h>
27 /// Define value for an invalid HPET Timer index.
29 #define HPET_INVALID_TIMER_INDEX 0xff
32 /// Timer Architectural Protocol function prototypes.
36 This function registers the handler NotifyFunction so it is called every time
37 the timer interrupt fires. It also passes the amount of time since the last
38 handler call to the NotifyFunction. If NotifyFunction is NULL, then the
39 handler is unregistered. If the handler is registered, then EFI_SUCCESS is
40 returned. If the CPU does not support registering a timer interrupt handler,
41 then EFI_UNSUPPORTED is returned. If an attempt is made to register a handler
42 when a handler is already registered, then EFI_ALREADY_STARTED is returned.
43 If an attempt is made to unregister a handler when a handler is not registered,
44 then EFI_INVALID_PARAMETER is returned. If an error occurs attempting to
45 register the NotifyFunction with the timer interrupt, then EFI_DEVICE_ERROR
48 @param This The EFI_TIMER_ARCH_PROTOCOL instance.
49 @param NotifyFunction The function to call when a timer interrupt fires.
50 This function executes at TPL_HIGH_LEVEL. The DXE
51 Core will register a handler for the timer interrupt,
52 so it can know how much time has passed. This
53 information is used to signal timer based events.
54 NULL will unregister the handler.
56 @retval EFI_SUCCESS The timer handler was registered.
57 @retval EFI_UNSUPPORTED The platform does not support timer interrupts.
58 @retval EFI_ALREADY_STARTED NotifyFunction is not NULL, and a handler is already
60 @retval EFI_INVALID_PARAMETER NotifyFunction is NULL, and a handler was not
61 previously registered.
62 @retval EFI_DEVICE_ERROR The timer handler could not be registered.
67 TimerDriverRegisterHandler (
68 IN EFI_TIMER_ARCH_PROTOCOL
*This
,
69 IN EFI_TIMER_NOTIFY NotifyFunction
73 This function adjusts the period of timer interrupts to the value specified
74 by TimerPeriod. If the timer period is updated, then the selected timer
75 period is stored in EFI_TIMER.TimerPeriod, and EFI_SUCCESS is returned. If
76 the timer hardware is not programmable, then EFI_UNSUPPORTED is returned.
77 If an error occurs while attempting to update the timer period, then the
78 timer hardware will be put back in its state prior to this call, and
79 EFI_DEVICE_ERROR is returned. If TimerPeriod is 0, then the timer interrupt
80 is disabled. This is not the same as disabling the CPU's interrupts.
81 Instead, it must either turn off the timer hardware, or it must adjust the
82 interrupt controller so that a CPU interrupt is not generated when the timer
85 @param This The EFI_TIMER_ARCH_PROTOCOL instance.
86 @param TimerPeriod The rate to program the timer interrupt in 100 nS units.
87 If the timer hardware is not programmable, then
88 EFI_UNSUPPORTED is returned. If the timer is programmable,
89 then the timer period will be rounded up to the nearest
90 timer period that is supported by the timer hardware.
91 If TimerPeriod is set to 0, then the timer interrupts
94 @retval EFI_SUCCESS The timer period was changed.
95 @retval EFI_UNSUPPORTED The platform cannot change the period of the timer interrupt.
96 @retval EFI_DEVICE_ERROR The timer period could not be changed due to a device error.
101 TimerDriverSetTimerPeriod (
102 IN EFI_TIMER_ARCH_PROTOCOL
*This
,
103 IN UINT64 TimerPeriod
107 This function retrieves the period of timer interrupts in 100 ns units,
108 returns that value in TimerPeriod, and returns EFI_SUCCESS. If TimerPeriod
109 is NULL, then EFI_INVALID_PARAMETER is returned. If a TimerPeriod of 0 is
110 returned, then the timer is currently disabled.
112 @param This The EFI_TIMER_ARCH_PROTOCOL instance.
113 @param TimerPeriod A pointer to the timer period to retrieve in 100 ns units.
114 If 0 is returned, then the timer is currently disabled.
116 @retval EFI_SUCCESS The timer period was returned in TimerPeriod.
117 @retval EFI_INVALID_PARAMETER TimerPeriod is NULL.
122 TimerDriverGetTimerPeriod (
123 IN EFI_TIMER_ARCH_PROTOCOL
*This
,
124 OUT UINT64
*TimerPeriod
128 This function generates a soft timer interrupt. If the platform does not support soft
129 timer interrupts, then EFI_UNSUPPORTED is returned. Otherwise, EFI_SUCCESS is returned.
130 If a handler has been registered through the EFI_TIMER_ARCH_PROTOCOL.RegisterHandler()
131 service, then a soft timer interrupt will be generated. If the timer interrupt is
132 enabled when this service is called, then the registered handler will be invoked. The
133 registered handler should not be able to distinguish a hardware-generated timer
134 interrupt from a software-generated timer interrupt.
136 @param This The EFI_TIMER_ARCH_PROTOCOL instance.
138 @retval EFI_SUCCESS The soft timer interrupt was generated.
139 @retval EFI_UNSUPPORTED The platform does not support the generation of soft
145 TimerDriverGenerateSoftInterrupt (
146 IN EFI_TIMER_ARCH_PROTOCOL
*This
150 /// The handle onto which the Timer Architectural Protocol will be installed.
152 EFI_HANDLE mTimerHandle
= NULL
;
155 /// The Timer Architectural Protocol that this driver produces.
157 EFI_TIMER_ARCH_PROTOCOL mTimer
= {
158 TimerDriverRegisterHandler
,
159 TimerDriverSetTimerPeriod
,
160 TimerDriverGetTimerPeriod
,
161 TimerDriverGenerateSoftInterrupt
165 /// Pointer to the CPU Architectural Protocol instance.
167 EFI_CPU_ARCH_PROTOCOL
*mCpu
= NULL
;
170 /// The notification function to call on every timer interrupt.
172 EFI_TIMER_NOTIFY mTimerNotifyFunction
= NULL
;
175 /// The current period of the HPET timer interrupt in 100 ns units.
177 UINT64 mTimerPeriod
= 0;
180 /// The number of HPET timer ticks required for the current HPET rate specified by mTimerPeriod.
185 /// Mask used for counter and comparator calculations to adjust for a 32-bit or 64-bit counter.
190 /// The HPET main counter value from the most recent HPET timer interrupt.
192 volatile UINT64 mPreviousMainCounter
;
194 volatile UINT64 mPreviousComparator
;
197 /// The index of the HPET timer being managed by this driver.
202 /// The I/O APIC IRQ that the HPET Timer is mapped if I/O APIC mode is used.
207 /// Cached state of the HPET General Capabilities register managed by this driver.
208 /// Caching the state reduces the number of times the configuration register is read.
210 HPET_GENERAL_CAPABILITIES_ID_REGISTER mHpetGeneralCapabilities
;
213 /// Cached state of the HPET General Configuration register managed by this driver.
214 /// Caching the state reduces the number of times the configuration register is read.
216 HPET_GENERAL_CONFIGURATION_REGISTER mHpetGeneralConfiguration
;
219 /// Cached state of the Configuration register for the HPET Timer managed by
220 /// this driver. Caching the state reduces the number of times the configuration
221 /// register is read.
223 HPET_TIMER_CONFIGURATION_REGISTER mTimerConfiguration
;
226 /// Counts the number of HPET Timer interrupts processed by this driver.
227 /// Only required for debug.
229 volatile UINTN mNumTicks
;
232 Read a 64-bit register from the HPET
234 @param Offset Specifies the offset of the HPET register to read.
236 @return The 64-bit value read from the HPET register specified by Offset.
243 return MmioRead64 (PcdGet32 (PcdHpetBaseAddress
) + Offset
);
247 Write a 64-bit HPET register.
249 @param Offset Specifies the offset of the HPET register to write.
250 @param Value Specifies the value to write to the HPET register specified by Offset.
252 @return The 64-bit value written to HPET register specified by Offset.
260 return MmioWrite64 (PcdGet32 (PcdHpetBaseAddress
) + Offset
, Value
);
264 Enable or disable the main counter in the HPET Timer.
266 @param Enable If TRUE, then enable the main counter in the HPET Timer.
267 If FALSE, then disable the main counter in the HPET Timer.
274 mHpetGeneralConfiguration
.Bits
.MainCounterEnable
= Enable
? 1 : 0;
275 HpetWrite (HPET_GENERAL_CONFIGURATION_OFFSET
, mHpetGeneralConfiguration
.Uint64
);
279 The interrupt handler for the HPET timer. This handler clears the HPET interrupt
280 and computes the amount of time that has passed since the last HPET timer interrupt.
281 If a notification function is registered, then the amount of time since the last
282 HPET interrupt is passed to that notification function in 100 ns units. The HPET
283 time is updated to generate another interrupt in the required time period.
285 @param InterruptType The type of interrupt that occurred.
286 @param SystemContext A pointer to the system context when the interrupt occurred.
290 TimerInterruptHandler (
291 IN EFI_EXCEPTION_TYPE InterruptType
,
292 IN EFI_SYSTEM_CONTEXT SystemContext
301 // Count number of ticks
308 // Clear HPET timer interrupt status
310 HpetWrite (HPET_GENERAL_INTERRUPT_STATUS_OFFSET
, LShiftU64 (1, mTimerIndex
));
318 // Disable HPET timer when adjusting the COMPARATOR value to prevent a missed interrupt
323 // Capture main counter value
325 MainCounter
= HpetRead (HPET_MAIN_COUNTER_OFFSET
);
328 // Get the previous comparator counter
330 mPreviousComparator
= HpetRead (HPET_TIMER_COMPARATOR_OFFSET
+ mTimerIndex
* HPET_TIMER_STRIDE
);
333 // Set HPET COMPARATOR to the value required for the next timer tick
335 Comparator
= (mPreviousComparator
+ mTimerCount
) & mCounterMask
;
337 if ((mPreviousMainCounter
< MainCounter
) && (mPreviousComparator
> Comparator
)) {
339 // When comparator overflows
341 HpetWrite (HPET_TIMER_COMPARATOR_OFFSET
+ mTimerIndex
* HPET_TIMER_STRIDE
, Comparator
);
342 } else if ((mPreviousMainCounter
> MainCounter
) && (mPreviousComparator
< Comparator
)) {
344 // When main counter overflows
346 HpetWrite (HPET_TIMER_COMPARATOR_OFFSET
+ mTimerIndex
* HPET_TIMER_STRIDE
, (MainCounter
+ mTimerCount
) & mCounterMask
);
349 // When both main counter and comparator do not overflow or both do overflow
351 if (Comparator
> MainCounter
) {
352 HpetWrite (HPET_TIMER_COMPARATOR_OFFSET
+ mTimerIndex
* HPET_TIMER_STRIDE
, Comparator
);
354 HpetWrite (HPET_TIMER_COMPARATOR_OFFSET
+ mTimerIndex
* HPET_TIMER_STRIDE
, (MainCounter
+ mTimerCount
) & mCounterMask
);
359 // Enable the HPET counter once the new COMPARATOR value has been set.
364 // Check to see if there is a registered notification function
366 if (mTimerNotifyFunction
!= NULL
) {
368 // Compute time since last notification in 100 ns units (10 ^ -7)
370 if (MainCounter
> mPreviousMainCounter
) {
372 // Main counter does not overflow
374 Delta
= MainCounter
- mPreviousMainCounter
;
377 // Main counter overflows, first usb, then add
379 Delta
= (mCounterMask
- mPreviousMainCounter
) + MainCounter
;
382 TimerPeriod
= DivU64x32 (
384 Delta
& mCounterMask
,
385 mHpetGeneralCapabilities
.Bits
.CounterClockPeriod
391 // Call registered notification function passing in the time since the last
392 // interrupt in 100 ns units.
394 mTimerNotifyFunction (TimerPeriod
);
398 // Save main counter value
400 mPreviousMainCounter
= MainCounter
;
404 This function registers the handler NotifyFunction so it is called every time
405 the timer interrupt fires. It also passes the amount of time since the last
406 handler call to the NotifyFunction. If NotifyFunction is NULL, then the
407 handler is unregistered. If the handler is registered, then EFI_SUCCESS is
408 returned. If the CPU does not support registering a timer interrupt handler,
409 then EFI_UNSUPPORTED is returned. If an attempt is made to register a handler
410 when a handler is already registered, then EFI_ALREADY_STARTED is returned.
411 If an attempt is made to unregister a handler when a handler is not registered,
412 then EFI_INVALID_PARAMETER is returned. If an error occurs attempting to
413 register the NotifyFunction with the timer interrupt, then EFI_DEVICE_ERROR
416 @param This The EFI_TIMER_ARCH_PROTOCOL instance.
417 @param NotifyFunction The function to call when a timer interrupt fires.
418 This function executes at TPL_HIGH_LEVEL. The DXE
419 Core will register a handler for the timer interrupt,
420 so it can know how much time has passed. This
421 information is used to signal timer based events.
422 NULL will unregister the handler.
424 @retval EFI_SUCCESS The timer handler was registered.
425 @retval EFI_UNSUPPORTED The platform does not support timer interrupts.
426 @retval EFI_ALREADY_STARTED NotifyFunction is not NULL, and a handler is already
428 @retval EFI_INVALID_PARAMETER NotifyFunction is NULL, and a handler was not
429 previously registered.
430 @retval EFI_DEVICE_ERROR The timer handler could not be registered.
435 TimerDriverRegisterHandler (
436 IN EFI_TIMER_ARCH_PROTOCOL
*This
,
437 IN EFI_TIMER_NOTIFY NotifyFunction
441 // Check for invalid parameters
443 if ((NotifyFunction
== NULL
) && (mTimerNotifyFunction
== NULL
)) {
444 return EFI_INVALID_PARAMETER
;
447 if ((NotifyFunction
!= NULL
) && (mTimerNotifyFunction
!= NULL
)) {
448 return EFI_ALREADY_STARTED
;
452 // Cache the registered notification function
454 mTimerNotifyFunction
= NotifyFunction
;
460 This function adjusts the period of timer interrupts to the value specified
461 by TimerPeriod. If the timer period is updated, then the selected timer
462 period is stored in EFI_TIMER.TimerPeriod, and EFI_SUCCESS is returned. If
463 the timer hardware is not programmable, then EFI_UNSUPPORTED is returned.
464 If an error occurs while attempting to update the timer period, then the
465 timer hardware will be put back in its state prior to this call, and
466 EFI_DEVICE_ERROR is returned. If TimerPeriod is 0, then the timer interrupt
467 is disabled. This is not the same as disabling the CPU's interrupts.
468 Instead, it must either turn off the timer hardware, or it must adjust the
469 interrupt controller so that a CPU interrupt is not generated when the timer
472 @param This The EFI_TIMER_ARCH_PROTOCOL instance.
473 @param TimerPeriod The rate to program the timer interrupt in 100 nS units.
474 If the timer hardware is not programmable, then
475 EFI_UNSUPPORTED is returned. If the timer is programmable,
476 then the timer period will be rounded up to the nearest
477 timer period that is supported by the timer hardware.
478 If TimerPeriod is set to 0, then the timer interrupts
481 @retval EFI_SUCCESS The timer period was changed.
482 @retval EFI_UNSUPPORTED The platform cannot change the period of the timer interrupt.
483 @retval EFI_DEVICE_ERROR The timer period could not be changed due to a device error.
488 TimerDriverSetTimerPeriod (
489 IN EFI_TIMER_ARCH_PROTOCOL
*This
,
490 IN UINT64 TimerPeriod
496 UINT64 CurrentComparator
;
497 HPET_TIMER_MSI_ROUTE_REGISTER HpetTimerMsiRoute
;
500 // Disable interrupts
502 Tpl
= gBS
->RaiseTPL (TPL_HIGH_LEVEL
);
505 // Disable HPET timer when adjusting the timer period
509 if (TimerPeriod
== 0) {
510 if (mTimerPeriod
!= 0) {
512 // Check if there is possibly a pending interrupt
514 MainCounter
= HpetRead (HPET_MAIN_COUNTER_OFFSET
);
515 if (MainCounter
< mPreviousMainCounter
) {
516 Delta
= (mCounterMask
- mPreviousMainCounter
) + MainCounter
;
518 Delta
= MainCounter
- mPreviousMainCounter
;
521 if ((Delta
& mCounterMask
) >= mTimerCount
) {
523 // Interrupt still happens after disable HPET, wait to be processed
524 // Wait until interrupt is processed and comparator is increased
526 CurrentComparator
= HpetRead (HPET_TIMER_COMPARATOR_OFFSET
+ mTimerIndex
* HPET_TIMER_STRIDE
);
527 while (CurrentComparator
== mPreviousComparator
) {
528 CurrentComparator
= HpetRead (HPET_TIMER_COMPARATOR_OFFSET
+ mTimerIndex
* HPET_TIMER_STRIDE
);
535 // If TimerPeriod is 0, then mask HPET Timer interrupts
538 if ((mTimerConfiguration
.Bits
.MsiInterruptCapability
!= 0) && FeaturePcdGet (PcdHpetMsiEnable
)) {
540 // Disable HPET MSI interrupt generation
542 mTimerConfiguration
.Bits
.MsiInterruptEnable
= 0;
545 // Disable I/O APIC Interrupt
547 IoApicEnableInterrupt (mTimerIrq
, FALSE
);
551 // Disable HPET timer interrupt
553 mTimerConfiguration
.Bits
.InterruptEnable
= 0;
554 HpetWrite (HPET_TIMER_CONFIGURATION_OFFSET
+ mTimerIndex
* HPET_TIMER_STRIDE
, mTimerConfiguration
.Uint64
);
557 // Convert TimerPeriod to femtoseconds and divide by the number if femtoseconds
558 // per tick of the HPET counter to determine the number of HPET counter ticks
559 // in TimerPeriod 100 ns units.
561 mTimerCount
= DivU64x32 (
562 MultU64x32 (TimerPeriod
, 100000000),
563 mHpetGeneralCapabilities
.Bits
.CounterClockPeriod
567 // Program the HPET Comparator with the number of ticks till the next interrupt
569 MainCounter
= HpetRead (HPET_MAIN_COUNTER_OFFSET
);
570 if (MainCounter
> mPreviousMainCounter
) {
571 Delta
= MainCounter
- mPreviousMainCounter
;
573 Delta
= (mCounterMask
- mPreviousMainCounter
) + MainCounter
;
576 if ((Delta
& mCounterMask
) >= mTimerCount
) {
577 HpetWrite (HPET_TIMER_COMPARATOR_OFFSET
+ mTimerIndex
* HPET_TIMER_STRIDE
, (MainCounter
+ 1) & mCounterMask
);
579 HpetWrite (HPET_TIMER_COMPARATOR_OFFSET
+ mTimerIndex
* HPET_TIMER_STRIDE
, (mPreviousMainCounter
+ mTimerCount
) & mCounterMask
);
583 // Enable HPET Timer interrupt generation
585 if ((mTimerConfiguration
.Bits
.MsiInterruptCapability
!= 0) && FeaturePcdGet (PcdHpetMsiEnable
)) {
587 // Program MSI Address and MSI Data values in the selected HPET Timer
588 // Program HPET register with APIC ID of current BSP in case BSP has been switched
590 HpetTimerMsiRoute
.Bits
.Address
= GetApicMsiAddress ();
591 HpetTimerMsiRoute
.Bits
.Value
= (UINT32
)GetApicMsiValue (PcdGet8 (PcdHpetLocalApicVector
), LOCAL_APIC_DELIVERY_MODE_LOWEST_PRIORITY
, FALSE
, FALSE
);
592 HpetWrite (HPET_TIMER_MSI_ROUTE_OFFSET
+ mTimerIndex
* HPET_TIMER_STRIDE
, HpetTimerMsiRoute
.Uint64
);
594 // Enable HPET MSI Interrupt
596 mTimerConfiguration
.Bits
.MsiInterruptEnable
= 1;
599 // Enable timer interrupt through I/O APIC
600 // Program IOAPIC register with APIC ID of current BSP in case BSP has been switched
602 IoApicConfigureInterrupt (mTimerIrq
, PcdGet8 (PcdHpetLocalApicVector
), IO_APIC_DELIVERY_MODE_LOWEST_PRIORITY
, TRUE
, FALSE
);
603 IoApicEnableInterrupt (mTimerIrq
, TRUE
);
607 // Enable HPET Interrupt Generation
609 mTimerConfiguration
.Bits
.InterruptEnable
= 1;
610 HpetWrite (HPET_TIMER_CONFIGURATION_OFFSET
+ mTimerIndex
* HPET_TIMER_STRIDE
, mTimerConfiguration
.Uint64
);
614 // Save the new timer period
616 mTimerPeriod
= TimerPeriod
;
619 // Enable the HPET counter once new timer period has been established
620 // The HPET counter should run even if the HPET Timer interrupts are
621 // disabled. This is used to account for time passed while the interrupt
627 // Restore interrupts
629 gBS
->RestoreTPL (Tpl
);
635 This function retrieves the period of timer interrupts in 100 ns units,
636 returns that value in TimerPeriod, and returns EFI_SUCCESS. If TimerPeriod
637 is NULL, then EFI_INVALID_PARAMETER is returned. If a TimerPeriod of 0 is
638 returned, then the timer is currently disabled.
640 @param This The EFI_TIMER_ARCH_PROTOCOL instance.
641 @param TimerPeriod A pointer to the timer period to retrieve in 100 ns units.
642 If 0 is returned, then the timer is currently disabled.
644 @retval EFI_SUCCESS The timer period was returned in TimerPeriod.
645 @retval EFI_INVALID_PARAMETER TimerPeriod is NULL.
650 TimerDriverGetTimerPeriod (
651 IN EFI_TIMER_ARCH_PROTOCOL
*This
,
652 OUT UINT64
*TimerPeriod
655 if (TimerPeriod
== NULL
) {
656 return EFI_INVALID_PARAMETER
;
659 *TimerPeriod
= mTimerPeriod
;
665 This function generates a soft timer interrupt. If the platform does not support soft
666 timer interrupts, then EFI_UNSUPPORTED is returned. Otherwise, EFI_SUCCESS is returned.
667 If a handler has been registered through the EFI_TIMER_ARCH_PROTOCOL.RegisterHandler()
668 service, then a soft timer interrupt will be generated. If the timer interrupt is
669 enabled when this service is called, then the registered handler will be invoked. The
670 registered handler should not be able to distinguish a hardware-generated timer
671 interrupt from a software-generated timer interrupt.
673 @param This The EFI_TIMER_ARCH_PROTOCOL instance.
675 @retval EFI_SUCCESS The soft timer interrupt was generated.
676 @retval EFI_UNSUPPORTED The platform does not support the generation of soft
682 TimerDriverGenerateSoftInterrupt (
683 IN EFI_TIMER_ARCH_PROTOCOL
*This
692 // Disable interrupts
694 Tpl
= gBS
->RaiseTPL (TPL_HIGH_LEVEL
);
697 // Capture main counter value
699 MainCounter
= HpetRead (HPET_MAIN_COUNTER_OFFSET
);
702 // Check to see if there is a registered notification function
704 if (mTimerNotifyFunction
!= NULL
) {
706 // Compute time since last interrupt in 100 ns units (10 ^ -7)
708 if (MainCounter
> mPreviousMainCounter
) {
710 // Main counter does not overflow
712 Delta
= MainCounter
- mPreviousMainCounter
;
715 // Main counter overflows, first usb, then add
717 Delta
= (mCounterMask
- mPreviousMainCounter
) + MainCounter
;
720 TimerPeriod
= DivU64x32 (
722 Delta
& mCounterMask
,
723 mHpetGeneralCapabilities
.Bits
.CounterClockPeriod
729 // Call registered notification function passing in the time since the last
730 // interrupt in 100 ns units.
732 mTimerNotifyFunction (TimerPeriod
);
736 // Save main counter value
738 mPreviousMainCounter
= MainCounter
;
741 // Restore interrupts
743 gBS
->RestoreTPL (Tpl
);
749 Initialize the Timer Architectural Protocol driver
751 @param ImageHandle ImageHandle of the loaded driver
752 @param SystemTable Pointer to the System Table
754 @retval EFI_SUCCESS Timer Architectural Protocol created
755 @retval EFI_OUT_OF_RESOURCES Not enough resources available to initialize driver.
756 @retval EFI_DEVICE_ERROR A device error occurred attempting to initialize the driver.
761 TimerDriverInitialize (
762 IN EFI_HANDLE ImageHandle
,
763 IN EFI_SYSTEM_TABLE
*SystemTable
769 HPET_TIMER_MSI_ROUTE_REGISTER HpetTimerMsiRoute
;
771 DEBUG ((DEBUG_INFO
, "Init HPET Timer Driver\n"));
774 // Make sure the Timer Architectural Protocol is not already installed in the system
776 ASSERT_PROTOCOL_ALREADY_INSTALLED (NULL
, &gEfiTimerArchProtocolGuid
);
779 // Find the CPU architectural protocol.
781 Status
= gBS
->LocateProtocol (&gEfiCpuArchProtocolGuid
, NULL
, (VOID
**)&mCpu
);
782 ASSERT_EFI_ERROR (Status
);
785 // Retrieve HPET Capabilities and Configuration Information
787 mHpetGeneralCapabilities
.Uint64
= HpetRead (HPET_GENERAL_CAPABILITIES_ID_OFFSET
);
788 mHpetGeneralConfiguration
.Uint64
= HpetRead (HPET_GENERAL_CONFIGURATION_OFFSET
);
791 // If Revision is not valid, then ASSERT() and unload the driver because the HPET
792 // device is not present.
794 ASSERT (mHpetGeneralCapabilities
.Uint64
!= 0);
795 ASSERT (mHpetGeneralCapabilities
.Uint64
!= 0xFFFFFFFFFFFFFFFFULL
);
796 if ((mHpetGeneralCapabilities
.Uint64
== 0) || (mHpetGeneralCapabilities
.Uint64
== 0xFFFFFFFFFFFFFFFFULL
)) {
797 DEBUG ((DEBUG_ERROR
, "HPET device is not present. Unload HPET driver.\n"));
798 return EFI_DEVICE_ERROR
;
802 // Force the HPET timer to be disabled while setting everything up
807 // Dump HPET Configuration Information
810 DEBUG ((DEBUG_INFO
, "HPET Base Address = 0x%08x\n", PcdGet32 (PcdHpetBaseAddress
)));
811 DEBUG ((DEBUG_INFO
, " HPET_GENERAL_CAPABILITIES_ID = 0x%016lx\n", mHpetGeneralCapabilities
));
812 DEBUG ((DEBUG_INFO
, " HPET_GENERAL_CONFIGURATION = 0x%016lx\n", mHpetGeneralConfiguration
.Uint64
));
813 DEBUG ((DEBUG_INFO
, " HPET_GENERAL_INTERRUPT_STATUS = 0x%016lx\n", HpetRead (HPET_GENERAL_INTERRUPT_STATUS_OFFSET
)));
814 DEBUG ((DEBUG_INFO
, " HPET_MAIN_COUNTER = 0x%016lx\n", HpetRead (HPET_MAIN_COUNTER_OFFSET
)));
815 DEBUG ((DEBUG_INFO
, " HPET Main Counter Period = %d (fs)\n", mHpetGeneralCapabilities
.Bits
.CounterClockPeriod
));
816 for (TimerIndex
= 0; TimerIndex
<= mHpetGeneralCapabilities
.Bits
.NumberOfTimers
; TimerIndex
++) {
817 DEBUG ((DEBUG_INFO
, " HPET_TIMER%d_CONFIGURATION = 0x%016lx\n", TimerIndex
, HpetRead (HPET_TIMER_CONFIGURATION_OFFSET
+ TimerIndex
* HPET_TIMER_STRIDE
)));
818 DEBUG ((DEBUG_INFO
, " HPET_TIMER%d_COMPARATOR = 0x%016lx\n", TimerIndex
, HpetRead (HPET_TIMER_COMPARATOR_OFFSET
+ TimerIndex
* HPET_TIMER_STRIDE
)));
819 DEBUG ((DEBUG_INFO
, " HPET_TIMER%d_MSI_ROUTE = 0x%016lx\n", TimerIndex
, HpetRead (HPET_TIMER_MSI_ROUTE_OFFSET
+ TimerIndex
* HPET_TIMER_STRIDE
)));
825 // Capture the current HPET main counter value.
827 mPreviousMainCounter
= HpetRead (HPET_MAIN_COUNTER_OFFSET
);
830 // Determine the interrupt mode to use for the HPET Timer.
831 // Look for MSI first, then unused PIC mode interrupt, then I/O APIC mode interrupt
833 MsiTimerIndex
= HPET_INVALID_TIMER_INDEX
;
834 mTimerIndex
= HPET_INVALID_TIMER_INDEX
;
835 for (TimerIndex
= 0; TimerIndex
<= mHpetGeneralCapabilities
.Bits
.NumberOfTimers
; TimerIndex
++) {
837 // Read the HPET Timer Capabilities and Configuration register
839 mTimerConfiguration
.Uint64
= HpetRead (HPET_TIMER_CONFIGURATION_OFFSET
+ TimerIndex
* HPET_TIMER_STRIDE
);
842 // Check to see if this HPET Timer supports MSI
844 if (mTimerConfiguration
.Bits
.MsiInterruptCapability
!= 0) {
846 // Save the index of the first HPET Timer that supports MSI interrupts
848 if (MsiTimerIndex
== HPET_INVALID_TIMER_INDEX
) {
849 MsiTimerIndex
= TimerIndex
;
854 // Check to see if this HPET Timer supports I/O APIC interrupts
856 if (mTimerConfiguration
.Bits
.InterruptRouteCapability
!= 0) {
858 // Save the index of the first HPET Timer that supports I/O APIC interrupts
860 if (mTimerIndex
== HPET_INVALID_TIMER_INDEX
) {
861 mTimerIndex
= TimerIndex
;
862 mTimerIrq
= (UINT32
)LowBitSet32 (mTimerConfiguration
.Bits
.InterruptRouteCapability
);
867 if (FeaturePcdGet (PcdHpetMsiEnable
) && (MsiTimerIndex
!= HPET_INVALID_TIMER_INDEX
)) {
869 // Use MSI interrupt if supported
871 mTimerIndex
= MsiTimerIndex
;
874 // Program MSI Address and MSI Data values in the selected HPET Timer
876 HpetTimerMsiRoute
.Bits
.Address
= GetApicMsiAddress ();
877 HpetTimerMsiRoute
.Bits
.Value
= (UINT32
)GetApicMsiValue (PcdGet8 (PcdHpetLocalApicVector
), LOCAL_APIC_DELIVERY_MODE_LOWEST_PRIORITY
, FALSE
, FALSE
);
878 HpetWrite (HPET_TIMER_MSI_ROUTE_OFFSET
+ mTimerIndex
* HPET_TIMER_STRIDE
, HpetTimerMsiRoute
.Uint64
);
881 // Read the HPET Timer Capabilities and Configuration register and initialize for MSI mode
882 // Clear LevelTriggeredInterrupt to use edge triggered interrupts when in MSI mode
884 mTimerConfiguration
.Uint64
= HpetRead (HPET_TIMER_CONFIGURATION_OFFSET
+ mTimerIndex
* HPET_TIMER_STRIDE
);
885 mTimerConfiguration
.Bits
.LevelTriggeredInterrupt
= 0;
888 // If no HPET timers support MSI or I/O APIC modes, then ASSERT() and unload the driver.
890 ASSERT (mTimerIndex
!= HPET_INVALID_TIMER_INDEX
);
891 if (mTimerIndex
== HPET_INVALID_TIMER_INDEX
) {
892 DEBUG ((DEBUG_ERROR
, "No HPET timers support MSI or I/O APIC mode. Unload HPET driver.\n"));
893 return EFI_DEVICE_ERROR
;
897 // Initialize I/O APIC entry for HPET Timer Interrupt
898 // Fixed Delivery Mode, Level Triggered, Asserted Low
900 IoApicConfigureInterrupt (mTimerIrq
, PcdGet8 (PcdHpetLocalApicVector
), IO_APIC_DELIVERY_MODE_LOWEST_PRIORITY
, TRUE
, FALSE
);
903 // Read the HPET Timer Capabilities and Configuration register and initialize for I/O APIC mode
904 // Clear MsiInterruptCapability to force rest of driver to use I/O APIC mode
905 // Set LevelTriggeredInterrupt to use level triggered interrupts when in I/O APIC mode
906 // Set InterruptRoute field based in mTimerIrq
908 mTimerConfiguration
.Uint64
= HpetRead (HPET_TIMER_CONFIGURATION_OFFSET
+ mTimerIndex
* HPET_TIMER_STRIDE
);
909 mTimerConfiguration
.Bits
.LevelTriggeredInterrupt
= 1;
910 mTimerConfiguration
.Bits
.InterruptRoute
= mTimerIrq
;
914 // Configure the selected HPET Timer with settings common to both MSI mode and I/O APIC mode
915 // Clear InterruptEnable to keep interrupts disabled until full init is complete
916 // Clear PeriodicInterruptEnable to use one-shot mode
917 // Configure as a 32-bit counter
919 mTimerConfiguration
.Bits
.InterruptEnable
= 0;
920 mTimerConfiguration
.Bits
.PeriodicInterruptEnable
= 0;
921 mTimerConfiguration
.Bits
.CounterSizeEnable
= 1;
922 HpetWrite (HPET_TIMER_CONFIGURATION_OFFSET
+ mTimerIndex
* HPET_TIMER_STRIDE
, mTimerConfiguration
.Uint64
);
925 // Read the HPET Timer Capabilities and Configuration register back again.
926 // CounterSizeEnable will be read back as a 0 if it is a 32-bit only timer
928 mTimerConfiguration
.Uint64
= HpetRead (HPET_TIMER_CONFIGURATION_OFFSET
+ mTimerIndex
* HPET_TIMER_STRIDE
);
929 if ((mTimerConfiguration
.Bits
.CounterSizeEnable
== 1) && (sizeof (UINTN
) == sizeof (UINT64
))) {
930 DEBUG ((DEBUG_INFO
, "Choose 64-bit HPET timer.\n"));
932 // 64-bit BIOS can use 64-bit HPET timer
934 mCounterMask
= 0xffffffffffffffffULL
;
936 // Set timer back to 64-bit
938 mTimerConfiguration
.Bits
.CounterSizeEnable
= 0;
939 HpetWrite (HPET_TIMER_CONFIGURATION_OFFSET
+ mTimerIndex
* HPET_TIMER_STRIDE
, mTimerConfiguration
.Uint64
);
941 DEBUG ((DEBUG_INFO
, "Choose 32-bit HPET timer.\n"));
942 mCounterMask
= 0x00000000ffffffffULL
;
946 // Install interrupt handler for selected HPET Timer
948 Status
= mCpu
->RegisterInterruptHandler (mCpu
, PcdGet8 (PcdHpetLocalApicVector
), TimerInterruptHandler
);
949 ASSERT_EFI_ERROR (Status
);
950 if (EFI_ERROR (Status
)) {
951 DEBUG ((DEBUG_ERROR
, "Unable to register HPET interrupt with CPU Arch Protocol. Unload HPET driver.\n"));
952 return EFI_DEVICE_ERROR
;
956 // Force the HPET Timer to be enabled at its default period
958 Status
= TimerDriverSetTimerPeriod (&mTimer
, PcdGet64 (PcdHpetDefaultTimerPeriod
));
959 ASSERT_EFI_ERROR (Status
);
960 if (EFI_ERROR (Status
)) {
961 DEBUG ((DEBUG_ERROR
, "Unable to set HPET default timer rate. Unload HPET driver.\n"));
962 return EFI_DEVICE_ERROR
;
966 // Show state of enabled HPET timer
969 if ((mTimerConfiguration
.Bits
.MsiInterruptCapability
!= 0) && FeaturePcdGet (PcdHpetMsiEnable
)) {
970 DEBUG ((DEBUG_INFO
, "HPET Interrupt Mode MSI\n"));
972 DEBUG ((DEBUG_INFO
, "HPET Interrupt Mode I/O APIC\n"));
973 DEBUG ((DEBUG_INFO
, "HPET I/O APIC IRQ = 0x%02x\n", mTimerIrq
));
976 DEBUG ((DEBUG_INFO
, "HPET Interrupt Vector = 0x%02x\n", PcdGet8 (PcdHpetLocalApicVector
)));
977 DEBUG ((DEBUG_INFO
, "HPET Counter Mask = 0x%016lx\n", mCounterMask
));
978 DEBUG ((DEBUG_INFO
, "HPET Timer Period = %d\n", mTimerPeriod
));
979 DEBUG ((DEBUG_INFO
, "HPET Timer Count = 0x%016lx\n", mTimerCount
));
980 DEBUG ((DEBUG_INFO
, "HPET_TIMER%d_CONFIGURATION = 0x%016lx\n", mTimerIndex
, HpetRead (HPET_TIMER_CONFIGURATION_OFFSET
+ mTimerIndex
* HPET_TIMER_STRIDE
)));
981 DEBUG ((DEBUG_INFO
, "HPET_TIMER%d_COMPARATOR = 0x%016lx\n", mTimerIndex
, HpetRead (HPET_TIMER_COMPARATOR_OFFSET
+ mTimerIndex
* HPET_TIMER_STRIDE
)));
982 DEBUG ((DEBUG_INFO
, "HPET_TIMER%d_MSI_ROUTE = 0x%016lx\n", mTimerIndex
, HpetRead (HPET_TIMER_MSI_ROUTE_OFFSET
+ mTimerIndex
* HPET_TIMER_STRIDE
)));
985 // Wait for a few timer interrupts to fire before continuing
987 while (mNumTicks
< 10) {
993 // Install the Timer Architectural Protocol onto a new handle
995 Status
= gBS
->InstallMultipleProtocolInterfaces (
997 &gEfiTimerArchProtocolGuid
,
1001 ASSERT_EFI_ERROR (Status
);