mach_pc/Acpi.cc

/*
 * Copyright (c) 2008-2014, Pedigree Developers
 *
 * Please see the CONTRIB file in the root of the source tree for a full
 * list of contributors.
 *
 * Permission to use, copy, modify, and distribute this software for any
 * purpose with or without fee is hereby granted, provided that the above
 * copyright notice and this permission notice appear in all copies.
 *
 * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
 * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
 * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
 * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
 * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
 * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
 * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
 */
 
#include <config.h>
 
#if ACPI
 
#include "pedigree/kernel/BootstrapInfo.h"
#include "pedigree/kernel/Log.h"
#include "pedigree/kernel/machine/Device.h"
#include "pedigree/kernel/processor/PhysicalMemoryManager.h"
#include "pedigree/kernel/processor/VirtualAddressSpace.h"
#include "pedigree/kernel/utilities/RangeList.h"
#include "pedigree/kernel/utilities/utility.h"
 
#include "../../core/processor/x86_common/PhysicalMemoryManager.h"
#include "Acpi.h"
 
Acpi Acpi::m_Instance;
 
namespace {
bool rangeContains(uint64_t rangeAddress, uint64_t rangeLength, uint64_t address, uint64_t length) {
  const uint64_t rangeEnd = rangeAddress + rangeLength;
  const uint64_t end = address + length;
  return rangeEnd >= rangeAddress && end >= address && address >= rangeAddress && end <= rangeEnd;
}
 
bool mappedRangeContains(const MemoryRegion& region, uint64_t address, uint64_t length) {
  return rangeContains(region.physicalAddress(), region.size(), address, length);
}
}  // namespace
 
