$ unlink MikanLoaderPkg # 前に残っていたシンボリックリンクを削除
$ ln -s /mnt/30DayOS/workspace/ch06/MikanLoaderPkg/ ./
$ source edksetup.sh
$ build

extern "C" void KernelMain(const FrameBufferConfig& frame_buffer_config) {
  PixelWriter* writer = GetWriter(frame_buffer_config);

  // Base Screen
  const int kFrameWidth =
      static_cast<int>(frame_buffer_config.horizontal_resolution);
  const int kFrameHeight =
      static_cast<int>(frame_buffer_config.vertical_resolution);
  // 上の青い部分
  FillRectangle(*writer, {0, 0}, {kFrameWidth, kFrameHeight - 50},
                kDesktopBGColor);
  // 下のバー(とりあえず全体を塗りつぶす)
  FillRectangle(*writer, {0, kFrameHeight - 50}, {kFrameWidth, 50},
                kDesktopBlackColor);
  // 左下のグレーの部分(下のバーを上書き)
  FillRectangle(*writer, {0, kFrameHeight - 50}, {kFrameWidth / 5, 50},
                kDesktopDarkGrayColor);
  // 左下の四角枠(更に上書き)
  DrawRectangle(*writer, {10, kFrameHeight - 40}, {30, 30},
                kDesktopLightGrayColor);

  console = new (console_buf) Console{*writer, {0, 0, 0}, {255, 255, 255}};
  printk("Welcome to MikanOS!\n");

  // Write Mouse Cursol
  for (int y = 0; y < kMouseCursorHeight; ++y) {
    for (int x = 0; x < kMouseCursorWidth; ++x) {
      if (mouse_cursor_shape[y][x] == '@') {
        writer->Write(200 + x, 100 + y, kMouseEdgeColor);
      } else if (mouse_cursor_shape[y][x] == '.') {
        writer->Write(200 + x, 100 + y, kMouseInsideColor);
      }
    }
  }

  while (1) __asm__("hlt");
}

bits 64
section .text

global IoOut32  ; void IoOut32(uint16_t addr, uint32_t data);
IoOut32:
    mov dx, di    ; dx = addr
    mov eax, esi  ; eax = data
    out dx, eax
    ret

global IoIn32  ; uint32_t IoIn32(uint16_t addr);
IoIn32:
    mov dx, di    ; dx = addr
    in eax, dx
    ret

void WriteAddress(uint32_t address) { IoOut32(kConfigAddress, address); }

void WriteData(uint32_t value) { IoOut32(kConfigData, value); }

uint32_t ReadData() { return IoIn32(kConfigData); }

uint16_t ReadVendorId(uint8_t bus, uint8_t device, uint8_t function) {
  WriteAddress(MakeAddress(bus, device, function, 0x00));
  return ReadData() & 0xffffu;
}

uint16_t ReadDeviceId(uint8_t bus, uint8_t device, uint8_t function) {
  WriteAddress(MakeAddress(bus, device, function, 0x00));
  return ReadData() >> 16;
}

uint8_t ReadHeaderType(uint8_t bus, uint8_t device, uint8_t function) {
  WriteAddress(MakeAddress(bus, device, function, 0x0c));
  return (ReadData() >> 16) & 0xffu;
}

uint32_t ReadClassCode(uint8_t bus, uint8_t device, uint8_t function) {
  WriteAddress(MakeAddress(bus, device, function, 0x08));
  return ReadData();
}

uint32_t ReadBusNumbers(uint8_t bus, uint8_t device, uint8_t function) {
  WriteAddress(MakeAddress(bus, device, function, 0x18));
  return ReadData();
}

uint16_t ReadVendorId(uint8_t bus, uint8_t device, uint8_t function) {
  WriteAddress(MakeAddress(bus, device, function, 0x00));
  return ReadData() & 0xffffu;
}

/** @brief PCI デバイスを操作するための基礎データを格納する
 *
 * バス番号，デバイス番号，ファンクション番号はデバイスを特定するのに必須．
 * その他の情報は単に利便性のために加えてある．
 * */
struct Device {
  uint8_t bus, device, function, header_type;
};

/** @brief ScanAllBus() により発見された PCI デバイスの一覧 */
inline std::array<Device, 32> devices;
/** @brief devices の有効な要素の数 */
inline int num_device;
/** @brief PCI デバイスをすべて探索し devices に格納する
 *
 * バス 0 から再帰的に PCI デバイスを探索し，devices の先頭から詰めて書き込む．
 * 発見したデバイスの数を num_devices に設定する．
 */
Error ScanAllBus();

Error ScanAllBus() {
  num_device = 0;

  auto header_type = ReadHeaderType(0, 0, 0);
  if (IsSingleFunctionDevice(header_type)) {
    return ScanBus(0);
  }

  for (uint8_t function = 1; function < 8; ++function) {
    if (ReadVendorId(0, 0, function) == 0xffffu) {
      continue;
    }
    if (auto err = ScanBus(function)) {
      return err;
    }
  }
  return Error::kSuccess;
}

