/*
* ======== TimestampProvider_get32 ========
* The 32-bit timestamp can be retrieved more efficiently than the 64-bit one,
* so it has a different implementation.
*/
Bits32 TimestampProvider_get32()
{
/*
* If we're sharing the Clock timer, get the timestamp by using the Clock
* tick count.
*/
if (TimestampProvider_useClockTimer) {
UInt key;
UInt32 timestamp;
/*
* Disable interrupts so that the Clock tick count doesn't change if
* the timer expires while we are reading it.
*/
key = Hwi_disable();
/*
* timestamp = (clock ticks) x (tick period) + (current timer count)
* The 'getExpiredCounts' API retrieves the current Timer count and
* also accounts for timer rollover.
*/
timestamp = Clock_getTicks() * Timer_getPeriod(MOD->timer)
+ Timer_getExpiredCounts(MOD->timer);
Hwi_restore(key);
return (timestamp);
}
/* If we have a dedicated timer, just read the timer count. */
else {
return (Timer_getCount(MOD->timer));
}
}
/*
* ======== Timer_getExpiredTicks ========
*/
UInt32 Timer_getExpiredTicks(Timer_Object *obj, UInt32 tickPeriod)
{
UInt32 ticks;
ticks = Timer_getExpiredCounts(obj) / tickPeriod;
return (ticks);
}
/*
* ======== TimestampProvider_get32 ========
*/
Bits32 TimestampProvider_get32()
{
UInt32 timestamp;
UInt key;
key = Hwi_disable();
if (BIOS_clockEnabled && TimestampProvider_useClockTimer) {
timestamp = (Clock_getCompletedTicks() * Clock_getTickPeriod())
+ Timer_getExpiredCounts(MOD->timer);
}
else {
timestamp = (MOD->rollovers * Timer_MAX_PERIOD)
+ Timer_getExpiredCounts(MOD->timer);
}
Hwi_restore(key);
return (timestamp);
}
/*
* ======== TimestampProvider_get32 ========
*/
Bits32 TimestampProvider_get32()
{
UInt32 timestamp;
UInt key;
key = Hwi_disable();
if (TimestampProvider_useClockTimer) {
timestamp = (Clock_getCompletedTicks() * Clock_getTickPeriod())
+ Timer_getExpiredCounts(MOD->timer);
}
else {
timestamp = (MOD->rollovers << 16) + Timer_getExpiredCounts(MOD->timer);
timestamp -= MOD->rollovers; /* adjust for Timer_MAX_PERIOD = 0xFFFF */
}
Hwi_restore(key);
return (timestamp);
}
/*
* ======== TimestampProvider_get64 ========
*/
Void TimestampProvider_get64(Types_Timestamp64 *result)
{
UInt key;
UInt64 timestamp;
key = Hwi_disable();
if (TimestampProvider_useClockTimer) {
timestamp = Clock_getTicks() * Timer_getPeriod(MOD->timer)
+ Timer_getExpiredCounts(MOD->timer);
}
else {
timestamp = ((UInt64)MOD->hi << 32) + Timer_getExpiredCounts(MOD->timer);
}
Hwi_restore(key);
result->hi = timestamp >> 32;
result->lo = timestamp;
}
/*
* ======== TimestampProvider_get32 ========
*/
Bits32 TimestampProvider_get32()
{
if (TimestampProvider_useClockTimer) {
UInt key;
UInt32 timestamp;
key = Hwi_disable();
timestamp = Clock_getTicks() * Timer_getPeriod(MOD->timer)
+ Timer_getExpiredCounts(MOD->timer);
Hwi_restore(key);
return (timestamp);
}
else {
return (Timer_getCount(MOD->timer));
}
}
/*
* ======== TimestampProvider_get64 ========
* This API has different implementations based on whether we're using a
* dedicated timer or sharing the Clock timer.
* If we're sharing the Clock timer, we have to multiply the Clock tick count
* by the Clock tick period. If we have a dedicate timer, the timer period is
* 2^32, so we can just use the MOD->hi tick count as the upper 32-bits of the
* timestamp.
*/
Void TimestampProvider_get64(Types_Timestamp64 *result)
{
UInt key;
/*
* If we're sharing the Clock timer, get the timestamp by using the Clock
* tick count.
*/
if (TimestampProvider_useClockTimer) {
UInt64 timestamp;
/*
* Disable interrupts so that the Clock tick count doesn't change if
* the timer expires while we are reading it.
*/
key = Hwi_disable();
/*
* timestamp = (clock ticks) x (tick period) + (current timer count)
* The 'getExpiredCounts' API retrieves the current Timer count and
* also accounts for timer rollover.
*/
timestamp = (UInt64) Clock_getTicks() * Timer_getPeriod(MOD->timer)
+ Timer_getExpiredCounts(MOD->timer);
Hwi_restore(key);
/*
* Copy the value into the result structure.
*
* The 28x is little endian, so it stores the 16-bit words
* in reverse order. For example, the value
* 0xFEDCBA9876543210
* Is stored as:
* Address Value
* 0x0 0x3210
* 0x1 0x7654
* 0x2 0xBA98
* 0x3 0xFEDC
*
* To retrieve the lower 32 bits, simply cast the value as a UInt32.
* To retrieve the upper 32 bits, cast the address of 'timestamp' as a
* pointer to a UInt32, increment the pointer by 1, then retrieve the
* value at that address.
*/
result->lo = (UInt32) timestamp;
result->hi = *(((UInt32 *) ×tamp) + 1);
}
/* If we have a dedicated timer... */
else {
/* Disable interrupts while reading the tick count and timer value. */
key = Hwi_disable();
/* Use the tick counter as the upper 32-bits. */
result->hi = MOD->hi;
/*
* Get the timer value as the lower 32-bits. This API will also take
* timer rollover into account and add 1 to result->hi if necessary.
*/
Timer_getExpiredCounts64(MOD->timer, result);
Hwi_restore(key);
}
}