void Acpi::initialise() {
  // Search for the ACPI root system description pointer
  if (find() == false) {
    WARNING("Acpi: not compliant to the ACPI Specification");
    return;
  }
 
  NOTICE("ACPI Specification");
  NOTICE(" RSDT pointer at " << Hex << reinterpret_cast<uintptr_t>(m_pRsdtPointer));
 
  // XSDT present?
  if (m_pRsdtPointer->revision >= 2) {
    if (m_pRsdtPointer->xsdtAddress != 0) {
      NOTICE(" XSDT at " << Hex << m_pRsdtPointer->xsdtAddress);
    }
  }
 
  NOTICE(" RSDT at " << Hex << m_pRsdtPointer->rsdtAddress);
 
  // Get the ACPI memory ranges
  X86CommonPhysicalMemoryManager& physicalMemoryManager =
      X86CommonPhysicalMemoryManager::instance();
  const RangeList<uint64_t>& AcpiRanges = physicalMemoryManager.getAcpiRanges();
  RangeList<uint64_t>::Range AcpiRange(0, 0);
  bool foundAcpiRange = false;
  for (size_t i = 0; i < AcpiRanges.size(); ++i) {
    RangeList<uint64_t>::Range candidate(0, 0);
    if (AcpiRanges.getRange(i, candidate) &&
        rangeContains(candidate.address, candidate.length, m_pRsdtPointer->rsdtAddress,
                      sizeof(SystemDescriptionTableHeader))) {
      AcpiRange = candidate;
      foundAcpiRange = true;
      break;
    }
  }
 
  // Firmware may mark ACPI tables reserved instead of reclaimable.
  if (!foundAcpiRange && g_pBootstrapInfo) {
    void* memoryMap = g_pBootstrapInfo->getMemoryMap();
    while (memoryMap) {
      const uint64_t address = g_pBootstrapInfo->getMemoryMapEntryAddress(memoryMap);
      const uint64_t length = g_pBootstrapInfo->getMemoryMapEntryLength(memoryMap);
      if (rangeContains(address, length, m_pRsdtPointer->rsdtAddress,
                        sizeof(SystemDescriptionTableHeader))) {
        AcpiRange.address = address;
        AcpiRange.length = length;
        foundAcpiRange = true;
        NOTICE(" ACPI tables are in firmware memory-map type "
               << Hex << g_pBootstrapInfo->getMemoryMapEntryType(memoryMap));
        break;
      }
      memoryMap = g_pBootstrapInfo->nextMemoryMapEntry(memoryMap);
    }
  }
 
  if (!foundAcpiRange) {
    ERROR("Acpi: Could not locate the RSDT in the firmware memory map");
    return;
  }
 
  // Allocate the ACPI memory as a MemoryRegion
  physical_uintptr_t address = AcpiRange.address & (~(PhysicalMemoryManager::getPageSize() - 1));
  size_t sAddress = AcpiRange.length + (AcpiRange.address - address);
  size_t nPages = (sAddress + (PhysicalMemoryManager::getPageSize() - 1)) /
                  PhysicalMemoryManager::getPageSize();
  if (physicalMemoryManager.allocateRegion(
          m_AcpiMemoryRegion, nPages,
          PhysicalMemoryManager::continuous | PhysicalMemoryManager::nonRamMemory |
              PhysicalMemoryManager::force,
          VirtualAddressSpace::KernelMode | VirtualAddressSpace::Write, address) == false) {
    ERROR("Acpi: Could not allocate the MemoryRegion");
    return;
  }
 
  // Check the RSDT (Root System Description Table)
  m_pRsdt = m_AcpiMemoryRegion.convertPhysicalPointer<SystemDescriptionTableHeader>(
      m_pRsdtPointer->rsdtAddress);
  if (m_pRsdt->signature != 0x54445352 || m_pRsdt->length < sizeof(SystemDescriptionTableHeader) ||
      !mappedRangeContains(m_AcpiMemoryRegion, m_pRsdtPointer->rsdtAddress, m_pRsdt->length) ||
      checksum(m_pRsdt) != true) {
    ERROR("Acpi: RSDT invalid");
    m_pRsdt = 0;
    return;
  }
 
  // Go through the table's entries
  size_t sEntries = (m_pRsdt->length - sizeof(SystemDescriptionTableHeader)) / 4;
  for (size_t i = 0; i < sEntries; i++) {
    uint32_t* pTable = adjust_pointer(reinterpret_cast<uint32_t*>(m_pRsdt),
                                      sizeof(SystemDescriptionTableHeader) + 4 * i);
 
    SystemDescriptionTableHeader* pSystemDescTable =
        m_AcpiMemoryRegion.convertPhysicalPointer<SystemDescriptionTableHeader>(*pTable);
 
    if (!mappedRangeContains(m_AcpiMemoryRegion, *pTable, sizeof(SystemDescriptionTableHeader))) {
      ERROR("  ACPI table header is outside the mapped firmware range");
      continue;
    }
 
    if (pSystemDescTable->length < sizeof(SystemDescriptionTableHeader) ||
        !mappedRangeContains(m_AcpiMemoryRegion, *pTable, pSystemDescTable->length)) {
      ERROR("  ACPI table is outside the mapped firmware range");
      continue;
    }
 
    char Signature[5];
    StringCopyN(Signature, reinterpret_cast<char*>(&pSystemDescTable->signature), 4);
    Signature[4] = '\0';
 
    NOTICE("  " << Signature << " at " << Hex << *pTable);
 
    // Is the table valid?
    if (checksum(pSystemDescTable) != true) {
      ERROR("   invalid");
      continue;
    }
 
    // Is Fixed ACPI Description Table?
    if (pSystemDescTable->signature == 0x50434146) {
      if (pSystemDescTable->length < sizeof(FixedACPIDescriptionTable)) {
        ERROR("Acpi: truncated Fixed ACPI Description Table");
        continue;
      }
      m_pFacp = reinterpret_cast<FixedACPIDescriptionTable*>(pSystemDescTable);
    }
// Is Multiple APIC Description Table?
#if MULTIPROCESSOR
    else if (pSystemDescTable->signature == 0x43495041)
      m_pApic = pSystemDescTable;
#endif
    else if (pSystemDescTable->signature == 0x52414d44) {
      if (m_DmarSeen) {
        m_DmarPresent = false;
        ERROR("Acpi: duplicate DMAR table");
        continue;
      }
      m_DmarSeen = true;
      AcpiDmar::Info info;
      if (!AcpiDmar::parse(reinterpret_cast<const uint8_t*>(pSystemDescTable),
                           pSystemDescTable->length, info)) {
        ERROR("Acpi: invalid DMAR table");
      } else {
        m_DmarInfo = info;
        m_DmarPresent = true;
        NOTICE(" ACPI DMAR: " << Dec << info.hardwareUnitCount << " DMA remapping units ("
                              << info.segmentZeroUnitCount << " on PCI segment 0), interrupt "
                              << (info.interruptRemapping ? "remapping advertised"
                                                          : "remapping absent"));
      }
    } else if (pSystemDescTable->signature == 0x4746434d) {
      constexpr size_t entriesOffset = sizeof(SystemDescriptionTableHeader) + 8;
      if (pSystemDescTable->length < entriesOffset ||
          (pSystemDescTable->length - entriesOffset) % sizeof(PciConfigurationRange)) {
        ERROR("Acpi: invalid MCFG length");
        continue;
      }
      const size_t count =
          (pSystemDescTable->length - entriesOffset) / sizeof(PciConfigurationRange);
      for (size_t entryIndex = 0; entryIndex < count; ++entryIndex) {
        const auto* entry =
            adjust_pointer(reinterpret_cast<const PciConfigurationRange*>(pSystemDescTable),
                           entriesOffset + entryIndex * sizeof(PciConfigurationRange));
        if (entry->segment || entry->firstBus > entry->lastBus ||
            (entry->base & ((1ULL << 20) - 1))) {
          continue;
        }
        const uint64_t bytes = uint64_t(entry->lastBus + 1) << 20;
        if (!entry->base || entry->base + bytes < entry->base) {
          continue;
        }
        bool overlap = false;
        for (const auto& range : m_PciConfigurationRanges) {
          if (entry->firstBus <= range.lastBus && entry->lastBus >= range.firstBus) {
            overlap = true;
            break;
          }
        }
        if (!overlap) {
          m_PciConfigurationRanges.pushBack(*entry);
          NOTICE(" ACPI MCFG segment 0 buses " << Dec << entry->firstBus << ".." << entry->lastBus
                                               << " at " << Hex << entry->base);
        }
      }
    } else {
      NOTICE("   unknown table");
    }
  }
 
  // Do we have a Fixed ACPI Description Table?
  if (m_pFacp == 0) {
    ERROR("Acpi: no Fixed ACPI Description Table (FACP)");
    return;
  }
 
  // Parse the FACP
  parseFixedACPIDescriptionTable();
  initialisePowerManagement();
 
  if (m_pFacp->dsdt && mappedRangeContains(m_AcpiMemoryRegion, m_pFacp->dsdt,
                                           sizeof(SystemDescriptionTableHeader))) {
    const auto* dsdt =
        m_AcpiMemoryRegion.convertPhysicalPointer<SystemDescriptionTableHeader>(m_pFacp->dsdt);
    if (dsdt->signature == 0x54445344 && dsdt->length >= sizeof(SystemDescriptionTableHeader) &&
        mappedRangeContains(m_AcpiMemoryRegion, m_pFacp->dsdt, dsdt->length) && checksum(dsdt)) {
      m_PciInterruptRoutesPresent = AcpiPciRouting::parse(
          reinterpret_cast<const uint8_t*>(dsdt) + sizeof(SystemDescriptionTableHeader),
          dsdt->length - sizeof(SystemDescriptionTableHeader), m_PciInterruptRoutes);
      if (m_PciInterruptRoutesPresent) {
        NOTICE(" ACPI PCI IOAPIC routes available");
      }
    }
  }
 
#if MULTIPROCESSOR
  // If we have an Multiple APIC Description Table parse it
  if (m_pApic != 0)
    parseMultipleApicDescriptionTable();
#endif
 
  m_bValid = true;
}
 
