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

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

Browse source 
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
Download patch file Download diff file Expand all files Collapse all files

107
Kernel/Time/HardwareTimer.h
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: