PrOSess/kernel/include/init/apic.h

#pragma once

#include "init/acpi.h"
#include "memory/pointer.h"
#include "util/number.h"

namespace acpi {

enum class madt_entry_type : uint8_t {
  local_apic = 0,
  io_apic = 1,
  interrupt_source_override = 2,
  nmi_source = 3,
  local_apic_nmi = 4,
  local_apic_address_override = 5,
};

inline constexpr const char *get_madt_entry_type_name(madt_entry_type type) {
  switch (type) {
  case madt_entry_type::local_apic:
    return "local_apic";
  case madt_entry_type::io_apic:
    return "io_apic";
  case madt_entry_type::interrupt_source_override:
    return "interrupt_source_override";
  case madt_entry_type::nmi_source:
    return "nmi_source";
  case madt_entry_type::local_apic_nmi:
    return "local_apic_nmi";
  case madt_entry_type::local_apic_address_override:
    return "local_apic_address_override";
  }
  return "unknown";
}

struct madt_flags_t {
  uint32_t dual_8259_present : 1;
  uint32_t reserved : 31;
};
static_assert(sizeof(madt_flags_t) == 4);

struct local_apic_flags_t {
  uint32_t enabled : 1;
  uint32_t online_capable : 1;
  uint32_t reserved : 30;
};
static_assert(sizeof(local_apic_flags_t) == 4);

enum class inti_polarity : uint16_t {
  bus_default = 0,
  active_high = 1,
  active_low = 3,
};

enum class inti_trigger_mode : uint16_t {
  bus_default = 0,
  edge = 1,
  level = 3,
};

struct inti_flags_t {
  inti_polarity polarity : 2;
  inti_trigger_mode trigger_mode : 2;
  uint16_t reserved : 12;
};
static_assert(sizeof(inti_flags_t) == 2);

struct madt_t {
  sdt_header_t header;
  uint32_t local_apic_address;
  madt_flags_t flags;
  uint8_t entries[0];
} __attribute__((packed));
static_assert(sizeof(madt_t) == 44);

struct madt_entry_t {
  madt_entry_type type;
  uint8_t length;
} __attribute__((packed));
static_assert(sizeof(madt_entry_t) == 2);

struct madt_local_apic_t {
  madt_entry_type type;
  uint8_t length;
  uint8_t acpi_processor_uid;
  uint8_t apic_id;
  local_apic_flags_t flags;
} __attribute__((packed));
static_assert(sizeof(madt_local_apic_t) == 8);

struct madt_io_apic_t {
  madt_entry_type type;
  uint8_t length;
  uint8_t io_apic_id;
  uint8_t reserved;
  uint32_t io_apic_address;
  uint32_t global_system_interrupt_base;
} __attribute__((packed));
static_assert(sizeof(madt_io_apic_t) == 12);

struct madt_interrupt_source_override_t {
  madt_entry_type type;
  uint8_t length;
  uint8_t bus;    // always 0 (ISA)
  uint8_t source; // ISA IRQ number
  uint32_t global_system_interrupt;
  inti_flags_t flags;
} __attribute__((packed));
static_assert(sizeof(madt_interrupt_source_override_t) == 10);

struct madt_nmi_source_t {
  madt_entry_type type;
  uint8_t length;
  inti_flags_t flags;
  uint32_t global_system_interrupt;
} __attribute__((packed));
static_assert(sizeof(madt_nmi_source_t) == 8);

struct madt_local_apic_nmi_t {
  madt_entry_type type;
  uint8_t length;
  uint8_t acpi_processor_uid; // 0xFF: applies to all processors
  inti_flags_t flags;
  uint8_t lint; // local APIC LINT# the NMI is wired to
} __attribute__((packed));
static_assert(sizeof(madt_local_apic_nmi_t) == 6);

struct madt_local_apic_address_override_t {
  madt_entry_type type;
  uint8_t length;
  uint16_t reserved;
  uint64_t local_apic_address;
} __attribute__((packed));
static_assert(sizeof(madt_local_apic_address_override_t) == 12);

struct Madt {
  explicit Madt(paddr_t madt_physical)
      : table(madt_physical.access<madt_t>()) {}
  explicit Madt(const madt_t *madt_table) : table(madt_table) {}

  paddr_t local_apic_address() {
    uint64_t address = table->local_apic_address;
    for_each_entry(
        [&](const madt_local_apic_address_override_t *override_entry) {
          address = override_entry->local_apic_address;
        });
    return paddr_t{address};
  }

  bool has_legacy_pic() { return table->flags.dual_8259_present != 0; }

  template <typename Fn> void for_each_entry(Fn &&callback) {
    auto ptr = table->entries;
    const auto end =
        reinterpret_cast<const uint8_t *>(table) + table->header.length;
    while (ptr < end) {
      auto entry = reinterpret_cast<const madt_entry_t *>(ptr);
      if (entry->length < sizeof(madt_entry_t)) {
        break;
      }
      dispatch(entry, callback);
      ptr += entry->length;
    }
  }

private:
  template <typename Fn>
  static void dispatch(const madt_entry_t *entry, Fn &&fn) {
#define MADT_DISPATCH(entry_enum, EntryType)                                   \
  case madt_entry_type::entry_enum:                                            \
    if constexpr (requires { fn(static_cast<const EntryType *>(nullptr)); })   \
      fn(reinterpret_cast<const EntryType *>(entry));                          \
    break;

    switch (entry->type) {
      MADT_DISPATCH(local_apic, madt_local_apic_t)
      MADT_DISPATCH(io_apic, madt_io_apic_t)
      MADT_DISPATCH(interrupt_source_override, madt_interrupt_source_override_t)
      MADT_DISPATCH(nmi_source, madt_nmi_source_t)
      MADT_DISPATCH(local_apic_nmi, madt_local_apic_nmi_t)
      MADT_DISPATCH(local_apic_address_override,
                    madt_local_apic_address_override_t)
    default:
      break;
    }

#undef MADT_DISPATCH
  }

  const madt_t *table;
};

} // namespace acpi