Ladybird/ladybird
1
0
Fork 0
mirror of https://github.com/LadybirdBrowser/ladybird.git synced 2025-06-12 02:30:30 +09:00
Code Activity

Kernel: Fix HPET timer not firing in Bochs

Browse source 
* Change the register structures to use the volatile keyword explicitly
  on the register values. This avoids accidentally omitting it as any
  access will be guaranteed volatile.
* Don't assume we can read/write 64 bit value to the main counter and
  the comparator. Not all HPET implementations may support this. So,
  just use 32 bit words to access the registers. This ultimately works
  around a bug in Bochs 2.6.11 that loses 32 bits of a 64 bit write to
  a timer's comparator register (it internally writes one half and
  clears the Tn_VAL_SET_CNF bit, and then because it's cleared it
  fails to write the second half).
* Properly calculate the tick duration in calculate_ticks_in_nanoseconds
* As per specification, changing the frequency of one periodic timer
  requires a restart of all periodic timers as it requires the main
  counter to be reset.
This commit is contained in:
Tom 2020-11-03 13:19:42 -07:00 • committed by Andreas Kling
parent 348cd0fdc1
commit d5bb5d109b
Notes: sideshowbarker 2024-07-19 01:32:30 +09:00
4 changed files with 158 additions and 95 deletions
Download patch file Download diff file Expand all files Collapse all files

212
Kernel/Time/HPET.cpp
View file

