Parser.cpp 20 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452453454455456457458459460461462463464465466467468469470
  1. /*
  2. * Copyright (c) 2020-2021, Liav A. <liavalb@hotmail.co.il>
  3. * Copyright (c) 2020-2021, Andreas Kling <kling@serenityos.org>
  4. *
  5. * SPDX-License-Identifier: BSD-2-Clause
  6. */
  7. #include <AK/Format.h>
  8. #include <AK/StringView.h>
  9. #include <AK/Try.h>
  10. #include <Kernel/Arch/x86/IO.h>
  11. #include <Kernel/Arch/x86/InterruptDisabler.h>
  12. #include <Kernel/Bus/PCI/API.h>
  13. #include <Kernel/Debug.h>
  14. #include <Kernel/Firmware/ACPI/Parser.h>
  15. #include <Kernel/Firmware/BIOS.h>
  16. #include <Kernel/Memory/TypedMapping.h>
  17. #include <Kernel/Sections.h>
  18. #include <Kernel/StdLib.h>
  19. namespace Kernel::ACPI {
  20. static Parser* s_acpi_parser;
  21. Parser* Parser::the()
  22. {
  23. return s_acpi_parser;
  24. }
  25. void Parser::must_initialize(PhysicalAddress rsdp, PhysicalAddress fadt, u8 irq_number)
  26. {
  27. VERIFY(!s_acpi_parser);
  28. s_acpi_parser = new (nothrow) Parser(rsdp, fadt, irq_number);
  29. VERIFY(s_acpi_parser);
  30. }
  31. UNMAP_AFTER_INIT NonnullRefPtr<ACPISysFSComponent> ACPISysFSComponent::create(StringView name, PhysicalAddress paddr, size_t table_size)
  32. {
  33. // FIXME: Handle allocation failure gracefully
  34. auto table_name = KString::must_create(name);
  35. return adopt_ref(*new (nothrow) ACPISysFSComponent(move(table_name), paddr, table_size));
  36. }
  37. ErrorOr<size_t> ACPISysFSComponent::read_bytes(off_t offset, size_t count, UserOrKernelBuffer& buffer, OpenFileDescription*) const
  38. {
  39. auto blob = TRY(try_to_generate_buffer());
  40. if ((size_t)offset >= blob->size())
  41. return 0;
  42. ssize_t nread = min(static_cast<off_t>(blob->size() - offset), static_cast<off_t>(count));
  43. TRY(buffer.write(blob->data() + offset, nread));
  44. return nread;
  45. }
  46. ErrorOr<NonnullOwnPtr<KBuffer>> ACPISysFSComponent::try_to_generate_buffer() const
  47. {
  48. auto acpi_blob = Memory::map_typed<u8>((m_paddr), m_length);
  49. return KBuffer::try_create_with_bytes(Span<u8> { acpi_blob.ptr(), m_length });
  50. }
  51. UNMAP_AFTER_INIT ACPISysFSComponent::ACPISysFSComponent(NonnullOwnPtr<KString> table_name, PhysicalAddress paddr, size_t table_size)
  52. : SysFSComponent()
  53. , m_paddr(paddr)
  54. , m_length(table_size)
  55. , m_table_name(move(table_name))
  56. {
  57. }
  58. UNMAP_AFTER_INIT void ACPISysFSDirectory::find_tables_and_register_them_as_components()
  59. {
  60. NonnullRefPtrVector<SysFSComponent> components;
  61. size_t ssdt_count = 0;
  62. ACPI::Parser::the()->enumerate_static_tables([&](StringView signature, PhysicalAddress p_table, size_t length) {
  63. if (signature == "SSDT") {
  64. components.append(ACPISysFSComponent::create(String::formatted("{:4s}{}", signature.characters_without_null_termination(), ssdt_count), p_table, length));
  65. ssdt_count++;
  66. return;
  67. }
  68. components.append(ACPISysFSComponent::create(signature, p_table, length));
  69. });
  70. m_components = components;
  71. auto rsdp = Memory::map_typed<Structures::RSDPDescriptor20>(ACPI::Parser::the()->rsdp());
  72. m_components.append(ACPISysFSComponent::create("RSDP", ACPI::Parser::the()->rsdp(), rsdp->base.revision == 0 ? sizeof(Structures::RSDPDescriptor) : rsdp->length));
  73. auto main_system_description_table = Memory::map_typed<Structures::SDTHeader>(ACPI::Parser::the()->main_system_description_table());
  74. if (ACPI::Parser::the()->is_xsdt_supported()) {
  75. m_components.append(ACPISysFSComponent::create("XSDT", ACPI::Parser::the()->main_system_description_table(), main_system_description_table->length));
  76. } else {
  77. m_components.append(ACPISysFSComponent::create("RSDT", ACPI::Parser::the()->main_system_description_table(), main_system_description_table->length));
  78. }
  79. }
  80. UNMAP_AFTER_INIT NonnullRefPtr<ACPISysFSDirectory> ACPISysFSDirectory::must_create(FirmwareSysFSDirectory& firmware_directory)
  81. {
  82. auto acpi_directory = MUST(adopt_nonnull_ref_or_enomem(new (nothrow) ACPISysFSDirectory(firmware_directory)));
  83. acpi_directory->find_tables_and_register_them_as_components();
  84. return acpi_directory;
  85. }
  86. UNMAP_AFTER_INIT ACPISysFSDirectory::ACPISysFSDirectory(FirmwareSysFSDirectory& firmware_directory)
  87. : SysFSDirectory(firmware_directory)
  88. {
  89. }
  90. void Parser::enumerate_static_tables(Function<void(StringView, PhysicalAddress, size_t)> callback)
  91. {
  92. for (auto& p_table : m_sdt_pointers) {
  93. auto table = Memory::map_typed<Structures::SDTHeader>(p_table);
  94. callback({ table->sig, 4 }, p_table, table->length);
  95. }
  96. }
  97. static bool match_table_signature(PhysicalAddress table_header, StringView signature);
  98. static Optional<PhysicalAddress> search_table_in_xsdt(PhysicalAddress xsdt, StringView signature);
  99. static Optional<PhysicalAddress> search_table_in_rsdt(PhysicalAddress rsdt, StringView signature);
  100. static bool validate_table(const Structures::SDTHeader&, size_t length);
  101. UNMAP_AFTER_INIT void Parser::locate_static_data()
  102. {
  103. locate_main_system_description_table();
  104. initialize_main_system_description_table();
  105. process_fadt_data();
  106. }
  107. UNMAP_AFTER_INIT Optional<PhysicalAddress> Parser::find_table(StringView signature)
  108. {
  109. dbgln_if(ACPI_DEBUG, "ACPI: Calling Find Table method!");
  110. for (auto p_sdt : m_sdt_pointers) {
  111. auto sdt = Memory::map_typed<Structures::SDTHeader>(p_sdt);
  112. dbgln_if(ACPI_DEBUG, "ACPI: Examining Table @ {}", p_sdt);
  113. if (!strncmp(sdt->sig, signature.characters_without_null_termination(), 4)) {
  114. dbgln_if(ACPI_DEBUG, "ACPI: Found Table @ {}", p_sdt);
  115. return p_sdt;
  116. }
  117. }
  118. return {};
  119. }
  120. bool Parser::handle_irq(const RegisterState&)
  121. {
  122. TODO();
  123. }
  124. UNMAP_AFTER_INIT void Parser::enable_aml_parsing()
  125. {
  126. // FIXME: When enabled, do other things to "parse AML".
  127. m_can_process_bytecode = true;
  128. }
  129. UNMAP_AFTER_INIT void Parser::process_fadt_data()
  130. {
  131. dmesgln("ACPI: Initializing Fixed ACPI data");
  132. VERIFY(!m_fadt.is_null());
  133. dbgln_if(ACPI_DEBUG, "ACPI: FADT @ {}", m_fadt);
  134. auto sdt = Memory::map_typed<Structures::FADT>(m_fadt);
  135. dmesgln("ACPI: Fixed ACPI data, Revision {}, length: {} bytes", (size_t)sdt->h.revision, (size_t)sdt->h.length);
  136. dmesgln("ACPI: DSDT {}", PhysicalAddress(sdt->dsdt_ptr));
  137. m_x86_specific_flags.cmos_rtc_not_present = (sdt->ia_pc_boot_arch_flags & (u8)FADTFlags::IA_PC_Flags::CMOS_RTC_Not_Present);
  138. // FIXME: QEMU doesn't report that we have an i8042 controller in these flags, even if it should (when FADT revision is 3),
  139. // Later on, we need to make sure that we enumerate the ACPI namespace (AML encoded), instead of just using this value.
  140. m_x86_specific_flags.keyboard_8042 = (sdt->h.revision <= 3) || (sdt->ia_pc_boot_arch_flags & (u8)FADTFlags::IA_PC_Flags::PS2_8042);
  141. m_x86_specific_flags.legacy_devices = (sdt->ia_pc_boot_arch_flags & (u8)FADTFlags::IA_PC_Flags::Legacy_Devices);
  142. m_x86_specific_flags.msi_not_supported = (sdt->ia_pc_boot_arch_flags & (u8)FADTFlags::IA_PC_Flags::MSI_Not_Supported);
  143. m_x86_specific_flags.vga_not_present = (sdt->ia_pc_boot_arch_flags & (u8)FADTFlags::IA_PC_Flags::VGA_Not_Present);
  144. m_hardware_flags.cpu_software_sleep = (sdt->flags & (u32)FADTFlags::FeatureFlags::CPU_SW_SLP);
  145. m_hardware_flags.docking_capability = (sdt->flags & (u32)FADTFlags::FeatureFlags::DCK_CAP);
  146. m_hardware_flags.fix_rtc = (sdt->flags & (u32)FADTFlags::FeatureFlags::FIX_RTC);
  147. m_hardware_flags.force_apic_cluster_model = (sdt->flags & (u32)FADTFlags::FeatureFlags::FORCE_APIC_CLUSTER_MODEL);
  148. m_hardware_flags.force_apic_physical_destination_mode = (sdt->flags & (u32)FADTFlags::FeatureFlags::FORCE_APIC_PHYSICAL_DESTINATION_MODE);
  149. m_hardware_flags.hardware_reduced_acpi = (sdt->flags & (u32)FADTFlags::FeatureFlags::HW_REDUCED_ACPI);
  150. m_hardware_flags.headless = (sdt->flags & (u32)FADTFlags::FeatureFlags::HEADLESS);
  151. m_hardware_flags.low_power_s0_idle_capable = (sdt->flags & (u32)FADTFlags::FeatureFlags::LOW_POWER_S0_IDLE_CAPABLE);
  152. m_hardware_flags.multiprocessor_c2 = (sdt->flags & (u32)FADTFlags::FeatureFlags::P_LVL2_UP);
  153. m_hardware_flags.pci_express_wake = (sdt->flags & (u32)FADTFlags::FeatureFlags::PCI_EXP_WAK);
  154. m_hardware_flags.power_button = (sdt->flags & (u32)FADTFlags::FeatureFlags::PWR_BUTTON);
  155. m_hardware_flags.processor_c1 = (sdt->flags & (u32)FADTFlags::FeatureFlags::PROC_C1);
  156. m_hardware_flags.remote_power_on_capable = (sdt->flags & (u32)FADTFlags::FeatureFlags::REMOTE_POWER_ON_CAPABLE);
  157. m_hardware_flags.reset_register_supported = (sdt->flags & (u32)FADTFlags::FeatureFlags::RESET_REG_SUPPORTED);
  158. m_hardware_flags.rtc_s4 = (sdt->flags & (u32)FADTFlags::FeatureFlags::RTC_s4);
  159. m_hardware_flags.s4_rtc_status_valid = (sdt->flags & (u32)FADTFlags::FeatureFlags::S4_RTC_STS_VALID);
  160. m_hardware_flags.sealed_case = (sdt->flags & (u32)FADTFlags::FeatureFlags::SEALED_CASE);
  161. m_hardware_flags.sleep_button = (sdt->flags & (u32)FADTFlags::FeatureFlags::SLP_BUTTON);
  162. m_hardware_flags.timer_value_extension = (sdt->flags & (u32)FADTFlags::FeatureFlags::TMR_VAL_EXT);
  163. m_hardware_flags.use_platform_clock = (sdt->flags & (u32)FADTFlags::FeatureFlags::USE_PLATFORM_CLOCK);
  164. m_hardware_flags.wbinvd = (sdt->flags & (u32)FADTFlags::FeatureFlags::WBINVD);
  165. m_hardware_flags.wbinvd_flush = (sdt->flags & (u32)FADTFlags::FeatureFlags::WBINVD_FLUSH);
  166. }
  167. bool Parser::can_reboot()
  168. {
  169. auto fadt = Memory::map_typed<Structures::FADT>(m_fadt);
  170. if (fadt->h.revision < 2)
  171. return false;
  172. return m_hardware_flags.reset_register_supported;
  173. }
  174. void Parser::access_generic_address(const Structures::GenericAddressStructure& structure, u32 value)
  175. {
  176. switch ((GenericAddressStructure::AddressSpace)structure.address_space) {
  177. case GenericAddressStructure::AddressSpace::SystemIO: {
  178. IOAddress address(structure.address);
  179. dbgln("ACPI: Sending value {:x} to {}", value, address);
  180. switch (structure.access_size) {
  181. case (u8)GenericAddressStructure::AccessSize::QWord: {
  182. dbgln("Trying to send QWord to IO port");
  183. VERIFY_NOT_REACHED();
  184. break;
  185. }
  186. case (u8)GenericAddressStructure::AccessSize::Undefined: {
  187. dbgln("ACPI Warning: Unknown access size {}", structure.access_size);
  188. VERIFY(structure.bit_width != (u8)GenericAddressStructure::BitWidth::QWord);
  189. VERIFY(structure.bit_width != (u8)GenericAddressStructure::BitWidth::Undefined);
  190. dbgln("ACPI: Bit Width - {} bits", structure.bit_width);
  191. address.out(value, structure.bit_width);
  192. break;
  193. }
  194. default:
  195. address.out(value, (8 << (structure.access_size - 1)));
  196. break;
  197. }
  198. return;
  199. }
  200. case GenericAddressStructure::AddressSpace::SystemMemory: {
  201. dbgln("ACPI: Sending value {:x} to {}", value, PhysicalAddress(structure.address));
  202. switch ((GenericAddressStructure::AccessSize)structure.access_size) {
  203. case GenericAddressStructure::AccessSize::Byte:
  204. *Memory::map_typed<u8>(PhysicalAddress(structure.address)) = value;
  205. break;
  206. case GenericAddressStructure::AccessSize::Word:
  207. *Memory::map_typed<u16>(PhysicalAddress(structure.address)) = value;
  208. break;
  209. case GenericAddressStructure::AccessSize::DWord:
  210. *Memory::map_typed<u32>(PhysicalAddress(structure.address)) = value;
  211. break;
  212. case GenericAddressStructure::AccessSize::QWord: {
  213. *Memory::map_typed<u64>(PhysicalAddress(structure.address)) = value;
  214. break;
  215. }
  216. default:
  217. VERIFY_NOT_REACHED();
  218. }
  219. return;
  220. }
  221. case GenericAddressStructure::AddressSpace::PCIConfigurationSpace: {
  222. // According to https://uefi.org/specs/ACPI/6.4/05_ACPI_Software_Programming_Model/ACPI_Software_Programming_Model.html#address-space-format,
  223. // PCI addresses must be confined to devices on Segment group 0, bus 0.
  224. auto pci_address = PCI::Address(0, 0, ((structure.address >> 24) & 0xFF), ((structure.address >> 16) & 0xFF));
  225. dbgln("ACPI: Sending value {:x} to {}", value, pci_address);
  226. u32 offset_in_pci_address = structure.address & 0xFFFF;
  227. if (structure.access_size == (u8)GenericAddressStructure::AccessSize::QWord) {
  228. dbgln("Trying to send QWord to PCI configuration space");
  229. VERIFY_NOT_REACHED();
  230. }
  231. VERIFY(structure.access_size != (u8)GenericAddressStructure::AccessSize::Undefined);
  232. PCI::raw_access(pci_address, offset_in_pci_address, (1 << (structure.access_size - 1)), value);
  233. return;
  234. }
  235. default:
  236. VERIFY_NOT_REACHED();
  237. }
  238. VERIFY_NOT_REACHED();
  239. }
  240. bool Parser::validate_reset_register()
  241. {
  242. // According to https://uefi.org/specs/ACPI/6.4/04_ACPI_Hardware_Specification/ACPI_Hardware_Specification.html#reset-register,
  243. // the reset register can only be located in I/O bus, PCI bus or memory-mapped.
  244. auto fadt = Memory::map_typed<Structures::FADT>(m_fadt);
  245. return (fadt->reset_reg.address_space == (u8)GenericAddressStructure::AddressSpace::PCIConfigurationSpace || fadt->reset_reg.address_space == (u8)GenericAddressStructure::AddressSpace::SystemMemory || fadt->reset_reg.address_space == (u8)GenericAddressStructure::AddressSpace::SystemIO);
  246. }
  247. void Parser::try_acpi_reboot()
  248. {
  249. InterruptDisabler disabler;
  250. if (!can_reboot()) {
  251. dmesgln("ACPI: Reboot not supported!");
  252. return;
  253. }
  254. dbgln_if(ACPI_DEBUG, "ACPI: Rebooting, probing FADT ({})", m_fadt);
  255. auto fadt = Memory::map_typed<Structures::FADT>(m_fadt);
  256. VERIFY(validate_reset_register());
  257. access_generic_address(fadt->reset_reg, fadt->reset_value);
  258. Processor::halt();
  259. }
  260. void Parser::try_acpi_shutdown()
  261. {
  262. dmesgln("ACPI: Shutdown is not supported with the current configuration, aborting!");
  263. }
  264. size_t Parser::get_table_size(PhysicalAddress table_header)
  265. {
  266. InterruptDisabler disabler;
  267. dbgln_if(ACPI_DEBUG, "ACPI: Checking SDT Length");
  268. return Memory::map_typed<Structures::SDTHeader>(table_header)->length;
  269. }
  270. u8 Parser::get_table_revision(PhysicalAddress table_header)
  271. {
  272. InterruptDisabler disabler;
  273. dbgln_if(ACPI_DEBUG, "ACPI: Checking SDT Revision");
  274. return Memory::map_typed<Structures::SDTHeader>(table_header)->revision;
  275. }
  276. UNMAP_AFTER_INIT void Parser::initialize_main_system_description_table()
  277. {
  278. dbgln_if(ACPI_DEBUG, "ACPI: Checking Main SDT Length to choose the correct mapping size");
  279. VERIFY(!m_main_system_description_table.is_null());
  280. auto length = get_table_size(m_main_system_description_table);
  281. auto revision = get_table_revision(m_main_system_description_table);
  282. auto sdt = Memory::map_typed<Structures::SDTHeader>(m_main_system_description_table, length);
  283. dmesgln("ACPI: Main Description Table valid? {}", validate_table(*sdt, length));
  284. if (m_xsdt_supported) {
  285. auto& xsdt = (const Structures::XSDT&)*sdt;
  286. dmesgln("ACPI: Using XSDT, enumerating tables @ {}", m_main_system_description_table);
  287. dmesgln("ACPI: XSDT revision {}, total length: {}", revision, length);
  288. dbgln_if(ACPI_DEBUG, "ACPI: XSDT pointer @ {}", VirtualAddress { &xsdt });
  289. for (u32 i = 0; i < ((length - sizeof(Structures::SDTHeader)) / sizeof(u64)); i++) {
  290. dbgln_if(ACPI_DEBUG, "ACPI: Found new table [{0}], @ V{1:p} - P{1:p}", i, &xsdt.table_ptrs[i]);
  291. m_sdt_pointers.append(PhysicalAddress(xsdt.table_ptrs[i]));
  292. }
  293. } else {
  294. auto& rsdt = (const Structures::RSDT&)*sdt;
  295. dmesgln("ACPI: Using RSDT, enumerating tables @ {}", m_main_system_description_table);
  296. dmesgln("ACPI: RSDT revision {}, total length: {}", revision, length);
  297. dbgln_if(ACPI_DEBUG, "ACPI: RSDT pointer @ V{}", &rsdt);
  298. for (u32 i = 0; i < ((length - sizeof(Structures::SDTHeader)) / sizeof(u32)); i++) {
  299. dbgln_if(ACPI_DEBUG, "ACPI: Found new table [{0}], @ V{1:p} - P{1:p}", i, &rsdt.table_ptrs[i]);
  300. m_sdt_pointers.append(PhysicalAddress(rsdt.table_ptrs[i]));
  301. }
  302. }
  303. }
  304. UNMAP_AFTER_INIT void Parser::locate_main_system_description_table()
  305. {
  306. auto rsdp = Memory::map_typed<Structures::RSDPDescriptor20>(m_rsdp);
  307. if (rsdp->base.revision == 0) {
  308. m_xsdt_supported = false;
  309. } else if (rsdp->base.revision >= 2) {
  310. if (rsdp->xsdt_ptr != (u64) nullptr) {
  311. m_xsdt_supported = true;
  312. } else {
  313. m_xsdt_supported = false;
  314. }
  315. }
  316. if (!m_xsdt_supported) {
  317. m_main_system_description_table = PhysicalAddress(rsdp->base.rsdt_ptr);
  318. } else {
  319. m_main_system_description_table = PhysicalAddress(rsdp->xsdt_ptr);
  320. }
  321. }
  322. UNMAP_AFTER_INIT Parser::Parser(PhysicalAddress rsdp, PhysicalAddress fadt, u8 irq_number)
  323. : IRQHandler(irq_number)
  324. , m_rsdp(rsdp)
  325. , m_fadt(fadt)
  326. {
  327. dmesgln("ACPI: Using RSDP @ {}", rsdp);
  328. locate_static_data();
  329. }
  330. static bool validate_table(const Structures::SDTHeader& v_header, size_t length)
  331. {
  332. u8 checksum = 0;
  333. auto* sdt = (const u8*)&v_header;
  334. for (size_t i = 0; i < length; i++)
  335. checksum += sdt[i];
  336. if (checksum == 0)
  337. return true;
  338. return false;
  339. }
  340. // https://uefi.org/specs/ACPI/6.4/05_ACPI_Software_Programming_Model/ACPI_Software_Programming_Model.html#finding-the-rsdp-on-ia-pc-systems
  341. UNMAP_AFTER_INIT Optional<PhysicalAddress> StaticParsing::find_rsdp()
  342. {
  343. StringView signature("RSD PTR ");
  344. auto rsdp = map_ebda().find_chunk_starting_with(signature, 16);
  345. if (rsdp.has_value())
  346. return rsdp;
  347. rsdp = map_bios().find_chunk_starting_with(signature, 16);
  348. if (rsdp.has_value())
  349. return rsdp;
  350. // On some systems the RSDP may be located in ACPI NVS or reclaimable memory regions
  351. MM.for_each_physical_memory_range([&](auto& memory_range) {
  352. if (!(memory_range.type == Memory::PhysicalMemoryRangeType::ACPI_NVS || memory_range.type == Memory::PhysicalMemoryRangeType::ACPI_Reclaimable))
  353. return IterationDecision::Continue;
  354. Memory::MappedROM mapping;
  355. mapping.region = MM.allocate_kernel_region(memory_range.start, Memory::page_round_up(memory_range.length).release_value_but_fixme_should_propagate_errors(), {}, Memory::Region::Access::Read).release_value();
  356. mapping.offset = memory_range.start.offset_in_page();
  357. mapping.size = memory_range.length;
  358. mapping.paddr = memory_range.start;
  359. rsdp = mapping.find_chunk_starting_with(signature, 16);
  360. if (rsdp.has_value())
  361. return IterationDecision::Break;
  362. return IterationDecision::Continue;
  363. });
  364. return rsdp;
  365. }
  366. UNMAP_AFTER_INIT Optional<PhysicalAddress> StaticParsing::find_table(PhysicalAddress rsdp_address, StringView signature)
  367. {
  368. // FIXME: There's no validation of ACPI tables here. Use the checksum to validate the tables.
  369. VERIFY(signature.length() == 4);
  370. auto rsdp = Memory::map_typed<Structures::RSDPDescriptor20>(rsdp_address);
  371. if (rsdp->base.revision == 0)
  372. return search_table_in_rsdt(PhysicalAddress(rsdp->base.rsdt_ptr), signature);
  373. if (rsdp->base.revision >= 2) {
  374. if (rsdp->xsdt_ptr)
  375. return search_table_in_xsdt(PhysicalAddress(rsdp->xsdt_ptr), signature);
  376. return search_table_in_rsdt(PhysicalAddress(rsdp->base.rsdt_ptr), signature);
  377. }
  378. VERIFY_NOT_REACHED();
  379. }
  380. UNMAP_AFTER_INIT static Optional<PhysicalAddress> search_table_in_xsdt(PhysicalAddress xsdt_address, StringView signature)
  381. {
  382. // FIXME: There's no validation of ACPI tables here. Use the checksum to validate the tables.
  383. VERIFY(signature.length() == 4);
  384. auto xsdt = Memory::map_typed<Structures::XSDT>(xsdt_address);
  385. for (size_t i = 0; i < ((xsdt->h.length - sizeof(Structures::SDTHeader)) / sizeof(u64)); ++i) {
  386. if (match_table_signature(PhysicalAddress((PhysicalPtr)xsdt->table_ptrs[i]), signature))
  387. return PhysicalAddress((PhysicalPtr)xsdt->table_ptrs[i]);
  388. }
  389. return {};
  390. }
  391. static bool match_table_signature(PhysicalAddress table_header, StringView signature)
  392. {
  393. // FIXME: There's no validation of ACPI tables here. Use the checksum to validate the tables.
  394. VERIFY(signature.length() == 4);
  395. auto table = Memory::map_typed<Structures::RSDT>(table_header);
  396. return !strncmp(table->h.sig, signature.characters_without_null_termination(), 4);
  397. }
  398. UNMAP_AFTER_INIT static Optional<PhysicalAddress> search_table_in_rsdt(PhysicalAddress rsdt_address, StringView signature)
  399. {
  400. // FIXME: There's no validation of ACPI tables here. Use the checksum to validate the tables.
  401. VERIFY(signature.length() == 4);
  402. auto rsdt = Memory::map_typed<Structures::RSDT>(rsdt_address);
  403. for (u32 i = 0; i < ((rsdt->h.length - sizeof(Structures::SDTHeader)) / sizeof(u32)); i++) {
  404. if (match_table_signature(PhysicalAddress((PhysicalPtr)rsdt->table_ptrs[i]), signature))
  405. return PhysicalAddress((PhysicalPtr)rsdt->table_ptrs[i]);
  406. }
  407. return {};
  408. }
  409. }