1
Fork 0
mirror of https://github.com/RGBCube/serenity synced 2025-07-25 15:47:44 +00:00

Kernel: Set up and calibrate APIC timer, and enable timer on all CPUs

This enables the APIC timer on all CPUs, which means Scheduler::timer_tick
is now called on all CPUs independently. We still don't do anything on
the APs as it instantly crashes due to a number of other problems.
This commit is contained in:
Tom 2020-10-25 09:13:47 -06:00 committed by Andreas Kling
parent 9d347352a1
commit fe615e601a
14 changed files with 478 additions and 70 deletions

View file

@ -35,37 +35,114 @@
namespace Kernel {
enum class HardwareTimerType {
i8253 = 0x1, /* PIT */
RTC = 0x2, /* Real Time Clock */
HighPrecisionEventTimer = 0x3 /* also known as IA-PC HPET */
i8253 = 0x1, /* PIT */
RTC = 0x2, /* Real Time Clock */
HighPrecisionEventTimer = 0x3, /* also known as IA-PC HPET */
LocalAPICTimer = 0x4 /* Local APIC */
};
class HardwareTimer
: public RefCounted<HardwareTimer>
, public IRQHandler {
template<typename InterruptHandlerType>
class HardwareTimer;
class HardwareTimerBase
: public RefCounted<HardwareTimerBase> {
public:
virtual HardwareTimerType timer_type() const = 0;
virtual ~HardwareTimerBase() { }
virtual const char* model() const = 0;
virtual const char* purpose() const override;
void set_callback(Function<void(const RegisterState&)>);
virtual size_t ticks_per_second() const = 0;
virtual HardwareTimerType timer_type() const = 0;
virtual Function<void(const RegisterState&)> set_callback(Function<void(const RegisterState&)>) = 0;
virtual bool is_periodic() const = 0;
virtual bool is_periodic_capable() const = 0;
virtual void set_periodic() = 0;
virtual void set_non_periodic() = 0;
virtual size_t ticks_per_second() const = 0;
virtual void reset_to_default_ticks_per_second() = 0;
virtual bool try_to_set_frequency(size_t frequency) = 0;
virtual bool is_capable_of_frequency(size_t frequency) const = 0;
virtual size_t calculate_nearest_possible_frequency(size_t frequency) const = 0;
};
template<>
class HardwareTimer<IRQHandler>
: public HardwareTimerBase
, public IRQHandler {
public:
virtual const char* purpose() const override
{
if (TimeManagement::the().is_system_timer(*this))
return "System Timer";
return model();
}
virtual Function<void(const RegisterState&)> set_callback(Function<void(const RegisterState&)> callback) override
{
disable_irq();
auto previous_callback = move(m_callback);
m_callback = move(callback);
enable_irq();
return previous_callback;
}
protected:
HardwareTimer(u8 irq_number, Function<void(const RegisterState&)> = nullptr);
//^IRQHandler
virtual void handle_irq(const RegisterState&) override;
HardwareTimer(u8 irq_number, Function<void(const RegisterState&)> callback = nullptr)
: IRQHandler(irq_number)
, m_callback(move(callback))
{
}
virtual void handle_irq(const RegisterState& regs) override
{
if (m_callback)
m_callback(regs);
}
u64 m_frequency { OPTIMAL_TICKS_PER_SECOND_RATE };
private:
Function<void(const RegisterState&)> m_callback;
};
template<>
class HardwareTimer<GenericInterruptHandler>
: public HardwareTimerBase
, public GenericInterruptHandler {
public:
virtual const char* purpose() const override
{
return model();
}
virtual Function<void(const RegisterState&)> set_callback(Function<void(const RegisterState&)> callback) override
{
auto previous_callback = move(m_callback);
m_callback = move(callback);
return previous_callback;
}
virtual size_t sharing_devices_count() const override { return 0; }
virtual bool is_shared_handler() const override { return false; }
virtual bool is_sharing_with_others() const { return false; }
virtual HandlerType type() const override { return HandlerType::IRQHandler; }
virtual const char* controller() const override { return nullptr; }
virtual bool eoi() override;
protected:
HardwareTimer(u8 irq_number, Function<void(const RegisterState&)> callback = nullptr)
: GenericInterruptHandler(irq_number)
, m_callback(move(callback))
{
}
virtual void handle_interrupt(const RegisterState& regs) override
{
if (m_callback)
m_callback(regs);
}
u64 m_frequency { OPTIMAL_TICKS_PER_SECOND_RATE };
private: