#include #include #include #include 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(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 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(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&& 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::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; } }