static void hpetAdjustComparator(HpetTimer *pHpetTimer, uint64_t u64Now)
{
uint64_t u64Period = pHpetTimer->u64Period;
if ( (pHpetTimer->u64Config & HPET_TN_PERIODIC)
&& u64Period != 0)
{
/* While loop is suboptimal */
if (hpet32bitTimer(pHpetTimer))
{
while (hpetTimeAfter32(u64Now, pHpetTimer->u64Cmp))
pHpetTimer->u64Cmp = (uint32_t)(pHpetTimer->u64Cmp + u64Period);
}
else
{
while (hpetTimeAfter64(u64Now, pHpetTimer->u64Cmp))
pHpetTimer->u64Cmp += u64Period;
}
}
}
DECLINLINE(uint64_t) hpetComputeDiff(HPETTIMER *pHpetTimer, uint64_t u64Now)
{
if (hpet32bitTimer(pHpetTimer))
{
uint32_t u32Diff;
u32Diff = (uint32_t)pHpetTimer->u64Cmp - (uint32_t)u64Now;
u32Diff = ((int32_t)u32Diff > 0) ? u32Diff : (uint32_t)0;
return (uint64_t)u32Diff;
}
else
{
uint64_t u64Diff;
u64Diff = pHpetTimer->u64Cmp - u64Now;
u64Diff = ((int64_t)u64Diff > 0) ? u64Diff : (uint64_t)0;
return u64Diff;
}
}
static void hpetProgramTimer(HpetTimer *pHpetTimer)
{
/* no wrapping on new timers */
pHpetTimer->u8Wrap = 0;
uint64_t u64Ticks = hpetGetTicks(pHpetTimer->CTX_SUFF(pHpet));
hpetAdjustComparator(pHpetTimer, u64Ticks);
uint64_t u64Diff = hpetComputeDiff(pHpetTimer, u64Ticks);
/*
* HPET spec says in one-shot 32-bit mode, generate an interrupt when
* counter wraps in addition to an interrupt with comparator match.
*/
if ( hpet32bitTimer(pHpetTimer)
&& !(pHpetTimer->u64Config & HPET_TN_PERIODIC))
{
uint32_t u32TillWrap = 0xffffffff - (uint32_t)u64Ticks + 1;
if (u32TillWrap < (uint32_t)u64Diff)
{
Log(("wrap on timer %d: till=%u ticks=%lld diff64=%lld\n",
pHpetTimer->idxTimer, u32TillWrap, u64Ticks, u64Diff));
u64Diff = u32TillWrap;
pHpetTimer->u8Wrap = 1;
}
}
/*
* HACK ALERT! Avoid killing VM with interrupts.
*/
#if 1 /** @todo: HACK, rethink, may have negative impact on the guest */
if (u64Diff == 0)
u64Diff = 100000; /* 1 millisecond */
#endif
Log4(("HPET: next IRQ in %lld ticks (%lld ns)\n", u64Diff, hpetTicksToNs(pHpetTimer->CTX_SUFF(pHpet), u64Diff)));
TMTimerSetNano(pHpetTimer->CTX_SUFF(pTimer), hpetTicksToNs(pHpetTimer->CTX_SUFF(pHpet), u64Diff));
hpetTimerSetFrequencyHint(pHpetTimer->CTX_SUFF(pHpet), pHpetTimer);
}
/**
* 32-bit write to a HPET timer register.
*
* @returns Strict VBox status code.
*
* @param pThis The HPET state.
* @param idxReg The register being written to.
* @param u32NewValue The value being written.
*
* @remarks The caller should not hold the device lock, unless it also holds
* the TM lock.
*/
static int hpetTimerRegWrite32(HpetState *pThis, uint32_t iTimerNo, uint32_t iTimerReg, uint32_t u32NewValue)
{
Assert(!PDMCritSectIsOwner(&pThis->csLock) || TMTimerIsLockOwner(pThis->aTimers[0].CTX_SUFF(pTimer)));
if ( iTimerNo >= RT_ELEMENTS(pThis->aTimers) /* parfait */
|| iTimerNo >= HPET_CAP_GET_TIMERS(pThis->u32Capabilities))
{
static unsigned s_cOccurences = 0;
if (s_cOccurences++ < 10)
LogRel(("HPET: using timer above configured range: %d\n", iTimerNo));
return VINF_SUCCESS;
}
HpetTimer *pHpetTimer = &pThis->aTimers[iTimerNo];
switch (iTimerReg)
{
case HPET_TN_CFG:
{
DEVHPET_LOCK_RETURN(pThis, VINF_IOM_R3_MMIO_WRITE);
Log(("write HPET_TN_CFG: %d: %x\n", iTimerNo, u32NewValue));
uint64_t const iOldValue = (uint32_t)pHpetTimer->u64Config;
uint64_t u64Mask = HPET_TN_CFG_WRITE_MASK;
if (pHpetTimer->u64Config & HPET_TN_PERIODIC_CAP)
u64Mask |= HPET_TN_PERIODIC;
if (pHpetTimer->u64Config & HPET_TN_SIZE_CAP)
u64Mask |= HPET_TN_32BIT;
else
u32NewValue &= ~HPET_TN_32BIT;
if (u32NewValue & HPET_TN_32BIT)
{
Log(("setting timer %d to 32-bit mode\n", iTimerNo));
pHpetTimer->u64Cmp = (uint32_t)pHpetTimer->u64Cmp;
pHpetTimer->u64Period = (uint32_t)pHpetTimer->u64Period;
}
if ((u32NewValue & HPET_TN_INT_TYPE) == HPET_TIMER_TYPE_LEVEL)
{
static unsigned s_cOccurences = 0;
if (s_cOccurences++ < 10)
LogRel(("level-triggered config not yet supported\n"));
AssertFailed();
}
/* We only care about lower 32-bits so far */
pHpetTimer->u64Config = hpetUpdateMasked(u32NewValue, iOldValue, u64Mask);
DEVHPET_UNLOCK(pThis);
break;
}
case HPET_TN_CFG + 4: /* Interrupt capabilities */
{
Log(("write HPET_TN_CFG + 4, useless\n"));
break;
}
case HPET_TN_CMP: /* lower bits of comparator register */
{
DEVHPET_LOCK_BOTH_RETURN(pThis, VINF_IOM_R3_MMIO_WRITE);
Log(("write HPET_TN_CMP on %d: %#x\n", iTimerNo, u32NewValue));
if (pHpetTimer->u64Config & HPET_TN_PERIODIC)
{
u32NewValue &= hpetInvalidValue(pHpetTimer) >> 1; /** @todo check this in the docs and add a not why? */
pHpetTimer->u64Period = RT_MAKE_U64(u32NewValue, pHpetTimer->u64Period);
}
pHpetTimer->u64Cmp = RT_MAKE_U64(u32NewValue, pHpetTimer->u64Cmp);
pHpetTimer->u64Config &= ~HPET_TN_SETVAL;
Log2(("after HPET_TN_CMP cmp=%#llx per=%#llx\n", pHpetTimer->u64Cmp, pHpetTimer->u64Period));
if (pThis->u64HpetConfig & HPET_CFG_ENABLE)
hpetProgramTimer(pHpetTimer);
DEVHPET_UNLOCK_BOTH(pThis);
break;
}
case HPET_TN_CMP + 4: /* upper bits of comparator register */
{
DEVHPET_LOCK_BOTH_RETURN(pThis, VINF_IOM_R3_MMIO_WRITE);
Log(("write HPET_TN_CMP + 4 on %d: %#x\n", iTimerNo, u32NewValue));
if (!hpet32bitTimer(pHpetTimer))
{
if (pHpetTimer->u64Config & HPET_TN_PERIODIC)
pHpetTimer->u64Period = RT_MAKE_U64(pHpetTimer->u64Period, u32NewValue);
pHpetTimer->u64Cmp = RT_MAKE_U64(pHpetTimer->u64Cmp, u32NewValue);
Log2(("after HPET_TN_CMP+4 cmp=%llx per=%llx tmr=%d\n", pHpetTimer->u64Cmp, pHpetTimer->u64Period, iTimerNo));
pHpetTimer->u64Config &= ~HPET_TN_SETVAL;
if (pThis->u64HpetConfig & HPET_CFG_ENABLE)
hpetProgramTimer(pHpetTimer);
}
DEVHPET_UNLOCK_BOTH(pThis);
break;
}
case HPET_TN_ROUTE:
{
Log(("write HPET_TN_ROUTE\n"));
break;
}
case HPET_TN_ROUTE + 4:
{
Log(("write HPET_TN_ROUTE + 4\n"));
break;
}
default:
{
static unsigned s_cOccurences = 0;
if (s_cOccurences++ < 10)
LogRel(("invalid timer register write: %d\n", iTimerReg));
break;
}
}
DECLINLINE(uint64_t) hpetInvalidValue(HpetTimer *pHpetTimer)
{
return hpet32bitTimer(pHpetTimer) ? UINT32_MAX : UINT64_MAX;
}