bool IsSingleFunctionDevice(uint8_t header_type) {
  return (header_type & 0x80u) == 0;
}

/** @brief 指定のバス番号の各デバイスをスキャンする．
 * 有効なデバイスを見つけたら ScanDevice を実行する．
 */
Error ScanBus(uint8_t bus) {
  for (uint8_t device = 0; device < 32; ++device) {
    if (ReadVendorId(bus, device, 0) == 0xffffu) {
      continue;
    }
    if (auto err = ScanDevice(bus, device)) {
      return err;
    }
  }
  return Error::kSuccess;
}

/** @brief 指定のデバイス番号の各ファンクションをスキャンする．
 * 有効なファンクションを見つけたら ScanFunction を実行する．
 */
Error ScanDevice(uint8_t bus, uint8_t device) {
  if (auto err = ScanFunction(bus, device, 0)) {
    return err;
  }
  if (IsSingleFunctionDevice(ReadHeaderType(bus, device, 0))) {
    return Error::kSuccess;
  }

  for (uint8_t function = 1; function < 8; ++function) {
    if (ReadVendorId(bus, device, function) == 0xffffu) {
      continue;
    }
    if (auto err = ScanFunction(bus, device, function)) {
      return err;
    }
  }
  return Error::kSuccess;
}

Error ScanFunction(uint8_t bus, uint8_t device, uint8_t function) {
  auto header_type = ReadHeaderType(bus, device, function);
  if (auto err = AddDevice(bus, device, function, header_type)) {
    return err;
  }

  auto class_code = ReadClassCode(bus, device, function);
  uint8_t base = (class_code >> 24) & 0xffu;
  uint8_t sub = (class_code >> 16) & 0xffu;

  if (base == 0x06u && sub == 0x04u) {
    // standard PCI-PCI bridge
    auto bus_numbers = ReadBusNumbers(bus, device, function);
    uint8_t secondary_bus = (bus_numbers >> 8) & 0xffu;
    return ScanBus(secondary_bus);
  }

  return Error::kSuccess;
}

/** @brief devices[num_device] に情報を書き込み num_deviceをインクリメントする．
 */
Error AddDevice(uint8_t bus, uint8_t device, uint8_t function,
                uint8_t header_type) {
  if (num_device == devices.size()) {
    return Error::kFull;
  }

  devices[num_device] = Device{bus, device, function, header_type};
  ++num_device;
  return Error::kSuccess;
}

// Intel 製を優先して xHC を探す
  pci::Device* xhc_dev = nullptr;
  for (int i = 0; i < pci::num_device; ++i) {
    if (pci::devices[i].class_code.Match(0x0cu, 0x03u, 0x30u)) {
      xhc_dev = &pci::devices[i];

      if (0x8086 == pci::ReadVendorId(*xhc_dev)) {
        break;
      }
    }
  }

  if (xhc_dev) {
    Log(kInfo, "xHC has been found: %d.%d.%d\n",
        xhc_dev->bus, xhc_dev->device, xhc_dev->function);
  }

-device nec-usb-xhci,id=xhci

  // show_devices
  auto err = pci::ScanAllBus();
  printk("ScanAllBus: %s\n", err.Name());

  for (int i = 0; i < pci::num_device; ++i) {
    const auto& dev = pci::devices[i];
    auto vendor_id = pci::ReadVendorId(dev.bus, dev.device, dev.function);
    auto class_code = pci::ReadClassCode(dev.bus, dev.device, dev.function);
    printk(
        "%d.%d.%d: vend %04x, class %08x, head %02x / base[%02x], sub[%02x], "
        "interface[%02x]\n",
        dev.bus, dev.device, dev.function, vendor_id, class_code,
        dev.header_type, class_code.base, class_code.sub, class_code.interface);
  }

  /** @brief PCI デバイスのクラスコード */
  struct ClassCode {
    uint8_t base, sub, interface;

    /** @brief ベースクラスが等しい場合に真を返す */
    bool Match(uint8_t b) { return b == base; }
    /** @brief ベースクラスとサブクラスが等しい場合に真を返す */
    bool Match(uint8_t b, uint8_t s) { return Match(b) && s == sub; }
    /** @brief ベース，サブ，インターフェースが等しい場合に真を返す */
    bool Match(uint8_t b, uint8_t s, uint8_t i) {
      return Match(b, s) && i == interface;
    }
  };

extern "C" void __cxa_pure_virtual() {
  while (1) __asm__("hlt");
}

#include <errno.h>
#include <sys/types.h>

void _exit(void) {
  while (1) __asm__("hlt");
}

caddr_t sbrk(int incr) {
  errno = ENOMEM;
  return (caddr_t)-1;
}

int getpid(void) {
  return 1;
}

int kill(int pid, int sig) {
  errno = EINVAL;
  return -1;
}