@ -48,58 +48,78 @@ enum class Attributes {
}; };
enum class Configuration { enum class Configuration {
Enable = 0x1, Enable = 1 << 0,
LegacyReplacementRoute = 0x2 LegacyReplacementRoute = 1 << 1
}; };
enum class TimerConfiguration : u32 { enum class TimerConfiguration : u32 {
InterruptType = 1 << 1, LevelTriggered = 1 << 1,
InterruptEnable = 1 << 2, InterruptEnable = 1 << 2,
TimerType = 1 << 3, GeneratePeriodicInterrupt = 1 << 3,
PeriodicInterruptCapable = 1 << 4, PeriodicInterruptCapable = 1 << 4,
Timer64BitsCapable = 1 << 5, Timer64BitsCapable = 1 << 5,
ValueSet = 1 << 6, ValueSet = 1 << 6,
Force32BitMode = 1 << 7, Force32BitMode = 1 << 8,
FSBInterruptEnable = 1 << 14, FSBInterruptEnable = 1 << 14,
FSBInterruptDelivery = 1 << 15 FSBInterruptDelivery = 1 << 15
}; };
}; };
struct [[gnu::packed]] HPETRegister
{
volatile u32 low;
volatile u32 high;
};
struct [[gnu::packed]] TimerStructure struct [[gnu::packed]] TimerStructure
{ {
u64 configuration_and_capability; volatile u32 capabilities;
u64 comparator_value; volatile u32 interrupt_routing;
u64 fsb_interrupt_route; HPETRegister comparator_value;
volatile u64 fsb_interrupt_route;
u64 reserved; u64 reserved;
}; };
struct [[gnu::packed]] HPETCapabilityRegister struct [[gnu::packed]] HPETCapabilityRegister
{ {
u32 attributes; // Note: We must do a 32 bit access to offsets 0x0, or 0x4 only, according to HPET spec. // Note: We must do a 32 bit access to offsets 0x0, or 0x4 only, according to HPET spec.
u32 main_counter_tick_period; volatile u32 attributes;
u64 reserved; volatile u32 main_counter_tick_period;
};
struct [[gnu::packed]] HPETRegister
{
u64 reg;
u64 reserved; u64 reserved;
}; };
struct [[gnu::packed]] HPETRegistersBlock struct [[gnu::packed]] HPETRegistersBlock
{ {
union { HPETCapabilityRegister capabilities;
HPETCapabilityRegister capabilities;
HPETRegister raw_capabilites;
};
HPETRegister configuration; HPETRegister configuration;
u64 reserved1;
HPETRegister interrupt_status; HPETRegister interrupt_status;
u8 reserved[0xF0 - 48]; u8 reserved2[0xF0 - 0x28];
HPETRegister main_counter_value; HPETRegister main_counter_value;
u64 reserved3;
TimerStructure timers[3]; TimerStructure timers[3];
u8 reserved2[0x400 - 0x160]; u8 reserved4[0x400 - 0x160];
}; };
static_assert(__builtin_offsetof(HPETRegistersBlock, main_counter_value) == 0xf0);
static_assert(__builtin_offsetof(HPETRegistersBlock, timers[0]) == 0x100);
static_assert(__builtin_offsetof(HPETRegistersBlock, timers[1]) == 0x120);
static u64 read_register_safe64(const HPETRegister& reg)
{
// As per 2.4.7 this reads the 64 bit value in a consistent manner
// using only 32 bit reads
u32 low, high = reg.high;
for (;;) {
low = reg.low;
u32 new_high = reg.high;
if (new_high == high)
break;
high = new_high;
}
return ((u64)high << 32) | (u64)low;
}
static HPET* s_hpet; static HPET* s_hpet;
static bool hpet_initialized { false }; static bool hpet_initialized { false };
@ -135,7 +155,7 @@ bool HPET::test_and_initialize()
return false; return false;
} }
} }
s_hpet = new HPET(PhysicalAddress(hpet)); new HPET(PhysicalAddress(hpet));
return true; return true;
} }
@ -147,11 +167,11 @@ bool HPET::check_for_exisiting_periodic_timers()
auto sdt = map_typed<ACPI::Structures::HPET>(hpet); auto sdt = map_typed<ACPI::Structures::HPET>(hpet);
ASSERT(sdt->event_timer_block.address_space == 0); ASSERT(sdt->event_timer_block.address_space == 0);
auto registers = map_typed<volatile HPETRegistersBlock>(PhysicalAddress(sdt->event_timer_block.address)); auto registers = map_typed<HPETRegistersBlock>(PhysicalAddress(sdt->event_timer_block.address));
size_t timers_count = ((registers->raw_capabilites.reg >> 8) & 0x1f) + 1; size_t timers_count = ((registers->capabilities.attributes >> 8) & 0x1f) + 1;
for (size_t index = 0; index < timers_count; index++) { for (size_t index = 0; index < timers_count; index++) {
if (registers->timers[index].configuration_and_capability & (u32)HPETFlags::TimerConfiguration::PeriodicInterruptCapable) if (registers->timers[index].capabilities & (u32)HPETFlags::TimerConfiguration::PeriodicInterruptCapable)
return true; return true;
} }
return false; return false;
@ -159,30 +179,67 @@ bool HPET::check_for_exisiting_periodic_timers()
void HPET::global_disable() void HPET::global_disable()
{ {
registers().configuration.reg = registers().configuration.reg & ~(u32)HPETFlags::Configuration::Enable; auto& regs = registers();
regs.configuration.low = regs.configuration.low & ~(u32)HPETFlags::Configuration::Enable;
} }
void HPET::global_enable() void HPET::global_enable()
{ {
registers().configuration.reg = registers().configuration.reg | (u32)HPETFlags::Configuration::Enable; auto& regs = registers();
regs.configuration.low = regs.configuration.low | (u32)HPETFlags::Configuration::Enable;
} }
void HPET::set_periodic_comparator_value(const HPETComparator& comparator, u64 value) void HPET::update_periodic_comparator_value()
{ {
disable(comparator); // According to 2.3.9.2.2 the only safe way to change the periodic timer frequency
ASSERT(comparator.is_periodic()); // is to disable all periodic timers, reset the main counter and each timer's comparator value.
ASSERT(comparator.comparator_number() <= m_comparators.size()); // This introduces time drift, so it should be avoided unless absolutely necessary.
volatile auto& timer = registers().timers[comparator.comparator_number()]; global_disable();
timer.configuration_and_capability = timer.configuration_and_capability | (u32)HPETFlags::TimerConfiguration::ValueSet; auto& regs = registers();
timer.comparator_value = value;
enable(comparator); u64 previous_main_value = (u64)regs.main_counter_value.low | ((u64)regs.main_counter_value.high << 32);
regs.main_counter_value.low = 0;
regs.main_counter_value.high = 0;
for (auto& comparator : m_comparators) {
auto& timer = regs.timers[comparator.comparator_number()];
if (comparator.is_periodic()) {
// Note that this means we're restarting all periodic timers. There is no
// way to resume periodic timers properly because we reset the main counter
// and we can only write the period into the comparator value...
timer.capabilities = timer.capabilities | (u32)HPETFlags::TimerConfiguration::ValueSet;
u64 value = frequency() / comparator.ticks_per_second();
#ifdef HPET_DEBUG
dbg() << "HPET: Update periodic comparator " << comparator.comparator_number() << " comparator value to " << value << " main value was: " << previous_main_value;
#endif
timer.comparator_value.low = (u32)value;
timer.capabilities = timer.capabilities | (u32)HPETFlags::TimerConfiguration::ValueSet;
timer.comparator_value.high = (u32)(value >> 32);
} else {
// Set the new target comparator value to the delta to the remaining ticks
u64 current_value = (u64)timer.comparator_value.low | ((u64)timer.comparator_value.high << 32);
u64 value = current_value - previous_main_value;
#ifdef HPET_DEBUG
dbg() << "HPET: Update non-periodic comparator " << comparator.comparator_number() << " comparator value from " << current_value << " to " << value << " main value was: " << previous_main_value;
#endif
timer.comparator_value.low = (u32)value;
timer.comparator_value.high = (u32)(value >> 32);
}
}
global_enable();
} }
void HPET::set_non_periodic_comparator_value(const HPETComparator& comparator, u64 value) void HPET::update_non_periodic_comparator_value(const HPETComparator& comparator)
{ {
ASSERT_INTERRUPTS_DISABLED(); ASSERT_INTERRUPTS_DISABLED();
ASSERT(!comparator.is_periodic()); ASSERT(!comparator.is_periodic());
ASSERT(comparator.comparator_number() <= m_comparators.size()); ASSERT(comparator.comparator_number() <= m_comparators.size());
registers().timers[comparator.comparator_number()].comparator_value = main_counter_value() + value; auto& regs = registers();
auto& timer = regs.timers[comparator.comparator_number()];
u64 value = frequency() / comparator.ticks_per_second();
// NOTE: If the main counter passes this new value before we finish writing it, we will never receive an interrupt!
u64 new_counter_value = read_register_safe64(regs.main_counter_value) + value;
timer.comparator_value.high = (u32)(new_counter_value >> 32);
timer.comparator_value.low = (u32)new_counter_value;
} }
void HPET::enable_periodic_interrupt(const HPETComparator& comparator) void HPET::enable_periodic_interrupt(const HPETComparator& comparator)
@ -192,10 +249,10 @@ void HPET::enable_periodic_interrupt(const HPETComparator& comparator)
#endif #endif
disable(comparator); disable(comparator);
ASSERT(comparator.comparator_number() <= m_comparators.size()); ASSERT(comparator.comparator_number() <= m_comparators.size());
volatile auto& timer = registers().timers[comparator.comparator_number()]; auto& timer = registers().timers[comparator.comparator_number()];
auto configuration_and_capability = timer.configuration_and_capability; auto capabilities = timer.capabilities;
ASSERT(configuration_and_capability & (u32)HPETFlags::TimerConfiguration::PeriodicInterruptCapable); ASSERT(capabilities & (u32)HPETFlags::TimerConfiguration::PeriodicInterruptCapable);
timer.configuration_and_capability = configuration_and_capability | (u32)HPETFlags::TimerConfiguration::TimerType; timer.capabilities = capabilities | (u32)HPETFlags::TimerConfiguration::GeneratePeriodicInterrupt;
enable(comparator); enable(comparator);
} }
void HPET::disable_periodic_interrupt(const HPETComparator& comparator) void HPET::disable_periodic_interrupt(const HPETComparator& comparator)
@ -205,10 +262,10 @@ void HPET::disable_periodic_interrupt(const HPETComparator& comparator)
#endif #endif
disable(comparator); disable(comparator);
ASSERT(comparator.comparator_number() <= m_comparators.size()); ASSERT(comparator.comparator_number() <= m_comparators.size());
auto volatile& timer = registers().timers[comparator.comparator_number()]; auto& timer = registers().timers[comparator.comparator_number()];
auto configuration_and_capability = timer.configuration_and_capability; auto capabilities = timer.capabilities;
ASSERT(configuration_and_capability & (u32)HPETFlags::TimerConfiguration::PeriodicInterruptCapable); ASSERT(capabilities & (u32)HPETFlags::TimerConfiguration::PeriodicInterruptCapable);
timer.configuration_and_capability = configuration_and_capability & ~(u32)HPETFlags::TimerConfiguration::TimerType; timer.capabilities = capabilities & ~(u32)HPETFlags::TimerConfiguration::GeneratePeriodicInterrupt;
enable(comparator); enable(comparator);
} }
@ -218,8 +275,8 @@ void HPET::disable(const HPETComparator& comparator)
klog() << "HPET: Disable comparator " << comparator.comparator_number() << "."; klog() << "HPET: Disable comparator " << comparator.comparator_number() << ".";
#endif #endif
ASSERT(comparator.comparator_number() <= m_comparators.size()); ASSERT(comparator.comparator_number() <= m_comparators.size());
volatile auto& timer = registers().timers[comparator.comparator_number()]; auto& timer = registers().timers[comparator.comparator_number()];
timer.configuration_and_capability = timer.configuration_and_capability & ~(u32)HPETFlags::TimerConfiguration::InterruptEnable; timer.capabilities = timer.capabilities & ~(u32)HPETFlags::TimerConfiguration::InterruptEnable;
} }
void HPET::enable(const HPETComparator& comparator) void HPET::enable(const HPETComparator& comparator)
{ {
@ -227,13 +284,8 @@ void HPET::enable(const HPETComparator& comparator)
klog() << "HPET: Enable comparator " << comparator.comparator_number() << "."; klog() << "HPET: Enable comparator " << comparator.comparator_number() << ".";
#endif #endif
ASSERT(comparator.comparator_number() <= m_comparators.size()); ASSERT(comparator.comparator_number() <= m_comparators.size());
volatile auto& timer = registers().timers[comparator.comparator_number()]; auto& timer = registers().timers[comparator.comparator_number()];
timer.configuration_and_capability = timer.configuration_and_capability | (u32)HPETFlags::TimerConfiguration::InterruptEnable; timer.capabilities = timer.capabilities | (u32)HPETFlags::TimerConfiguration::InterruptEnable;
}
u64 HPET::main_counter_value() const
{
return registers().main_counter_value.reg;
} }
u64 HPET::frequency() const u64 HPET::frequency() const
@ -245,8 +297,8 @@ Vector<unsigned> HPET::capable_interrupt_numbers(const HPETComparator& comparato
{ {
ASSERT(comparator.comparator_number() <= m_comparators.size()); ASSERT(comparator.comparator_number() <= m_comparators.size());
Vector<unsigned> capable_interrupts; Vector<unsigned> capable_interrupts;
auto& comparator_registers = (const volatile TimerStructure&)registers().timers[comparator.comparator_number()]; auto& comparator_registers = registers().timers[comparator.comparator_number()];
u32 interrupt_bitfield = comparator_registers.configuration_and_capability >> 32; u32 interrupt_bitfield = comparator_registers.interrupt_routing;
for (size_t index = 0; index < 32; index++) { for (size_t index = 0; index < 32; index++) {
if (interrupt_bitfield & 1) if (interrupt_bitfield & 1)
capable_interrupts.append(index); capable_interrupts.append(index);
@ -259,8 +311,8 @@ Vector<unsigned> HPET::capable_interrupt_numbers(u8 comparator_number)
{ {
ASSERT(comparator_number <= m_comparators.size()); ASSERT(comparator_number <= m_comparators.size());
Vector<unsigned> capable_interrupts; Vector<unsigned> capable_interrupts;
auto& comparator_registers = (const volatile TimerStructure&)registers().timers[comparator_number]; auto& comparator_registers = registers().timers[comparator_number];
u32 interrupt_bitfield = comparator_registers.configuration_and_capability >> 32; u32 interrupt_bitfield = comparator_registers.interrupt_routing;
for (size_t index = 0; index < 32; index++) { for (size_t index = 0; index < 32; index++) {
if (interrupt_bitfield & 1) if (interrupt_bitfield & 1)
capable_interrupts.append(index); capable_interrupts.append(index);
@ -272,15 +324,15 @@ Vector<unsigned> HPET::capable_interrupt_numbers(u8 comparator_number)
void HPET::set_comparator_irq_vector(u8 comparator_number, u8 irq_vector) void HPET::set_comparator_irq_vector(u8 comparator_number, u8 irq_vector)
{ {
ASSERT(comparator_number <= m_comparators.size()); ASSERT(comparator_number <= m_comparators.size());
auto& comparator_registers = (volatile TimerStructure&)registers().timers[comparator_number]; auto& comparator_registers = registers().timers[comparator_number];
comparator_registers.configuration_and_capability = comparator_registers.configuration_and_capability | (irq_vector << 9); comparator_registers.capabilities = comparator_registers.capabilities | (irq_vector << 9);
} }
bool HPET::is_periodic_capable(u8 comparator_number) const bool HPET::is_periodic_capable(u8 comparator_number) const
{ {
ASSERT(comparator_number <= m_comparators.size()); ASSERT(comparator_number <= m_comparators.size());
auto& comparator_registers = (const volatile TimerStructure&)registers().timers[comparator_number]; auto& comparator_registers = registers().timers[comparator_number];
return comparator_registers.configuration_and_capability & (u32)HPETFlags::TimerConfiguration::PeriodicInterruptCapable; return comparator_registers.capabilities & (u32)HPETFlags::TimerConfiguration::PeriodicInterruptCapable;
} }
void HPET::set_comparators_to_optimal_interrupt_state(size_t) void HPET::set_comparators_to_optimal_interrupt_state(size_t)
@ -296,19 +348,20 @@ PhysicalAddress HPET::find_acpi_hpet_registers_block()
return PhysicalAddress(sdt->event_timer_block.address); return PhysicalAddress(sdt->event_timer_block.address);
} }
const volatile HPETRegistersBlock& HPET::registers() const const HPETRegistersBlock& HPET::registers() const
{ {
return *(const volatile HPETRegistersBlock*)m_hpet_mmio_region->vaddr().offset(m_physical_acpi_hpet_registers.offset_in_page()).as_ptr(); return *(const HPETRegistersBlock*)m_hpet_mmio_region->vaddr().offset(m_physical_acpi_hpet_registers.offset_in_page()).as_ptr();
} }
volatile HPETRegistersBlock& HPET::registers() HPETRegistersBlock& HPET::registers()
{ {
return *(volatile HPETRegistersBlock*)m_hpet_mmio_region->vaddr().offset(m_physical_acpi_hpet_registers.offset_in_page()).as_ptr(); return *(HPETRegistersBlock*)m_hpet_mmio_region->vaddr().offset(m_physical_acpi_hpet_registers.offset_in_page()).as_ptr();
} }
u64 HPET::calculate_ticks_in_nanoseconds() const u64 HPET::calculate_ticks_in_nanoseconds() const
{ {
return ABSOLUTE_MAXIMUM_COUNTER_TICK_PERIOD / registers().capabilities.main_counter_tick_period; // ABSOLUTE_MAXIMUM_COUNTER_TICK_PERIOD == 100 nanoseconds
return ((u64)registers().capabilities.main_counter_tick_period * 100ull) / ABSOLUTE_MAXIMUM_COUNTER_TICK_PERIOD;
} }
HPET::HPET(PhysicalAddress acpi_hpet) HPET::HPET(PhysicalAddress acpi_hpet)
@ -316,27 +369,36 @@ HPET::HPET(PhysicalAddress acpi_hpet)
, m_physical_acpi_hpet_registers(find_acpi_hpet_registers_block()) , m_physical_acpi_hpet_registers(find_acpi_hpet_registers_block())
, m_hpet_mmio_region(MM.allocate_kernel_region(m_physical_acpi_hpet_registers.page_base(), PAGE_SIZE, "HPET MMIO", Region::Access::Read | Region::Access::Write)) , m_hpet_mmio_region(MM.allocate_kernel_region(m_physical_acpi_hpet_registers.page_base(), PAGE_SIZE, "HPET MMIO", Region::Access::Read | Region::Access::Write))
{ {
s_hpet = this; // Make available as soon as possible so that IRQs can use it
auto sdt = map_typed<const volatile ACPI::Structures::HPET>(m_physical_acpi_hpet_table); auto sdt = map_typed<const volatile ACPI::Structures::HPET>(m_physical_acpi_hpet_table);
m_vendor_id = sdt->pci_vendor_id; m_vendor_id = sdt->pci_vendor_id;
m_minimum_tick = sdt->mininum_clock_tick; m_minimum_tick = sdt->mininum_clock_tick;
klog() << "HPET: Minimum clock tick - " << m_minimum_tick; klog() << "HPET: Minimum clock tick - " << m_minimum_tick;
auto& regs = registers();
// Note: We must do a 32 bit access to offsets 0x0, or 0x4 only. // Note: We must do a 32 bit access to offsets 0x0, or 0x4 only.
size_t timers_count = ((registers().raw_capabilites.reg >> 8) & 0x1f) + 1; size_t timers_count = ((regs.capabilities.attributes >> 8) & 0x1f) + 1;
klog() << "HPET: Timers count - " << timers_count; klog() << "HPET: Timers count - " << timers_count;
klog() << "HPET: Main counter size: " << ((regs.capabilities.attributes & (u32)HPETFlags::Attributes::Counter64BitCapable) ? "64 bit" : "32 bit");
for (size_t i = 0; i < timers_count; i++) {
bool capable_64_bit = regs.timers[i].capabilities & (u32)HPETFlags::TimerConfiguration::Timer64BitsCapable;
klog() << "HPET: Timer[" << i << "] comparator size: " << (capable_64_bit ? "64 bit" : "32 bit") << " mode: " << ((!capable_64_bit || (regs.timers[i].capabilities & (u32)HPETFlags::TimerConfiguration::Force32BitMode)) ? "32 bit" : "64 bit");
}
ASSERT(timers_count >= 2); ASSERT(timers_count >= 2);
auto* capabilities_register = (const volatile HPETCapabilityRegister*)&registers().raw_capabilites.reg;
global_disable(); global_disable();
m_frequency = NANOSECOND_PERIOD_TO_HERTZ(calculate_ticks_in_nanoseconds()); m_frequency = NANOSECOND_PERIOD_TO_HERTZ(calculate_ticks_in_nanoseconds());
klog() << "HPET: frequency " << m_frequency << " Hz (" << MEGAHERTZ_TO_HERTZ(m_frequency) << " MHz)"; klog() << "HPET: frequency " << m_frequency << " Hz (" << MEGAHERTZ_TO_HERTZ(m_frequency) << " MHz) resolution: " << calculate_ticks_in_nanoseconds() << "ns";
ASSERT(capabilities_register->main_counter_tick_period <= ABSOLUTE_MAXIMUM_COUNTER_TICK_PERIOD); ASSERT(regs.capabilities.main_counter_tick_period <= ABSOLUTE_MAXIMUM_COUNTER_TICK_PERIOD);
// Reset the counter, just in case... // Reset the counter, just in case...
registers().main_counter_value.reg = 0; regs.main_counter_value.high = 0;
if (registers().raw_capabilites.reg & (u32)HPETFlags::Attributes::LegacyReplacementRouteCapable) regs.main_counter_value.low = 0;
registers().configuration.reg = registers().configuration.reg | (u32)HPETFlags::Configuration::LegacyReplacementRoute; if (regs.capabilities.attributes & (u32)HPETFlags::Attributes::LegacyReplacementRouteCapable)
regs.configuration.low = regs.configuration.low | (u32)HPETFlags::Configuration::LegacyReplacementRoute;
m_comparators.append(HPETComparator::create(0, 0, is_periodic_capable(0))); m_comparators.append(HPETComparator::create(0, 0, is_periodic_capable(0)));
m_comparators.append(HPETComparator::create(1, 8, is_periodic_capable(1))); m_comparators.append(HPETComparator::create(1, 8, is_periodic_capable(1)));

9
Kernel/Time/HPET.h
View file

@ -45,15 +45,14 @@ public:
static bool check_for_exisiting_periodic_timers(); static bool check_for_exisiting_periodic_timers();
static HPET& the(); static HPET& the();
u64 main_counter_value() const;
u64 frequency() const; u64 frequency() const;
const NonnullRefPtrVector<HPETComparator>& comparators() const { return m_comparators; } const NonnullRefPtrVector<HPETComparator>& comparators() const { return m_comparators; }
void disable(const HPETComparator&); void disable(const HPETComparator&);
void enable(const HPETComparator&); void enable(const HPETComparator&);
void set_periodic_comparator_value(const HPETComparator& comparator, u64 value); void update_periodic_comparator_value();
void set_non_periodic_comparator_value(const HPETComparator& comparator, u64 value); void update_non_periodic_comparator_value(const HPETComparator& comparator);
void set_comparator_irq_vector(u8 comparator_number, u8 irq_vector); void set_comparator_irq_vector(u8 comparator_number, u8 irq_vector);
@ -64,8 +63,8 @@ public:
Vector<unsigned> capable_interrupt_numbers(const HPETComparator&); Vector<unsigned> capable_interrupt_numbers(const HPETComparator&);
private: private:
const volatile HPETRegistersBlock& registers() const; const HPETRegistersBlock& registers() const;
volatile HPETRegistersBlock& registers(); HPETRegistersBlock& registers();
void global_disable(); void global_disable();
void global_enable(); void global_enable();

29
Kernel/Time/HPETComparator.cpp
View file

@ -48,14 +48,14 @@ HPETComparator::HPETComparator(u8 number, u8 irq, bool periodic_capable)
void HPETComparator::set_periodic() void HPETComparator::set_periodic()
{ {
ASSERT(m_periodic_capable); ASSERT(m_periodic_capable);
HPET::the().enable_periodic_interrupt(*this);
m_periodic = true; m_periodic = true;
HPET::the().enable_periodic_interrupt(*this);
} }
void HPETComparator::set_non_periodic() void HPETComparator::set_non_periodic()
{ {
ASSERT(m_periodic_capable); ASSERT(m_periodic_capable);
HPET::the().disable_periodic_interrupt(*this);
m_periodic = false; m_periodic = false;
HPET::the().disable_periodic_interrupt(*this);
} }
void HPETComparator::handle_irq(const RegisterState& regs) void HPETComparator::handle_irq(const RegisterState& regs)
@ -69,7 +69,7 @@ void HPETComparator::set_new_countdown()
{ {
ASSERT_INTERRUPTS_DISABLED(); ASSERT_INTERRUPTS_DISABLED();
ASSERT(m_frequency <= HPET::the().frequency()); ASSERT(m_frequency <= HPET::the().frequency());
HPET::the().set_non_periodic_comparator_value(*this, HPET::the().frequency() / m_frequency); HPET::the().update_non_periodic_comparator_value(*this);
} }
size_t HPETComparator::ticks_per_second() const size_t HPETComparator::ticks_per_second() const
@ -91,20 +91,21 @@ bool HPETComparator::try_to_set_frequency(size_t frequency)
InterruptDisabler disabler; InterruptDisabler disabler;
if (!is_capable_of_frequency(frequency)) if (!is_capable_of_frequency(frequency))
return false; return false;
disable_irq(); if (m_frequency == frequency)
return true;
auto hpet_frequency = HPET::the().frequency(); auto hpet_frequency = HPET::the().frequency();
ASSERT(frequency <= hpet_frequency); ASSERT(frequency <= hpet_frequency);
#ifdef HPET_COMPARATOR_DEBUG
dbg() << "HPET Comparator: Max frequency - " << hpet_frequency << " Hz, want to set " << frequency << " Hz";
#endif
if (is_periodic())
HPET::the().set_periodic_comparator_value(*this, hpet_frequency / frequency);
else {
HPET::the().set_non_periodic_comparator_value(*this, hpet_frequency / frequency);
HPET::the().enable(*this);
}
m_frequency = frequency; m_frequency = frequency;
enable_irq(); #ifdef HPET_COMPARATOR_DEBUG
dbg() << "HPET Comparator: Max frequency " << hpet_frequency << " Hz, want to set " << frequency << " Hz, periodic: " << is_periodic();
#endif
if (is_periodic()) {
HPET::the().update_periodic_comparator_value();
} else {
HPET::the().update_non_periodic_comparator_value(*this);
}
enable_irq(); // Enable if we haven't already
return true; return true;
} }
bool HPETComparator::is_capable_of_frequency(size_t frequency) const bool HPETComparator::is_capable_of_frequency(size_t frequency) const

3
Kernel/Time/TimeManagement.cpp
View file

@ -225,9 +225,10 @@ bool TimeManagement::probe_and_set_non_legacy_hardware_timers()
} }
m_system_timer->set_callback(Scheduler::timer_tick); m_system_timer->set_callback(Scheduler::timer_tick);
m_time_keeper_timer->set_callback(TimeManagement::update_time);
dbg() << "Reset timers"; dbg() << "Reset timers";
m_system_timer->try_to_set_frequency(m_system_timer->calculate_nearest_possible_frequency(1024)); m_system_timer->try_to_set_frequency(m_system_timer->calculate_nearest_possible_frequency(1024));
m_time_keeper_timer->set_callback(TimeManagement::update_time);
m_time_keeper_timer->try_to_set_frequency(OPTIMAL_TICKS_PER_SECOND_RATE); m_time_keeper_timer->try_to_set_frequency(OPTIMAL_TICKS_PER_SECOND_RATE);
return true; return true;