interrupt.h

Go to the documentation of this file.

 
#pragma once
 
#include <cpu_io.h>
#include <etl/singleton.h>
 
#include <array>
#include <cstdint>
 
#include "interrupt_base.h"
#include "plic.h"
#include "sk_stdio.h"
 
class Interrupt final : public InterruptBase {
 public:
  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 plic() -> Plic& { return plic_; }
  [[nodiscard]] __always_inline auto plic() const -> const Plic& {
    return plic_;
  }
 
  auto InitPlic(uint64_t dev_addr, size_t ndev, size_t context_count) -> void;
 
  Interrupt();
  Interrupt(const Interrupt&) = delete;
  Interrupt(Interrupt&&) = delete;
  auto operator=(const Interrupt&) -> Interrupt& = delete;
  auto operator=(Interrupt&&) -> Interrupt& = delete;
  ~Interrupt() = default;
 
 private:
  std::array<InterruptDelegate, cpu_io::ScauseInfo::kInterruptMaxCount>
      interrupt_handlers_{};
  std::array<InterruptDelegate, cpu_io::ScauseInfo::kExceptionMaxCount>
      exception_handlers_{};
  Plic plic_{};
};
 
using InterruptSingleton = etl::singleton<Interrupt>;