373 lines
14 KiB
C++
373 lines
14 KiB
C++
|
#include <Kernel/ACPI/ACPIStaticParser.h>
|
||
|
|
#include <Kernel/IO.h>
|
||
|
|
#include <Kernel/StdLib.h>
|
||
|
|
#include <Kernel/VM/MemoryManager.h>
|
||
|
|
|
||
|
|
void ACPIStaticParser::initialize(ACPI_RAW::RSDPDescriptor20& rsdp)
|
||
|
|
{
|
||
|
|
if (!ACPIParser::is_initialized()) {
|
||
|
|
new ACPIStaticParser(rsdp);
|
||
|
|
}
|
||
|
|
}
|
||
|
|
void ACPIStaticParser::initialize_without_rsdp()
|
||
|
|
{
|
||
|
|
if (!ACPIParser::is_initialized()) {
|
||
|
|
new ACPIStaticParser();
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
bool ACPIStaticParser::is_initialized()
|
||
|
|
{
|
||
|
|
return ACPIParser::is_initialized();
|
||
|
|
}
|
||
|
|
|
||
|
|
void ACPIStaticParser::locate_static_data()
|
||
|
|
{
|
||
|
|
locate_main_system_description_table();
|
||
|
|
initialize_main_system_description_table();
|
||
|
|
init_fadt();
|
||
|
|
locate_all_aml_tables();
|
||
|
|
}
|
||
|
|
|
||
|
|
ACPI_RAW::SDTHeader* ACPIStaticParser::find_table(const char* sig)
|
||
|
|
{
|
||
|
|
#ifdef ACPI_DEBUG
|
||
|
|
dbgprintf("ACPI: Calling Find Table method!\n");
|
||
|
|
#endif
|
||
|
|
for (auto* physical_sdt_ptr : m_main_sdt->get_sdt_pointers()) {
|
||
|
|
auto region = MM.allocate_kernel_region((PAGE_SIZE * 2), "ACPI Static Parser Tables Finding", Region::Access::Read);
|
||
|
|
mmap_region(*region, PhysicalAddress((u32)physical_sdt_ptr));
|
||
|
|
ACPI_RAW::SDTHeader* sdt = (ACPI_RAW::SDTHeader*)(region->vaddr().get() + ((u32)physical_sdt_ptr & (~PAGE_MASK)));
|
||
|
|
#ifdef ACPI_DEBUG
|
||
|
|
dbgprintf("ACPI: Examining Table @ P 0x%x\n", physical_sdt_ptr);
|
||
|
|
#endif
|
||
|
|
if (!strncmp(sdt->sig, sig, 4)) {
|
||
|
|
#ifdef ACPI_DEBUG
|
||
|
|
dbgprintf("ACPI: Found Table @ P 0x%x\n", physical_sdt_ptr);
|
||
|
|
#endif
|
||
|
|
return physical_sdt_ptr;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
return nullptr;
|
||
|
|
}
|
||
|
|
|
||
|
|
ACPI_RAW::SDTHeader& ACPIStaticParser::find_fadt()
|
||
|
|
{
|
||
|
|
kprintf("ACPI: Searching for the Fixed ACPI Data Table\n");
|
||
|
|
for (auto* physical_sdt_ptr : m_main_sdt->get_sdt_pointers()) {
|
||
|
|
auto region = MM.allocate_kernel_region((PAGE_SIZE * 2), "ACPI Static Parser AML Tables Finding", Region::Access::Read);
|
||
|
|
mmap_region(*region, PhysicalAddress((u32)physical_sdt_ptr & PAGE_MASK));
|
||
|
|
ACPI_RAW::SDTHeader* sdt = (ACPI_RAW::SDTHeader*)(region->vaddr().get() + ((u32)physical_sdt_ptr & (~PAGE_MASK)));
|
||
|
|
#ifdef ACPI_DEBUG
|
||
|
|
dbgprintf("ACPI: Examining Table @ P 0x%x\n", physical_sdt_ptr);
|
||
|
|
#endif
|
||
|
|
if (!strncmp(sdt->sig, "FACP", 4)) {
|
||
|
|
kprintf("ACPI: Found FADT Table @ P 0x%x, registering\n", physical_sdt_ptr);
|
||
|
|
return *physical_sdt_ptr;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
ASSERT_NOT_REACHED(); // If we reached this point, there's something very incorrect with the system!
|
||
|
|
}
|
||
|
|
|
||
|
|
void ACPIStaticParser::init_fadt()
|
||
|
|
{
|
||
|
|
kprintf("ACPI: Initializing Fixed ACPI data\n");
|
||
|
|
ACPI_RAW::SDTHeader& physical_fadt = find_fadt();
|
||
|
|
|
||
|
|
auto checkup_region = MM.allocate_kernel_region((PAGE_SIZE * 2), "ACPI Static Parser", Region::Access::Read);
|
||
|
|
#ifdef ACPI_DEBUG
|
||
|
|
dbgprintf("ACPI: Checking FADT Length to choose the correct mapping size\n");
|
||
|
|
#endif
|
||
|
|
mmap_region(*checkup_region, PhysicalAddress((u32)(&physical_fadt) & PAGE_MASK));
|
||
|
|
|
||
|
|
ACPI_RAW::SDTHeader* sdt = (ACPI_RAW::SDTHeader*)(checkup_region->vaddr().get() + ((u32)(&physical_fadt) & (~PAGE_MASK)));
|
||
|
|
#ifdef ACPI_DEBUG
|
||
|
|
dbgprintf("ACPI: FADT @ V 0x%x, P 0x%x\n", sdt, &physical_fadt);
|
||
|
|
#endif
|
||
|
|
u32 length = sdt->length;
|
||
|
|
kprintf("ACPI: Fixed ACPI data, Revision %u\n", sdt->revision);
|
||
|
|
|
||
|
|
auto fadt_region = MM.allocate_kernel_region(PAGE_ROUND_UP(length) + PAGE_SIZE, "ACPI Static Parser", Region::Access::Read);
|
||
|
|
mmap_region(*fadt_region, PhysicalAddress((u32)(&physical_fadt) & PAGE_MASK));
|
||
|
|
m_fadt = OwnPtr<ACPI::FixedACPIData>(new ACPI::FixedACPIData(*((ACPI_RAW::FADT*)(fadt_region->vaddr().get() + ((u32)(&physical_fadt) & (~PAGE_MASK))))));
|
||
|
|
#ifdef ACPI_DEBUG
|
||
|
|
dbgprintf("ACPI: Finished to initialize Fixed ACPI data\n");
|
||
|
|
#endif
|
||
|
|
}
|
||
|
|
|
||
|
|
void ACPIStaticParser::do_acpi_reboot()
|
||
|
|
{
|
||
|
|
// FIXME: Determine if we need to do MMIO/PCI/IO access to reboot, according to ACPI spec 6.2, Section 4.8.3.6
|
||
|
|
#ifdef ACPI_DEBUG
|
||
|
|
dbgprintf("ACPI: Rebooting, Probing FADT (P @ 0x%x)\n", m_fadt.ptr());
|
||
|
|
#endif
|
||
|
|
if (m_fadt->m_revision >= 2) {
|
||
|
|
kprintf("ACPI: Reboot, Sending value 0%x to Port 0x%x\n", m_fadt->m_reset_value, m_fadt->m_reset_reg.address);
|
||
|
|
IO::out8(m_fadt->m_reset_reg.address, m_fadt->m_reset_value);
|
||
|
|
} else {
|
||
|
|
kprintf("ACPI: Reboot, Not supported!\n");
|
||
|
|
}
|
||
|
|
|
||
|
|
ASSERT_NOT_REACHED(); /// If rebooting didn't work, halt.
|
||
|
|
}
|
||
|
|
|
||
|
|
void ACPIStaticParser::do_acpi_shutdown()
|
||
|
|
{
|
||
|
|
kprintf("ACPI: Shutdown is not supported with the current configuration, Abort!\n");
|
||
|
|
ASSERT_NOT_REACHED();
|
||
|
|
}
|
||
|
|
|
||
|
|
void ACPIStaticParser::initialize_main_system_description_table()
|
||
|
|
{
|
||
|
|
auto checkup_region = MM.allocate_kernel_region((PAGE_SIZE * 2), "ACPI Static Parser Copying Method", Region::Access::Read);
|
||
|
|
#ifdef ACPI_DEBUG
|
||
|
|
dbgprintf("ACPI: Checking Main SDT Length to choose the correct mapping size");
|
||
|
|
#endif
|
||
|
|
mmap_region(*checkup_region, PhysicalAddress((u32)m_main_system_description_table & PAGE_MASK));
|
||
|
|
|
||
|
|
auto* sdt = (ACPI_RAW::SDTHeader*)(checkup_region->vaddr().get() + ((u32)m_main_system_description_table & (~PAGE_MASK)));
|
||
|
|
u32 length = sdt->length;
|
||
|
|
u8 revision = sdt->revision;
|
||
|
|
|
||
|
|
auto main_sdt_region = MM.allocate_kernel_region(PAGE_ROUND_UP(length) + PAGE_SIZE, "ACPI Static Parser Copying Method", Region::Access::Read);
|
||
|
|
mmap_region(*main_sdt_region, PhysicalAddress((u32)m_main_system_description_table & PAGE_MASK));
|
||
|
|
|
||
|
|
Vector<ACPI_RAW::SDTHeader*> sdt_pointers;
|
||
|
|
if (m_xsdt_supported) {
|
||
|
|
ACPI_RAW::XSDT* xsdt = (ACPI_RAW::XSDT*)(main_sdt_region->vaddr().get() + ((u32)m_main_system_description_table & (~PAGE_MASK)));
|
||
|
|
kprintf("ACPI: Using XSDT, Enumerating tables @ P 0x%x\n", m_main_system_description_table);
|
||
|
|
kprintf("ACPI: XSDT Revision %d, Total length - %u\n", revision, length);
|
||
|
|
for (u32 i = 0; i < ((xsdt->h.length - sizeof(ACPI_RAW::SDTHeader)) / sizeof(u64)); i++) {
|
||
|
|
#ifdef ACPI_DEBUG
|
||
|
|
dbgprintf("ACPI: Found new table, @ P 0x%x\n", xsdt->table_ptrs[i]);
|
||
|
|
#endif
|
||
|
|
sdt_pointers.append((ACPI_RAW::SDTHeader*)xsdt->table_ptrs[i]);
|
||
|
|
}
|
||
|
|
} else {
|
||
|
|
ACPI_RAW::RSDT* rsdt = (ACPI_RAW::RSDT*)(main_sdt_region->vaddr().get() + ((u32)m_main_system_description_table & (~PAGE_MASK)));
|
||
|
|
kprintf("ACPI: Using RSDT, Enumerating tables @ P 0x%x\n", m_main_system_description_table);
|
||
|
|
kprintf("ACPI: RSDT Revision %d, Total length - %u\n", revision, length);
|
||
|
|
for (u32 i = 0; i < ((rsdt->h.length - sizeof(ACPI_RAW::SDTHeader)) / sizeof(u32)); i++) {
|
||
|
|
#ifdef ACPI_DEBUG
|
||
|
|
dbgprintf("ACPI: Found new table, @ P 0x%x\n", rsdt->table_ptrs[i]);
|
||
|
|
#endif
|
||
|
|
sdt_pointers.append((ACPI_RAW::SDTHeader*)rsdt->table_ptrs[i]);
|
||
|
|
}
|
||
|
|
}
|
||
|
|
m_main_sdt = OwnPtr<ACPI::MainSystemDescriptionTable>(new ACPI::MainSystemDescriptionTable(move(sdt_pointers)));
|
||
|
|
}
|
||
|
|
|
||
|
|
void ACPIStaticParser::locate_main_system_description_table()
|
||
|
|
{
|
||
|
|
if (m_rsdp->base.revision == 0) {
|
||
|
|
m_xsdt_supported = false;
|
||
|
|
} else if (m_rsdp->base.revision >= 2) {
|
||
|
|
if (m_rsdp->xsdt_ptr != (u64) nullptr) {
|
||
|
|
m_xsdt_supported = true;
|
||
|
|
} else {
|
||
|
|
m_xsdt_supported = false;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
if (!m_xsdt_supported) {
|
||
|
|
m_main_system_description_table = (ACPI_RAW::SDTHeader*)m_rsdp->base.rsdt_ptr;
|
||
|
|
} else {
|
||
|
|
m_main_system_description_table = (ACPI_RAW::SDTHeader*)m_rsdp->xsdt_ptr;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
void ACPIStaticParser::locate_all_aml_tables()
|
||
|
|
{
|
||
|
|
// Note: According to the ACPI spec, DSDT pointer may be found in the FADT table.
|
||
|
|
// All other continuation of the DSDT can be found as pointers in the RSDT/XSDT.
|
||
|
|
|
||
|
|
kprintf("ACPI: Searching for AML Tables\n");
|
||
|
|
m_aml_tables_ptrs.append(m_fadt->get_dsdt());
|
||
|
|
for (auto* sdt_ptr : m_main_sdt->get_sdt_pointers()) {
|
||
|
|
auto region = MM.allocate_kernel_region((PAGE_SIZE * 2), "ACPI Static Parser AML Tables Finding", Region::Access::Read);
|
||
|
|
mmap_region(*region, PhysicalAddress((u32)sdt_ptr));
|
||
|
|
auto* sdt = (ACPI_RAW::SDTHeader*)(region->vaddr().get() + ((u32)sdt_ptr & (~PAGE_MASK)));
|
||
|
|
#ifdef ACPI_DEBUG
|
||
|
|
dbgprintf("ACPI: Examining Table @ P 0x%x\n", sdt_ptr);
|
||
|
|
#endif
|
||
|
|
if (!strncmp(sdt->sig, "SSDT", 4)) {
|
||
|
|
kprintf("ACPI: Found AML Table @ P 0x%x, registering\n", sdt_ptr);
|
||
|
|
m_aml_tables_ptrs.append(sdt);
|
||
|
|
}
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
ACPIStaticParser::ACPIStaticParser()
|
||
|
|
: ACPIParser(true)
|
||
|
|
, m_rsdp(nullptr)
|
||
|
|
, m_main_sdt(nullptr)
|
||
|
|
, m_fadt(nullptr)
|
||
|
|
{
|
||
|
|
m_rsdp = search_rsdp();
|
||
|
|
if (m_rsdp != nullptr) {
|
||
|
|
kprintf("ACPI: Using RSDP @ P 0x%x\n", m_rsdp);
|
||
|
|
m_operable = true;
|
||
|
|
locate_static_data();
|
||
|
|
} else {
|
||
|
|
m_operable = false;
|
||
|
|
kprintf("ACPI: Disabled, due to RSDP being absent\n");
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
ACPI_RAW::RSDPDescriptor20* ACPIStaticParser::search_rsdp()
|
||
|
|
{
|
||
|
|
auto region = MM.allocate_kernel_region(PAGE_SIZE, "ACPI Static Parser RSDP Finding", Region::Access::Read);
|
||
|
|
mmap_region(*region, PhysicalAddress(0));
|
||
|
|
u16 ebda_seg = (u16) * ((uint16_t*)((region->vaddr().get() & PAGE_MASK) + 0x40e));
|
||
|
|
kprintf("ACPI: Probing EBDA, Segment 0x%x\n", ebda_seg);
|
||
|
|
|
||
|
|
// FIXME: Ensure that we always have identity mapping (identity paging) here! Don't rely on existing mapping...
|
||
|
|
for (char* rsdp_str = (char*)(PhysicalAddress(ebda_seg << 4).as_ptr()); rsdp_str < (char*)((ebda_seg << 4) + 1024); rsdp_str += 16) {
|
||
|
|
#ifdef ACPI_DEBUG
|
||
|
|
dbgprintf("ACPI: Looking for RSDP in EBDA @ Px%x\n", rsdp_str);
|
||
|
|
#endif
|
||
|
|
if (!strncmp("RSD PTR ", rsdp_str, strlen("RSD PTR ")))
|
||
|
|
return (ACPI_RAW::RSDPDescriptor20*)rsdp_str;
|
||
|
|
}
|
||
|
|
|
||
|
|
// FIXME: Ensure that we always have identity mapping (identity paging) here! Don't rely on existing mapping...
|
||
|
|
for (char* rsdp_str = (char*)(PhysicalAddress(0xE0000).as_ptr()); rsdp_str < (char*)0xFFFFF; rsdp_str += 16) {
|
||
|
|
#ifdef ACPI_DEBUG
|
||
|
|
dbgprintf("ACPI: Looking for RSDP in EBDA @ Px%x\n", rsdp_str);
|
||
|
|
#endif
|
||
|
|
if (!strncmp("RSD PTR ", rsdp_str, strlen("RSD PTR ")))
|
||
|
|
return (ACPI_RAW::RSDPDescriptor20*)rsdp_str;
|
||
|
|
}
|
||
|
|
return nullptr;
|
||
|
|
}
|
||
|
|
|
||
|
|
void ACPIStaticParser::mmap(VirtualAddress vaddr, PhysicalAddress paddr, u32 length)
|
||
|
|
{
|
||
|
|
unsigned i = 0;
|
||
|
|
while (length >= PAGE_SIZE) {
|
||
|
|
MM.map_for_kernel(VirtualAddress(vaddr.offset(i * PAGE_SIZE).get()), PhysicalAddress(paddr.offset(i * PAGE_SIZE).get()));
|
||
|
|
#ifdef ACPI_DEBUG
|
||
|
|
dbgprintf("ACPI: map - V 0x%x -> P 0x%x\n", vaddr.offset(i * PAGE_SIZE).get(), paddr.offset(i * PAGE_SIZE).get());
|
||
|
|
#endif
|
||
|
|
length -= PAGE_SIZE;
|
||
|
|
i++;
|
||
|
|
}
|
||
|
|
if (length > 0) {
|
||
|
|
MM.map_for_kernel(vaddr.offset(i * PAGE_SIZE), paddr.offset(i * PAGE_SIZE), true);
|
||
|
|
}
|
||
|
|
#ifdef ACPI_DEBUG
|
||
|
|
dbgprintf("ACPI: Finished mapping\n");
|
||
|
|
#endif
|
||
|
|
}
|
||
|
|
|
||
|
|
void ACPIStaticParser::mmap_region(Region& region, PhysicalAddress paddr)
|
||
|
|
{
|
||
|
|
#ifdef ACPI_DEBUG
|
||
|
|
dbgprintf("ACPI: Mapping region, size - %u\n", region.size());
|
||
|
|
#endif
|
||
|
|
mmap(region.vaddr(), paddr, region.size());
|
||
|
|
}
|
||
|
|
|
||
|
|
ACPIStaticParser::ACPIStaticParser(ACPI_RAW::RSDPDescriptor20& rsdp)
|
||
|
|
: ACPIParser(true)
|
||
|
|
, m_rsdp(&rsdp)
|
||
|
|
, m_main_sdt(nullptr)
|
||
|
|
, m_fadt(nullptr)
|
||
|
|
{
|
||
|
|
kprintf("ACPI: Using RSDP @ Px%x\n", &rsdp);
|
||
|
|
m_operable = true;
|
||
|
|
locate_static_data();
|
||
|
|
}
|
||
|
|
|
||
|
|
ACPI::MainSystemDescriptionTable::MainSystemDescriptionTable(Vector<ACPI_RAW::SDTHeader*>&& sdt_pointers)
|
||
|
|
{
|
||
|
|
for (auto* sdt_ptr : sdt_pointers) {
|
||
|
|
#ifdef ACPI_DEBUG
|
||
|
|
dbgprintf("ACPI: Register new table in Main SDT, @ P 0x%x\n", sdt_ptr);
|
||
|
|
#endif
|
||
|
|
m_sdt_pointers.append(sdt_ptr);
|
||
|
|
}
|
||
|
|
}
|
||
|
|
Vector<ACPI_RAW::SDTHeader*>& ACPI::MainSystemDescriptionTable::get_sdt_pointers()
|
||
|
|
{
|
||
|
|
return m_sdt_pointers;
|
||
|
|
}
|
||
|
|
|
||
|
|
ACPI::FixedACPIData::FixedACPIData(ACPI_RAW::FADT& fadt)
|
||
|
|
{
|
||
|
|
m_dsdt_ptr = fadt.dsdt_ptr;
|
||
|
|
#ifdef ACPI_DEBUG
|
||
|
|
dbgprintf("ACPI: DSDT pointer @ P 0x%x\n", m_dsdt_ptr);
|
||
|
|
#endif
|
||
|
|
m_revision = fadt.h.revision;
|
||
|
|
m_x_dsdt_ptr = fadt.x_dsdt;
|
||
|
|
m_preferred_pm_profile = fadt.preferred_pm_profile;
|
||
|
|
m_sci_int = fadt.sci_int;
|
||
|
|
m_smi_cmd = fadt.smi_cmd;
|
||
|
|
m_acpi_enable_value = fadt.acpi_enable_value;
|
||
|
|
m_acpi_disable_value = fadt.acpi_disable_value;
|
||
|
|
m_s4bios_req = fadt.s4bios_req;
|
||
|
|
m_pstate_cnt = fadt.pstate_cnt;
|
||
|
|
|
||
|
|
m_PM1a_EVT_BLK = fadt.PM1a_EVT_BLK;
|
||
|
|
m_PM1b_EVT_BLK = fadt.PM1b_EVT_BLK;
|
||
|
|
m_PM1a_CNT_BLK = fadt.PM1a_CNT_BLK;
|
||
|
|
m_PM1b_CNT_BLK = fadt.PM1b_CNT_BLK;
|
||
|
|
m_PM2_CNT_BLK = fadt.PM2_CNT_BLK;
|
||
|
|
m_PM_TMR_BLK = fadt.PM_TMR_BLK;
|
||
|
|
m_GPE0_BLK = fadt.GPE0_BLK;
|
||
|
|
m_GPE1_BLK = fadt.GPE1_BLK;
|
||
|
|
m_PM1_EVT_LEN = fadt.PM1_EVT_LEN;
|
||
|
|
m_PM1_CNT_LEN = fadt.PM1_CNT_LEN;
|
||
|
|
m_PM2_CNT_LEN = fadt.PM2_CNT_LEN;
|
||
|
|
m_PM_TMR_LEN = fadt.PM_TMR_LEN;
|
||
|
|
m_GPE0_BLK_LEN = fadt.GPE0_BLK_LEN;
|
||
|
|
m_GPE1_BLK_LEN = fadt.GPE1_BLK_LEN;
|
||
|
|
m_GPE1_BASE = fadt.GPE1_BASE;
|
||
|
|
m_cst_cnt = fadt.cst_cnt;
|
||
|
|
m_P_LVL2_LAT = fadt.P_LVL2_LAT;
|
||
|
|
m_P_LVL3_LAT = fadt.P_LVL3_LAT;
|
||
|
|
m_flush_size = fadt.flush_size;
|
||
|
|
|
||
|
|
m_flush_stride = fadt.flush_stride;
|
||
|
|
m_duty_offset = fadt.duty_offset;
|
||
|
|
m_duty_width = fadt.duty_width;
|
||
|
|
m_day_alrm = fadt.day_alrm;
|
||
|
|
m_mon_alrm = fadt.mon_alrm;
|
||
|
|
m_century = fadt.century;
|
||
|
|
|
||
|
|
m_ia_pc_boot_arch_flags = fadt.ia_pc_boot_arch_flags;
|
||
|
|
m_flags = fadt.flags;
|
||
|
|
|
||
|
|
m_reset_reg = fadt.reset_reg;
|
||
|
|
#ifdef ACPI_DEBUG
|
||
|
|
dbgprintf("ACPI: Reset Register @ IO 0x%x\n", m_reset_reg.address);
|
||
|
|
dbgprintf("ACPI: Reset Register Address space %x\n", fadt.reset_reg.address_space);
|
||
|
|
#endif
|
||
|
|
m_reset_value = fadt.reset_value;
|
||
|
|
#ifdef ACPI_DEBUG
|
||
|
|
dbgprintf("ACPI: Reset Register value @ P 0x%x\n", m_reset_value);
|
||
|
|
#endif
|
||
|
|
m_x_pm1a_evt_blk = fadt.x_pm1a_evt_blk;
|
||
|
|
m_x_pm1b_evt_blk = fadt.x_pm1b_evt_blk;
|
||
|
|
m_x_pm1a_cnt_blk = fadt.x_pm1a_cnt_blk;
|
||
|
|
m_x_pm1b_cnt_blk = fadt.x_pm1b_cnt_blk;
|
||
|
|
m_x_pm2_cnt_blk = fadt.x_pm2_cnt_blk;
|
||
|
|
m_x_pm_tmr_blk = fadt.x_pm_tmr_blk;
|
||
|
|
m_x_gpe0_blk = fadt.x_gpe0_blk;
|
||
|
|
m_x_gpe1_blk = fadt.x_gpe1_blk;
|
||
|
|
m_sleep_control = fadt.sleep_control;
|
||
|
|
m_sleep_status = fadt.sleep_status;
|
||
|
|
|
||
|
|
m_hypervisor_vendor_identity = fadt.hypervisor_vendor_identity;
|
||
|
|
}
|
||
|
|
|
||
|
|
ACPI_RAW::SDTHeader* ACPI::FixedACPIData::get_dsdt()
|
||
|
|
{
|
||
|
|
if (m_x_dsdt_ptr != (u32) nullptr)
|
||
|
|
return (ACPI_RAW::SDTHeader*)m_x_dsdt_ptr;
|
||
|
|
else {
|
||
|
|
ASSERT((ACPI_RAW::SDTHeader*)m_dsdt_ptr != nullptr);
|
||
|
|
return (ACPI_RAW::SDTHeader*)m_dsdt_ptr;
|
||
|
|
}
|
||
|
|
}
|