interrupt.h

Go to the documentation of this file.

 
#pragma once
 
#include <cpu_io.h>
#include <etl/singleton.h>
 
#include <array>
#include <cstdint>
 
#include "apic.h"
#include "interrupt_base.h"
#include "sk_stdio.h"
 
class Interrupt final : public InterruptBase {
 public:
  static constexpr uint8_t kExternalVectorBase = 0x20;
 
  auto Do(uint64_t cause, cpu_io::TrapContext* context) -> void override;
 
  auto RegisterInterruptFunc(uint64_t cause, InterruptDelegate func)
      -> void override;
 
  [[nodiscard]] auto SendIpi(uint64_t target_cpu_mask)
      -> Expected<void> override;
 
  [[nodiscard]] auto BroadcastIpi() -> Expected<void> override;
 
  [[nodiscard]] auto RegisterExternalInterrupt(uint32_t irq, uint32_t cpu_id,
                                               uint32_t priority,
                                               InterruptDelegate handler)
      -> Expected<void> override;
 
  [[nodiscard]] __always_inline auto apic() -> Apic& { return apic_; }
  [[nodiscard]] __always_inline auto apic() const -> const Apic& {
    return apic_;
  }
 
  auto InitApic(size_t cpu_count) -> void;
 
  auto SetUpIdtr() -> void;
 
  Interrupt();
  Interrupt(const Interrupt&) = delete;
  Interrupt(Interrupt&&) = delete;
  auto operator=(const Interrupt&) -> Interrupt& = delete;
  auto operator=(Interrupt&&) -> Interrupt& = delete;
  ~Interrupt() override = default;
 
 private:
  alignas(4096)
      std::array<InterruptDelegate,
                 cpu_io::IdtrInfo::kInterruptMaxCount> interrupt_handlers_{};
 
  alignas(4096) std::array<cpu_io::IdtrInfo::Idt,
                           cpu_io::IdtrInfo::kInterruptMaxCount> idts_{};
 
  Apic apic_{};
 
  template <uint8_t no = 0>
  auto SetUpIdtr() -> void;
};
 
using InterruptSingleton = etl::singleton<Interrupt>;