Originally posted on: http://geekswithblogs.net/WernerWillemsens/archive/2014/08/02/157895.aspx"I needed a timer". That is how we started a few blogs ago our series about APIC and ACPI.
Well, here it is.
HPET (High Precision Event Timer) was introduced by Intel in early 2000 to:
Replace old style Intel 8253 (1981!) and 8254 timers
Support more accurate timers that could be used for multimedia purposes. Hence Microsoft and Intel sometimes refers to HPET as Multimedia timers.
An HPET chip consists of a 64-bit up-counter (main counter) counting at a frequency of at least 10 MHz, and a set of (at least three, up to 256) comparators.
These comparators are 32- or 64-bit wide. The HPET is discoverable via ACPI. The HPET circuit in recent Intel platforms is integrated into the SouthBridge chip (e.g. 82801)
All HPET timers should support one-shot interrupt programming, while optionally they can support periodic interrupts.
In most Intel SouthBridges I worked with, there are three HPET timers. TIMER0 supports both one-shot and periodic mode, while TIMER1 and TIMER2 are one-shot only.
Each HPET timer can generate interrupts, both in old-style PIC mode and in APIC mode. However in PIC mode, interrupts cannot freely be chosen.
Typically IRQ11 is available and cannot be shared with any other interrupt! Which makes the HPET in PIC mode virtually unusable.
In APIC mode however more IRQs are available and can be shared with other interrupt generating devices. (Check the datasheet of your SouthBridge)
Because of this higher level of freedom, I created the APIC BSP (see previous posts). The HPET driver code that I present you here uses this APIC mode.
Hpet.reg
[HKEY_LOCAL_MACHINE\Drivers\BuiltIn\Hpet]
"Dll"="Hpet.dll"
"Prefix"="HPT"
"Order"=dword:10
"IsrDll"="giisr.dll"
"IsrHandler"="ISRHandler"
"Priority256"=dword:50
Because HPET does not reside on the PCI bus, but can be found through ACPI as a memory mapped device,
you don't need to specify the "Class", "SubClass", "ProgIF" and other PCI related registry keys that you typically find for PCI devices.
If a driver needs to run its internal thread(s) at a certain priority level, by convention in Windows CE you add the "Priority256" registry key.
Through this key you can easily play with the driver's thread priority for better response and timer accuracy. See later.
Hpet.cpp (Hpet.dll)
This cpp file contains the complete HPET driver code. The file is part of a folder that you typically integrate in your BSP (\src\drivers\Hpet).
It is written as sample (example) code, you most likely want to change this code to your specific needs.
There are two sets of #define's that I use to control how the driver works.
_TRIGGER_EVENT or _TRIGGER_SEMAPHORE:
_TRIGGER_EVENT will let your driver trigger a Windows CE Event when the timer expires, _TRIGGER_SEMAPHORE will trigger a Windows CE counting Semaphore.
The latter guarantees that no events get lost in case your application cannot always process the triggers fast enough.
_TIMER0 or _TIMER2: both timers will trigger an event or semaphore periodically.
_TIMER0 will use a periodic HPET timer interrupt, while _TIMER2 will reprogram a one-shot HPET timer after each interrupt.
The one-shot approach is interesting if the frequency you wish to generate is not an even multiple of the HPET main counter frequency.
The sample code uses an algorithm to generate a more correct frequency over a longer period (by reducing rounding errors).
_TIMER1 is not used in the sample source code.
HPT_Init() will locate the HPET I/O memory space, setup the HPET counter (_TIMER0 or _TIMER2) and install the Interrupt Service Thread (IST).
Upon timer expiration, the IST will run and on its turn will generate a Windows CE Event or Semaphore.
In case of _TIMER2 a new one-shot comparator value is calculated and set for the timer.
The IRQ of the HPET timers are programmed to IRQ22, but you can choose typically from 20-23.
The TIMERn_INT_ROUT_CAP bits in the TIMn_CONF register will tell you what IRQs you can choose from.
HPT_IOControl() can be used to set a new HPET counter frequency (actually you configure the counter timeout value in microseconds),
start and stop the timer, and request the current HPET counter value. The latter is interesting because the Windows CE QueryPerformanceCounter() and
QueryPerformanceFrequency() APIs implement the same functionality, albeit based on other counter implementations.
HpetDrvIst() contains the IST code.
DWORD WINAPI HpetDrvIst(LPVOID lpArg)
{
psHpetDeviceContext pHwContext = (psHpetDeviceContext)lpArg;
DWORD mainCount = READDWORD(pHwContext->g_hpet_va, GenCapIDReg + 4); // Main Counter Tick period (fempto sec 10E-15)
DWORD i = 0;
while (1)
{
WaitForSingleObject(pHwContext->g_isrEvent, INFINITE);
#if defined(_TRIGGER_SEMAPHORE)
LONG p = 0;
BOOL b = ReleaseSemaphore(pHwContext->g_triggerEvent, 1, &p);
#elif defined(_TRIGGER_EVENT)
BOOL b = SetEvent(pHwContext->g_triggerEvent);
#else
#pragma error("Unknown TRIGGER")
#endif
#if defined(_TIMER0)
DWORD currentCount = READDWORD(pHwContext->g_hpet_va, MainCounterReg);
DWORD comparator = READDWORD(pHwContext->g_hpet_va, Tim0_ComparatorReg + 0);
SETBIT(pHwContext->g_hpet_va, GenIntStaReg, 0); // clear interrupt on HPET level
InterruptDone(pHwContext->g_sysIntr); // clear interrupt on OS level
_LOGMSG(ZONE_INTERRUPT, (L"%s: HpetDrvIst 0 %06d %08X %08X", pHwContext->g_id, i++, currentCount, comparator));
#elif defined(_TIMER2)
DWORD currentCount = READDWORD(pHwContext->g_hpet_va, MainCounterReg);
DWORD previousComparator = READDWORD(pHwContext->g_hpet_va, Tim2_ComparatorReg + 0);
pHwContext->g_counter2.QuadPart += pHwContext->g_comparator.QuadPart; // increment virtual counter (higher accuracy)
DWORD comparator = (DWORD)(pHwContext->g_counter2.QuadPart >> 8); // "round" to real value
WRITEDWORD(pHwContext->g_hpet_va, Tim2_ComparatorReg + 0, comparator);
SETBIT(pHwContext->g_hpet_va, GenIntStaReg, 2); // clear interrupt on HPET level
InterruptDone(pHwContext->g_sysIntr); // clear interrupt on OS level
_LOGMSG(ZONE_INTERRUPT, (L"%s: HpetDrvIst 2 %06d %08X %08X (%08X)", pHwContext->g_id, i++, currentCount, comparator, comparator - previousComparator));
#else
#pragma error("Unknown TIMER")
#endif
}
return 1;
}
The following figure shows how the HPET hardware interrupt via ISR -> IST is translated in a Windows CE Event or Semaphore by the HPET driver.
The Event or Semaphore can be used to trigger a Windows CE application.
HpetTest.cpp (HpetTest.exe)This cpp file contains sample source how to use the HPET driver from an application. The file is part of a separate (smart device) VS2013 solution.
It contains code to measure the generated Event/Semaphore times by means of GetSystemTime() and QueryPerformanceCounter() and
QueryPerformanceFrequency() APIs.
HPET evaluation
If you scan the internet about HPET, you'll find many remarks about buggy HPET implementations and bad performance.
Unfortunately that is true. I tested the HPET driver on an Intel ICH7M SBC (release date 2008). When a HPET timer expires on the ICH7M, an interrupt indeed is generated,
but right after you clear the interrupt, a few more unwanted interrupts (too soon!) occur as well.
I tested and debugged it for a loooong time, but I couldn't get it to work. I concluded ICH7M's HPET is buggy Intel hardware.
I tested the HPET driver successfully on a more recent NM10 SBC (release date 2013).
With the NM10 chipset however, I am not fully convinced about the timer's frequency accuracy. In the long run - on average - all is fine,
but occasionally I experienced upto 20 microseconds delays (which were immediately compensated on the next interrupt). Of course, this was all measured by software,
but I still experienced the occasional delay when both the HPET driver IST thread as the application thread ran at CeSetThreadPriority(1).
If it is not the hardware, only the kernel can cause this delay. But Windows CE is an RTOS and I have never experienced such long delays with previous versions of Windows CE.
I tested and developed this on WCE8, I am not heavily experienced with it yet.
Internet forum threads however mention inaccurate HPET timer implementations as well.
At this moment I haven't figured out what is going on here.
Useful references:
http://www.intel.com/content/dam/www/public/us/en/documents/technical-specifications/software-developers-hpet-spec-1-0a.pdf
http://en.wikipedia.org/wiki/High_Precision_Event_Timer
http://wiki.osdev.org/HPET
Windows CE BSP source file package for HPET in MyBsp Note that this source code is "As Is". It is still under development and I cannot (and never will) guarantee the correctness of the code. Use it as a guide for your own HPET integration.