Acpi::Acpi()
    : m_bValid(0),
      m_pRsdtPointer(0),
      m_AcpiMemoryRegion("ACPI"),
      m_pRsdt(0),
      m_pFacp(0),
      m_PciConfigurationRanges(),
      m_DmarInfo(),
      m_DmarPresent(false),
      m_DmarSeen(false)
#if MULTIPROCESSOR
      ,
      m_pApic(0),
      m_bValidApicInfo(false),
      m_bHasPICs(false),
      m_LocalApicAddress(0),
      m_IoApics(),
      m_bValidProcessorInfo(false),
      m_Processors()
#endif
{
  for (size_t irq = 0; irq < 16; ++irq) {
    m_IsaGsis[irq] = irq;
  }
}
 
bool Acpi::getPmTimerPort(uint16_t& port, uint32_t& mask) const {
  if (!m_bValid || !m_pFacp || (m_pFacp->flags & (1U << 20)) || m_pFacp->pmTimerLength != 4) {
    return false;
  }
 
  uint64_t address = m_pFacp->pmTimerBlock;
  // X_PM_TMR_BLK takes precedence when the extended FADT provides it.
  if (m_pFacp->header.length >= 220) {
    const uint8_t* gas = reinterpret_cast<const uint8_t*>(m_pFacp) + 208;
    uint64_t extendedAddress = 0;
    MemoryCopy(&extendedAddress, gas + 4, sizeof(extendedAddress));
    if (extendedAddress) {
      if (gas[0] != 1 || (gas[1] != 24 && gas[1] != 32) || gas[2] || (gas[3] != 0 && gas[3] != 3)) {
        return false;
      }
      address = extendedAddress;
    }
  }
  if (!address || address > 0xfffc) {
    return false;
  }
  port = static_cast<uint16_t>(address);
  mask = (m_pFacp->flags & (1U << 8)) ? 0xffffffffU : 0x00ffffffU;
  return true;
}
 
