diff --git a/hw/hpet.c b/hw/hpet.c index 0428290..bc2a21a 100644 --- a/hw/hpet.c +++ b/hw/hpet.c @@ -31,6 +31,7 @@ #include "hpet_emul.h" #include "sysbus.h" #include "mc146818rtc.h" +#include //#define HPET_DEBUG #ifdef HPET_DEBUG @@ -41,6 +42,9 @@ #define HPET_MSI_SUPPORT 0 +#define MAX_TICKS_NOT_ACCOUNTED (uint64_t)500000000 /* 5 sec */ +#define MAX_IRQ_RATE (uint32_t)10 + struct HPETState; typedef struct HPETTimer { /* timers */ uint8_t tn; /*timer number*/ @@ -334,13 +338,68 @@ static const VMStateDescription vmstate_hpet = { }; /* + * This function resets the driftfix state in the following situations. + * + * - When the guest o/s changes the 'CFG_ENABLE' bit (overall enable) + * in the General Configuration Register from 0 to 1. + * + * - When the guest o/s changes the 'TN_ENABLE' bit (timer N interrupt enable) + * in the Timer N Configuration and Capabilities Register from 0 to 1. + */ +static void hpet_timer_driftfix_reset(HPETTimer *t) +{ + if (t->state->driftfix && timer_is_periodic(t)) { + t->ticks_not_accounted = t->prev_period = t->period; + t->irq_rate = 1; + t->divisor = 1; + } +} + +/* + * This function determines whether there is a backlog of ticks for which + * no interrupts have been delivered to the guest o/s yet. If the backlog + * is equal to or greater than the current period length, then additional + * interrupts will be delivered to the guest o/s inside of the subsequent + * period interval to compensate missed interrupts. + * + * 'ticks_not_accounted' increases by 'N * period' when the comparator is + * being advanced, and it decreases by 'prev_period' when an interrupt is + * delivered to the guest o/s. Normally 'prev_period' is equal to 'period' + * and 'N' is 1. 'prev_period' is different from 'period' if a guest o/s + * has changed the comparator value during the previous period interval. + * 'N' is greater than 1 if the callback was delayed by 'N - 1' periods, + * and 'N' is zero while additional interrupts are delivered inside of an + * interval. + * + * This function is called after the comparator has been advanced but before + * the interrupt is delivered to the guest o/s. Hence, 'ticks_not_accounted' + * is equal to 'prev_period' plus 'period' if there is no backlog. + */ +static bool hpet_timer_has_tick_backlog(HPETTimer *t) +{ + uint64_t backlog = 0; + + if (t->ticks_not_accounted >= t->period + t->prev_period) { + backlog = t->ticks_not_accounted - (t->period + t->prev_period); + } + return (backlog >= t->period); +} + +/* * timer expiration callback */ static void hpet_timer(void *opaque) { HPETTimer *t = opaque; + HPETState *s = t->state; uint64_t diff; - + int irq_delivered = 0; + uint32_t period_count = 0; /* elapsed periods since last callback + * 1: normal case + * > 1: missed 'period_count - 1' interrupts + * due to delayed callback + * 0: callback inside of an interval + * to deliver additional interrupts */ uint64_t period = t->period; uint64_t cur_tick = hpet_get_ticks(t->state); @@ -348,13 +407,48 @@ static void hpet_timer(void *opaque) if (t->config & HPET_TN_32BIT) { while (hpet_time_after(cur_tick, t->cmp)) { t->cmp = (uint32_t)(t->cmp + t->period); + t->ticks_not_accounted += t->period; + period_count++; } } else { while (hpet_time_after64(cur_tick, t->cmp)) { t->cmp += period; + t->ticks_not_accounted += period; + period_count++; } } diff = hpet_calculate_diff(t, cur_tick); + if (s->driftfix) { + if (t->ticks_not_accounted > MAX_TICKS_NOT_ACCOUNTED) { + t->ticks_not_accounted = t->period + t->prev_period; + } + if (hpet_timer_has_tick_backlog(t)) { + if (t->irq_rate == 1 || period_count > 1) { + /* Increase the interrupt delivery rate if compensation + * was not already in progress or if this callback was + * delayed. */ + t->irq_rate++; + t->irq_rate = MIN(t->irq_rate, MAX_IRQ_RATE); + } + if (t->divisor == 0) { + assert(period_count); + } + if (period_count) { + /* A non-zero 'period_count' marks the start of a new + * period interval. Initialize the divisor now. */ + t->divisor = t->irq_rate; + } + /* 'diff' is the amount of ticks between the current callback + * and the start of the next period interval. 'diff' becomes + * smaller at each additional callback inside of an interval + * while compensation is in progress. Decrement the divisor + * here, so that the entire interval is divided into parts + * of similar size. */ + diff /= t->divisor--; + } else { + t->irq_rate = 1; + } + } qemu_mod_timer(t->qemu_timer, qemu_get_clock_ns(vm_clock) + (int64_t)ticks_to_ns(diff)); } else if (t->config & HPET_TN_32BIT && !timer_is_periodic(t)) { @@ -365,7 +459,27 @@ static void hpet_timer(void *opaque) t->wrap_flag = 0; } } - update_irq(t, 1); + if (s->driftfix && timer_is_periodic(t) && period != 0) { + if (t->ticks_not_accounted >= t->period + t->prev_period) { + irq_delivered = update_irq(t, 1); + if (irq_delivered) { + t->ticks_not_accounted -= t->prev_period; + t->prev_period = t->period; + } else { + if (period_count) { + /* If the interrupt was not delivered to the guest o/s, + * increase the delivery rate only if this happened at + * the start of a period interval (a failure to deliver + * additional interrupts inside of an interval does not + * cause an increase). */ + t->irq_rate++; + t->irq_rate = MIN(t->irq_rate, MAX_IRQ_RATE); + } + } + } + } else { + update_irq(t, 1); + } } static void hpet_set_timer(HPETTimer *t) @@ -534,6 +648,7 @@ static void hpet_ram_writel(void *opaque, target_phys_addr_t addr, timer->period = (uint32_t)timer->period; } if (activating_bit(old_val, new_val, HPET_TN_ENABLE)) { + hpet_timer_driftfix_reset(timer); hpet_set_timer(timer); } else if (deactivating_bit(old_val, new_val, HPET_TN_ENABLE)) { hpet_del_timer(timer); @@ -608,6 +723,7 @@ static void hpet_ram_writel(void *opaque, target_phys_addr_t addr, ticks_to_ns(s->hpet_counter) - qemu_get_clock_ns(vm_clock); for (i = 0; i < s->num_timers; i++) { if ((&s->timer[i])->cmp != ~0ULL) { + hpet_timer_driftfix_reset(&s->timer[i]); hpet_set_timer(&s->timer[i]); } }