feat: add timer calibration

kernel/include/apic/timer.h

@@ -1,11 +1,19 @@
 #pragma once
 
 #include "acpi/madt.h"
+#include "util/optional.h"
 
 namespace apic {
 
-struct lapic_timer_calibration_t {};
+struct lapic_timer_calibration_t {
+    uint64_t tsc_frequency_hz;
+};
 
-lapic_timer_calibration_t calibrateTimer(const acpi::Madt& madt);
+optional<lapic_timer_calibration_t> calibrateTimer(const acpi::Madt& madt);
+
+// TODO: when dynamic allocation and lists are available
+// struct Timer {};
+//
+// Timer getCoreTimerInstance();
 
 } // namespace apic

kernel/include/util/cpuid.h

@@ -0,0 +1,21 @@
+#pragma once
+
+#include <cpuid.h>
+#include <stdint.h>
+
+#include "util/optional.h"
+
+struct cpuid_result_t {
+    uint32_t eax;
+    uint32_t ebx;
+    uint32_t ecx;
+    uint32_t edx;
+};
+
+inline optional<cpuid_result_t> cpuid(uint32_t leaf, uint32_t subleaf = 0) {
+    cpuid_result_t result{};
+    if (__get_cpuid_count(leaf, subleaf, &result.eax, &result.ebx, &result.ecx, &result.edx) == 0) {
+        return {};
+    }
+    return result;
+}

kernel/include/util/function.h

@@ -1,5 +1,7 @@
 #pragma once
 
+#include "util/utility.h"
+
 template<typename... Ts>
 struct overloaded : Ts... {
     using Ts::operator()...;
@@ -7,3 +9,17 @@ struct overloaded : Ts... {
 
 template<typename... Ts>
 overloaded(Ts...) -> overloaded<Ts...>;
+
+template<typename Func, typename... BoundArgs>
+auto partial(Func func, BoundArgs... bound_args) {
+    return [func, bound_args...](auto&&... call_args) {
+        return func(bound_args..., forward<decltype(call_args)>(call_args)...);
+    };
+}
+
+template<typename Type>
+auto construct() {
+    return [](auto&&... args) {
+        return Type{forward<decltype(args)>(args)...};
+    };
+}

kernel/include/util/optional.h

@@ -9,6 +9,9 @@
 // instead of <utility>. The CrackOS3 value_or_panic() helper is omitted because
 // there is no global panic() in this tree yet.
 
+struct nullopt_t {};
+inline constexpr nullopt_t nullopt{};
+
 template<typename T>
 struct optional {
 private:
@@ -26,6 +29,7 @@ public:
     using value_type = T;
 
     constexpr optional() : initialized(false) {}
+    constexpr optional(nullopt_t) : initialized(false) {}
     optional(const T& value) : initialized(true) {
         new (buffer) T(value);
     }
@@ -135,10 +139,45 @@ public:
         return !initialized;
     }
 
-    template<typename R, typename Func, typename... ArgT>
+    template<typename Func>
-    optional<R> map(Func func, ArgT... args) {
+    auto map(Func&& func) -> optional<decltype(func(value()))> {
         if (initialized) {
-            return func(value(), forward<ArgT>(args)...);
+            return func(value());
+        } else {
+            return {};
+        }
+    }
+
+    template<typename Func>
+    auto map(Func&& func) const -> optional<decltype(func(value()))> {
+        if (initialized) {
+            return func(value());
+        } else {
+            return {};
+        }
+    }
+
+    template<typename Func>
+    optional or_else(Func&& func) const {
+        if (initialized) {
+            return *this;
+        }
+        return func();
+    }
+
+    template<typename Func>
+    auto bind(Func&& func) -> decltype(func(value())) {
+        if (initialized) {
+            return func(value());
+        } else {
+            return {};
+        }
+    }
+
+    template<typename Func>
+    auto bind(Func&& func) const -> decltype(func(value())) {
+        if (initialized) {
+            return func(value());
         } else {
             return {};
         }

kernel/src/apic/timer.cpp

@@ -0,0 +1,55 @@
+#include "apic/timer.h"
+
+#include "util/cpuid.h"
+#include "util/function.h"
+
+namespace {
+
+constexpr uint32_t feature_info_leaf = 0x1;
+constexpr uint32_t tsc_crystal_ratio_leaf = 0x15;
+constexpr uint32_t processor_frequency_leaf = 0x16;
+
+constexpr uint32_t feature_edx_tsc = 1u << 4;
+
+bool isTscSupported() {
+    return cpuid(feature_info_leaf)
+        .map([](const cpuid_result_t& features) {
+            return (features.edx & feature_edx_tsc) != 0;
+        })
+        .value_or(false);
+}
+
+optional<uint64_t> tscFrequencyFromCrystalRatio() {
+    return cpuid(tsc_crystal_ratio_leaf).bind([](const cpuid_result_t& ratio) -> optional<uint64_t> {
+        uint64_t denominator = ratio.eax;
+        uint64_t numerator = ratio.ebx;
+        uint64_t crystal_frequency_hz = ratio.ecx;
+        if (denominator == 0 || numerator == 0 || crystal_frequency_hz == 0) {
+            return nullopt;
+        }
+        return crystal_frequency_hz * numerator / denominator;
+    });
+}
+
+optional<uint64_t> tscFrequencyFromProcessorBase() {
+    return cpuid(processor_frequency_leaf).bind([](const cpuid_result_t& frequency_info) -> optional<uint64_t> {
+        uint64_t base_frequency_mhz = frequency_info.eax & 0xFFFF;
+        if (base_frequency_mhz == 0) {
+            return nullopt;
+        }
+        return base_frequency_mhz * 1'000'000;
+    });
+}
+
+optional<uint64_t> tscFrequency() {
+    return tscFrequencyFromCrystalRatio().or_else(tscFrequencyFromProcessorBase);
+}
+
+} // namespace
+
+optional<apic::lapic_timer_calibration_t> apic::calibrateTimer(const acpi::Madt&) {
+    if (!isTscSupported()) {
+        return {};
+    }
+    return tscFrequency().map(construct<lapic_timer_calibration_t>());
+}