bool Acpi::pciConfigurationAddress(uint8_t bus, uint64_t& address) const {
  if (!m_bValid) {
    return false;
  }
  for (const auto& range : m_PciConfigurationRanges) {
    if (bus >= range.firstBus && bus <= range.lastBus) {
      address = range.base + (uint64_t(bus) << 20);
      return true;
    }
  }
  return false;
}
 
bool Acpi::pciBusRange(uint8_t& first, uint8_t& last) const {
  if (!m_bValid || !m_PciConfigurationRanges.size()) {
    return false;
  }
  first = 255;
  last = 0;
  for (const auto& range : m_PciConfigurationRanges) {
    if (range.firstBus < first) {
      first = range.firstBus;
    }
    if (range.lastBus > last) {
      last = range.lastBus;
    }
  }
  return true;
}
 
bool Acpi::pciInterruptRoute(uint8_t slot, uint8_t pin, AcpiPciRouting::Route& route) const {
  if (!m_bValid || !m_PciInterruptRoutesPresent || slot >= 32 || pin < 1 || pin > 4) {
    return false;
  }
  route = m_PciInterruptRoutes[slot][pin - 1];
  return route.gsi >= 16;
}
 
void Acpi::setPciInterruptRouter(PciInterruptRouter router) {
  __atomic_store_n(&m_PciInterruptRouter, router, __ATOMIC_RELEASE);
}
 
bool Acpi::hasPciInterruptRouter() const {
  return __atomic_load_n(&m_PciInterruptRouter, __ATOMIC_ACQUIRE) != nullptr;
}
 
bool Acpi::pciInterruptRoute(Device* device, uint8_t pin, AcpiPciRouting::Route& route) const {
  if (!device || pin < 1 || pin > 4) {
    return false;
  }
  const auto router = __atomic_load_n(&m_PciInterruptRouter, __ATOMIC_ACQUIRE);
  if (router) {
    return router(device, pin, route);
  }
  Device* current = device;
  for (size_t depth = 0; current->getPciBusPosition(); ++depth) {
    if (depth == 8) {
      return false;
    }
    Device* bus = current->getParent();
    Device* bridge = bus ? bus->getParent() : nullptr;
    if (!bridge || bridge->getPciClassCode() != 6 || bridge->getPciSubclassCode() != 4) {
      return false;
    }
    pin = static_cast<uint8_t>(((pin - 1 + current->getPciDevicePosition()) & 3) + 1);
    current = bridge;
  }
  return pciInterruptRoute(current->getPciDevicePosition(), pin, route);
}
 
bool Acpi::isaIrqsForGsi(uint32_t gsi, uint16_t& irqs) const {
  irqs = 0;
#if MULTIPROCESSOR
  if (!m_bValidApicInfo) {
    return false;
  }
#endif
  if (!m_bValid || !m_IsaRoutingValid) {
    return false;
  }
  for (uint32_t nmi : m_NmiGsis) {
    if (nmi == gsi) {
      return false;
    }
  }
  for (size_t irq = 0; irq < 16; ++irq) {
    if (m_IsaGsis[irq] == gsi) {
      irqs |= uint16_t(1U << irq);
    }
  }
  return true;
}
 
void Acpi::parseFixedACPIDescriptionTable() {
  NOTICE("ACPI: Fixed Description Table (FACP)");
 
  NOTICE(" Firmware ACPI Control Structure at " << Hex << m_pFacp->firmwareControl);
  NOTICE(" Differentiated System Description Table at " << Hex << m_pFacp->dsdt);
  NOTICE(" Interrupt Model: " << Dec
                              << ((m_pFacp->interruptModel == 0) ? "dual 8259 PICs"
                                                                 : "multiple local APICs"));
  NOTICE(" SCI Interrupt #" << Dec << m_pFacp->sciInterrupt);
  NOTICE(" SMI Command Port at " << Hex << m_pFacp->smiCommandPort);
  NOTICE("  enable " << Hex << m_pFacp->acpiEnableCommand);
  NOTICE("  disable " << Hex << m_pFacp->acpiDisableCommand);
  if (m_pFacp->s4BiosCommand != 0) {
    NOTICE("  S4 BIOS " << Hex << m_pFacp->s4BiosCommand);
  }
  NOTICE(" Power-Management");
  NOTICE("  Event 1A at " << Hex << m_pFacp->pm1aEventBlock << " - "
                          << (m_pFacp->pm1aEventBlock + m_pFacp->pm1EventLength));
  if (m_pFacp->pm1bEventBlock != 0) {
    NOTICE("  Event 1B at " << Hex << m_pFacp->pm1bEventBlock << " - "
                            << (m_pFacp->pm1bEventBlock + m_pFacp->pm1EventLength));
  }
  NOTICE("  Control 1A at " << Hex << m_pFacp->pm1aControlBlock << " - "
                            << (m_pFacp->pm1aControlBlock + m_pFacp->pm1ControlLength));
  if (m_pFacp->pm1bControlBlock != 0) {
    NOTICE("  Control 1B at " << Hex << m_pFacp->pm1bControlBlock << " - "
                              << (m_pFacp->pm1bControlBlock + m_pFacp->pm1ControlLength));
  }
  if (m_pFacp->pm2ControlBlock != 0) {
    NOTICE("  Control 2 at " << Hex << m_pFacp->pm2ControlBlock << " - "
                             << (m_pFacp->pm2ControlBlock + m_pFacp->pm2ControlLength));
  }
  NOTICE("  Timer at " << Hex << m_pFacp->pmTimerBlock << " - "
                       << (m_pFacp->pmTimerBlock + m_pFacp->pmTimerLength));
  if (m_pFacp->gpe0Block != 0) {
    NOTICE("  General Purpose Event 0 at " << Hex << m_pFacp->gpe0Block << " - "
                                           << (m_pFacp->gpe0Block + m_pFacp->gpe0BlockLength));
  }
  if (m_pFacp->gpe1Block != 0) {
    NOTICE("  General Purpose Event 1 at " << Hex << m_pFacp->gpe1Block << " - "
                                           << (m_pFacp->gpe1Block + m_pFacp->gpe1BlockLength));
  }
  if (m_pFacp->gpe1Base != 0) {
    NOTICE("  General Purpose Event Base: " << Hex << m_pFacp->gpe1Base);
  }
  // TODO: Unimportant imho
  NOTICE(" Flags " << Hex << m_pFacp->flags);
}
 
#if MULTIPROCESSOR
void Acpi::parseMultipleApicDescriptionTable() {
  NOTICE("ACPI: Multiple APIC Description Table (APIC)");
 
  if (m_pApic->length < sizeof(SystemDescriptionTableHeader) + 8) {
    ERROR("ACPI: truncated Multiple APIC Description Table");
    return;
  }
 
  // Parse the Multiple APIC Description Table
  uint32_t* pLocalApicAddress =
      reinterpret_cast<uint32_t*>(adjust_pointer(m_pApic, sizeof(SystemDescriptionTableHeader)));
  uint32_t* pFlags = adjust_pointer(pLocalApicAddress, 4);
 
  m_LocalApicAddress = *pLocalApicAddress;
  m_bHasPICs = (((*pFlags) & 0x01) == 0x01);
 
  uint8_t* pType = reinterpret_cast<uint8_t*>(adjust_pointer(pFlags, 4));
  uint8_t* const end = reinterpret_cast<uint8_t*>(adjust_pointer(m_pApic, m_pApic->length));
  for (; end - pType >= 2;) {
    const uint8_t entryLength = pType[1];
    if (entryLength < 2 || entryLength > end - pType) {
      ERROR("ACPI: invalid Multiple APIC Description Table entry");
      return;
    }
    // Processor Local APIC
    if (*pType == 0 && entryLength >= 8) {
      ProcessorLocalApic* pLocalApic =
          reinterpret_cast<ProcessorLocalApic*>(adjust_pointer(pType, 2));
      bool bUsable = ((pLocalApic->flags & 0x01) == 0x01);
      NOTICE(" Processor #" << Dec << pLocalApic->processorId
                            << (bUsable ? " usable" : " unusable"));
 
      // Is the processor usable?
      if (bUsable) {
        // Add the processor to the list
        Multiprocessor::ProcessorInformation* pProcessorInfo =
            new Multiprocessor::ProcessorInformation(pLocalApic->processorId, pLocalApic->apicId);
        m_Processors.pushBack(pProcessorInfo);
      }
    }
    // I/O APIC
    else if (*pType == 1 && entryLength >= 12) {
      IoApic* pIoApic = reinterpret_cast<IoApic*>(adjust_pointer(pType, 2));
 
      NOTICE(" I/O APIC #" << Dec << pIoApic->apicId << " at " << Hex << pIoApic->address
                           << ", global system interrupt base "
                           << pIoApic->globalSystemInterruptBase);
 
      // Add to the I/O APIC list
      Multiprocessor::IoApicInformation* pIoApicInfo = new Multiprocessor::IoApicInformation(
          pIoApic->apicId, pIoApic->address, pIoApic->globalSystemInterruptBase);
      m_IoApics.pushBack(pIoApicInfo);
    }
    // Interrupt Source override
    else if (*pType == 2 && entryLength >= 10) {
      InterruptSourceOverride* pInterruptSourceOverride =
          reinterpret_cast<InterruptSourceOverride*>(adjust_pointer(pType, 2));
 
      ERROR(" Interrupt override: " << ((pInterruptSourceOverride->bus == 0) ? "ISA" : "unknown")
                                    << " bus, #" << Dec << pInterruptSourceOverride->source
                                    << " -> #" << pInterruptSourceOverride->globalSystemInterrupt
                                    << ", flags " << Hex << pInterruptSourceOverride->flags);
 
      const auto& source = *pInterruptSourceOverride;
      if (source.bus || source.source >= 16 || (m_IsaOverrides & (1U << source.source)) ||
          (source.flags & ~0xfU) || (source.flags & 3) == 2 || ((source.flags >> 2) & 3) == 2) {
        m_IsaRoutingValid = false;
      } else {
        m_IsaGsis[source.source] = source.globalSystemInterrupt;
        m_IsaOverrides |= uint16_t(1U << source.source);
      }
    }
    // Non-maskable Interrupt Source (NMI)
    else if (*pType == 3) {
      ERROR(" NMI source");
      if (entryLength < 8) {
        m_IsaRoutingValid = false;
      } else {
        m_NmiGsis.pushBack(uint32_t(pType[4]) | (uint32_t(pType[5]) << 8) |
                           (uint32_t(pType[6]) << 16) | (uint32_t(pType[7]) << 24));
      }
    }
    // Local APIC NMI
    else if (*pType == 4) {
      ERROR(" Local APIC NMI");
    }
    // Local APIC Address Override
    else if (*pType == 5) {
      ERROR(" Local APIC address override");
    }
    // I/O SAPIC
    else if (*pType == 6) {
      ERROR(" I/O SAPIC");
    }
    // Local SAPIC
    else if (*pType == 7) {
      ERROR(" Local SAPIC");
    }
    // Platform Interrupt Source
    else if (*pType == 8) {
      ERROR(" Platform Interrupt Source");
    } else {
      NOTICE(" unknown entry #" << Dec << *pType);
    }
 
    // Go to the next entry;
    pType += entryLength;
  }
 
  m_bValidApicInfo = true;
  m_bValidProcessorInfo = true;
}
#endif
 
bool Acpi::find() {
  if (g_pBootstrapInfo && g_pBootstrapInfo->getAcpiRsdp()) {
    m_pRsdtPointer = reinterpret_cast<RsdtPointer*>(g_pBootstrapInfo->getAcpiRsdp());
    if (m_pRsdtPointer->signature == 0x2052545020445352ULL && checksum(m_pRsdtPointer)) {
      return true;
    }
  }
  m_pRsdtPointer = nullptr;
  return false;
}
 
bool Acpi::checksum(const RsdtPointer* pRdstPointer) {
  // ACPI 1.0 checksum
  if (::checksum(reinterpret_cast<const uint8_t*>(pRdstPointer), 20) == false)
    return false;
 
  if (pRdstPointer->revision >= 2) {
    // ACPI 2.0+ checksum
    if (::checksum(reinterpret_cast<const uint8_t*>(pRdstPointer), pRdstPointer->length) == false)
      return false;
  }
 
  return true;
}
 
bool Acpi::checksum(const SystemDescriptionTableHeader* pHeader) {
  return ::checksum(reinterpret_cast<const uint8_t*>(pHeader), pHeader->length);
}
 
#endif