ACPIStaticParser.cpp 14 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372
  1. #include <Kernel/ACPI/ACPIStaticParser.h>
  2. #include <Kernel/IO.h>
  3. #include <Kernel/StdLib.h>
  4. #include <Kernel/VM/MemoryManager.h>
  5. void ACPIStaticParser::initialize(ACPI_RAW::RSDPDescriptor20& rsdp)
  6. {
  7. if (!ACPIParser::is_initialized()) {
  8. new ACPIStaticParser(rsdp);
  9. }
  10. }
  11. void ACPIStaticParser::initialize_without_rsdp()
  12. {
  13. if (!ACPIParser::is_initialized()) {
  14. new ACPIStaticParser();
  15. }
  16. }
  17. bool ACPIStaticParser::is_initialized()
  18. {
  19. return ACPIParser::is_initialized();
  20. }
  21. void ACPIStaticParser::locate_static_data()
  22. {
  23. locate_main_system_description_table();
  24. initialize_main_system_description_table();
  25. init_fadt();
  26. locate_all_aml_tables();
  27. }
  28. ACPI_RAW::SDTHeader* ACPIStaticParser::find_table(const char* sig)
  29. {
  30. #ifdef ACPI_DEBUG
  31. dbgprintf("ACPI: Calling Find Table method!\n");
  32. #endif
  33. for (auto* physical_sdt_ptr : m_main_sdt->get_sdt_pointers()) {
  34. auto region = MM.allocate_kernel_region((PAGE_SIZE * 2), "ACPI Static Parser Tables Finding", Region::Access::Read);
  35. mmap_region(*region, PhysicalAddress((u32)physical_sdt_ptr));
  36. ACPI_RAW::SDTHeader* sdt = (ACPI_RAW::SDTHeader*)(region->vaddr().get() + ((u32)physical_sdt_ptr & (~PAGE_MASK)));
  37. #ifdef ACPI_DEBUG
  38. dbgprintf("ACPI: Examining Table @ P 0x%x\n", physical_sdt_ptr);
  39. #endif
  40. if (!strncmp(sdt->sig, sig, 4)) {
  41. #ifdef ACPI_DEBUG
  42. dbgprintf("ACPI: Found Table @ P 0x%x\n", physical_sdt_ptr);
  43. #endif
  44. return physical_sdt_ptr;
  45. }
  46. }
  47. return nullptr;
  48. }
  49. ACPI_RAW::SDTHeader& ACPIStaticParser::find_fadt()
  50. {
  51. kprintf("ACPI: Searching for the Fixed ACPI Data Table\n");
  52. for (auto* physical_sdt_ptr : m_main_sdt->get_sdt_pointers()) {
  53. auto region = MM.allocate_kernel_region((PAGE_SIZE * 2), "ACPI Static Parser AML Tables Finding", Region::Access::Read);
  54. mmap_region(*region, PhysicalAddress((u32)physical_sdt_ptr & PAGE_MASK));
  55. ACPI_RAW::SDTHeader* sdt = (ACPI_RAW::SDTHeader*)(region->vaddr().get() + ((u32)physical_sdt_ptr & (~PAGE_MASK)));
  56. #ifdef ACPI_DEBUG
  57. dbgprintf("ACPI: Examining Table @ P 0x%x\n", physical_sdt_ptr);
  58. #endif
  59. if (!strncmp(sdt->sig, "FACP", 4)) {
  60. kprintf("ACPI: Found FADT Table @ P 0x%x, registering\n", physical_sdt_ptr);
  61. return *physical_sdt_ptr;
  62. }
  63. }
  64. ASSERT_NOT_REACHED(); // If we reached this point, there's something very incorrect with the system!
  65. }
  66. void ACPIStaticParser::init_fadt()
  67. {
  68. kprintf("ACPI: Initializing Fixed ACPI data\n");
  69. ACPI_RAW::SDTHeader& physical_fadt = find_fadt();
  70. auto checkup_region = MM.allocate_kernel_region((PAGE_SIZE * 2), "ACPI Static Parser", Region::Access::Read);
  71. #ifdef ACPI_DEBUG
  72. dbgprintf("ACPI: Checking FADT Length to choose the correct mapping size\n");
  73. #endif
  74. mmap_region(*checkup_region, PhysicalAddress((u32)(&physical_fadt) & PAGE_MASK));
  75. ACPI_RAW::SDTHeader* sdt = (ACPI_RAW::SDTHeader*)(checkup_region->vaddr().get() + ((u32)(&physical_fadt) & (~PAGE_MASK)));
  76. #ifdef ACPI_DEBUG
  77. dbgprintf("ACPI: FADT @ V 0x%x, P 0x%x\n", sdt, &physical_fadt);
  78. #endif
  79. u32 length = sdt->length;
  80. kprintf("ACPI: Fixed ACPI data, Revision %u\n", sdt->revision);
  81. auto fadt_region = MM.allocate_kernel_region(PAGE_ROUND_UP(length) + PAGE_SIZE, "ACPI Static Parser", Region::Access::Read);
  82. mmap_region(*fadt_region, PhysicalAddress((u32)(&physical_fadt) & PAGE_MASK));
  83. m_fadt = OwnPtr<ACPI::FixedACPIData>(new ACPI::FixedACPIData(*((ACPI_RAW::FADT*)(fadt_region->vaddr().get() + ((u32)(&physical_fadt) & (~PAGE_MASK))))));
  84. #ifdef ACPI_DEBUG
  85. dbgprintf("ACPI: Finished to initialize Fixed ACPI data\n");
  86. #endif
  87. }
  88. void ACPIStaticParser::do_acpi_reboot()
  89. {
  90. // FIXME: Determine if we need to do MMIO/PCI/IO access to reboot, according to ACPI spec 6.2, Section 4.8.3.6
  91. #ifdef ACPI_DEBUG
  92. dbgprintf("ACPI: Rebooting, Probing FADT (P @ 0x%x)\n", m_fadt.ptr());
  93. #endif
  94. if (m_fadt->m_revision >= 2) {
  95. kprintf("ACPI: Reboot, Sending value 0%x to Port 0x%x\n", m_fadt->m_reset_value, m_fadt->m_reset_reg.address);
  96. IO::out8(m_fadt->m_reset_reg.address, m_fadt->m_reset_value);
  97. } else {
  98. kprintf("ACPI: Reboot, Not supported!\n");
  99. }
  100. ASSERT_NOT_REACHED(); /// If rebooting didn't work, halt.
  101. }
  102. void ACPIStaticParser::do_acpi_shutdown()
  103. {
  104. kprintf("ACPI: Shutdown is not supported with the current configuration, Abort!\n");
  105. ASSERT_NOT_REACHED();
  106. }
  107. void ACPIStaticParser::initialize_main_system_description_table()
  108. {
  109. auto checkup_region = MM.allocate_kernel_region((PAGE_SIZE * 2), "ACPI Static Parser Copying Method", Region::Access::Read);
  110. #ifdef ACPI_DEBUG
  111. dbgprintf("ACPI: Checking Main SDT Length to choose the correct mapping size");
  112. #endif
  113. mmap_region(*checkup_region, PhysicalAddress((u32)m_main_system_description_table & PAGE_MASK));
  114. auto* sdt = (ACPI_RAW::SDTHeader*)(checkup_region->vaddr().get() + ((u32)m_main_system_description_table & (~PAGE_MASK)));
  115. u32 length = sdt->length;
  116. u8 revision = sdt->revision;
  117. auto main_sdt_region = MM.allocate_kernel_region(PAGE_ROUND_UP(length) + PAGE_SIZE, "ACPI Static Parser Copying Method", Region::Access::Read);
  118. mmap_region(*main_sdt_region, PhysicalAddress((u32)m_main_system_description_table & PAGE_MASK));
  119. Vector<ACPI_RAW::SDTHeader*> sdt_pointers;
  120. if (m_xsdt_supported) {
  121. ACPI_RAW::XSDT* xsdt = (ACPI_RAW::XSDT*)(main_sdt_region->vaddr().get() + ((u32)m_main_system_description_table & (~PAGE_MASK)));
  122. kprintf("ACPI: Using XSDT, Enumerating tables @ P 0x%x\n", m_main_system_description_table);
  123. kprintf("ACPI: XSDT Revision %d, Total length - %u\n", revision, length);
  124. for (u32 i = 0; i < ((xsdt->h.length - sizeof(ACPI_RAW::SDTHeader)) / sizeof(u64)); i++) {
  125. #ifdef ACPI_DEBUG
  126. dbgprintf("ACPI: Found new table, @ P 0x%x\n", xsdt->table_ptrs[i]);
  127. #endif
  128. sdt_pointers.append((ACPI_RAW::SDTHeader*)xsdt->table_ptrs[i]);
  129. }
  130. } else {
  131. ACPI_RAW::RSDT* rsdt = (ACPI_RAW::RSDT*)(main_sdt_region->vaddr().get() + ((u32)m_main_system_description_table & (~PAGE_MASK)));
  132. kprintf("ACPI: Using RSDT, Enumerating tables @ P 0x%x\n", m_main_system_description_table);
  133. kprintf("ACPI: RSDT Revision %d, Total length - %u\n", revision, length);
  134. for (u32 i = 0; i < ((rsdt->h.length - sizeof(ACPI_RAW::SDTHeader)) / sizeof(u32)); i++) {
  135. #ifdef ACPI_DEBUG
  136. dbgprintf("ACPI: Found new table, @ P 0x%x\n", rsdt->table_ptrs[i]);
  137. #endif
  138. sdt_pointers.append((ACPI_RAW::SDTHeader*)rsdt->table_ptrs[i]);
  139. }
  140. }
  141. m_main_sdt = OwnPtr<ACPI::MainSystemDescriptionTable>(new ACPI::MainSystemDescriptionTable(move(sdt_pointers)));
  142. }
  143. void ACPIStaticParser::locate_main_system_description_table()
  144. {
  145. if (m_rsdp->base.revision == 0) {
  146. m_xsdt_supported = false;
  147. } else if (m_rsdp->base.revision >= 2) {
  148. if (m_rsdp->xsdt_ptr != (u64) nullptr) {
  149. m_xsdt_supported = true;
  150. } else {
  151. m_xsdt_supported = false;
  152. }
  153. }
  154. if (!m_xsdt_supported) {
  155. m_main_system_description_table = (ACPI_RAW::SDTHeader*)m_rsdp->base.rsdt_ptr;
  156. } else {
  157. m_main_system_description_table = (ACPI_RAW::SDTHeader*)m_rsdp->xsdt_ptr;
  158. }
  159. }
  160. void ACPIStaticParser::locate_all_aml_tables()
  161. {
  162. // Note: According to the ACPI spec, DSDT pointer may be found in the FADT table.
  163. // All other continuation of the DSDT can be found as pointers in the RSDT/XSDT.
  164. kprintf("ACPI: Searching for AML Tables\n");
  165. m_aml_tables_ptrs.append(m_fadt->get_dsdt());
  166. for (auto* sdt_ptr : m_main_sdt->get_sdt_pointers()) {
  167. auto region = MM.allocate_kernel_region((PAGE_SIZE * 2), "ACPI Static Parser AML Tables Finding", Region::Access::Read);
  168. mmap_region(*region, PhysicalAddress((u32)sdt_ptr));
  169. auto* sdt = (ACPI_RAW::SDTHeader*)(region->vaddr().get() + ((u32)sdt_ptr & (~PAGE_MASK)));
  170. #ifdef ACPI_DEBUG
  171. dbgprintf("ACPI: Examining Table @ P 0x%x\n", sdt_ptr);
  172. #endif
  173. if (!strncmp(sdt->sig, "SSDT", 4)) {
  174. kprintf("ACPI: Found AML Table @ P 0x%x, registering\n", sdt_ptr);
  175. m_aml_tables_ptrs.append(sdt);
  176. }
  177. }
  178. }
  179. ACPIStaticParser::ACPIStaticParser()
  180. : ACPIParser(true)
  181. , m_rsdp(nullptr)
  182. , m_main_sdt(nullptr)
  183. , m_fadt(nullptr)
  184. {
  185. m_rsdp = search_rsdp();
  186. if (m_rsdp != nullptr) {
  187. kprintf("ACPI: Using RSDP @ P 0x%x\n", m_rsdp);
  188. m_operable = true;
  189. locate_static_data();
  190. } else {
  191. m_operable = false;
  192. kprintf("ACPI: Disabled, due to RSDP being absent\n");
  193. }
  194. }
  195. ACPI_RAW::RSDPDescriptor20* ACPIStaticParser::search_rsdp()
  196. {
  197. auto region = MM.allocate_kernel_region(PAGE_SIZE, "ACPI Static Parser RSDP Finding", Region::Access::Read);
  198. mmap_region(*region, PhysicalAddress(0));
  199. u16 ebda_seg = (u16) * ((uint16_t*)((region->vaddr().get() & PAGE_MASK) + 0x40e));
  200. kprintf("ACPI: Probing EBDA, Segment 0x%x\n", ebda_seg);
  201. // FIXME: Ensure that we always have identity mapping (identity paging) here! Don't rely on existing mapping...
  202. for (char* rsdp_str = (char*)(PhysicalAddress(ebda_seg << 4).as_ptr()); rsdp_str < (char*)((ebda_seg << 4) + 1024); rsdp_str += 16) {
  203. #ifdef ACPI_DEBUG
  204. dbgprintf("ACPI: Looking for RSDP in EBDA @ Px%x\n", rsdp_str);
  205. #endif
  206. if (!strncmp("RSD PTR ", rsdp_str, strlen("RSD PTR ")))
  207. return (ACPI_RAW::RSDPDescriptor20*)rsdp_str;
  208. }
  209. // FIXME: Ensure that we always have identity mapping (identity paging) here! Don't rely on existing mapping...
  210. for (char* rsdp_str = (char*)(PhysicalAddress(0xE0000).as_ptr()); rsdp_str < (char*)0xFFFFF; rsdp_str += 16) {
  211. #ifdef ACPI_DEBUG
  212. dbgprintf("ACPI: Looking for RSDP in EBDA @ Px%x\n", rsdp_str);
  213. #endif
  214. if (!strncmp("RSD PTR ", rsdp_str, strlen("RSD PTR ")))
  215. return (ACPI_RAW::RSDPDescriptor20*)rsdp_str;
  216. }
  217. return nullptr;
  218. }
  219. void ACPIStaticParser::mmap(VirtualAddress vaddr, PhysicalAddress paddr, u32 length)
  220. {
  221. unsigned i = 0;
  222. while (length >= PAGE_SIZE) {
  223. MM.map_for_kernel(VirtualAddress(vaddr.offset(i * PAGE_SIZE).get()), PhysicalAddress(paddr.offset(i * PAGE_SIZE).get()));
  224. #ifdef ACPI_DEBUG
  225. dbgprintf("ACPI: map - V 0x%x -> P 0x%x\n", vaddr.offset(i * PAGE_SIZE).get(), paddr.offset(i * PAGE_SIZE).get());
  226. #endif
  227. length -= PAGE_SIZE;
  228. i++;
  229. }
  230. if (length > 0) {
  231. MM.map_for_kernel(vaddr.offset(i * PAGE_SIZE), paddr.offset(i * PAGE_SIZE), true);
  232. }
  233. #ifdef ACPI_DEBUG
  234. dbgprintf("ACPI: Finished mapping\n");
  235. #endif
  236. }
  237. void ACPIStaticParser::mmap_region(Region& region, PhysicalAddress paddr)
  238. {
  239. #ifdef ACPI_DEBUG
  240. dbgprintf("ACPI: Mapping region, size - %u\n", region.size());
  241. #endif
  242. mmap(region.vaddr(), paddr, region.size());
  243. }
  244. ACPIStaticParser::ACPIStaticParser(ACPI_RAW::RSDPDescriptor20& rsdp)
  245. : ACPIParser(true)
  246. , m_rsdp(&rsdp)
  247. , m_main_sdt(nullptr)
  248. , m_fadt(nullptr)
  249. {
  250. kprintf("ACPI: Using RSDP @ Px%x\n", &rsdp);
  251. m_operable = true;
  252. locate_static_data();
  253. }
  254. ACPI::MainSystemDescriptionTable::MainSystemDescriptionTable(Vector<ACPI_RAW::SDTHeader*>&& sdt_pointers)
  255. {
  256. for (auto* sdt_ptr : sdt_pointers) {
  257. #ifdef ACPI_DEBUG
  258. dbgprintf("ACPI: Register new table in Main SDT, @ P 0x%x\n", sdt_ptr);
  259. #endif
  260. m_sdt_pointers.append(sdt_ptr);
  261. }
  262. }
  263. Vector<ACPI_RAW::SDTHeader*>& ACPI::MainSystemDescriptionTable::get_sdt_pointers()
  264. {
  265. return m_sdt_pointers;
  266. }
  267. ACPI::FixedACPIData::FixedACPIData(ACPI_RAW::FADT& fadt)
  268. {
  269. m_dsdt_ptr = fadt.dsdt_ptr;
  270. #ifdef ACPI_DEBUG
  271. dbgprintf("ACPI: DSDT pointer @ P 0x%x\n", m_dsdt_ptr);
  272. #endif
  273. m_revision = fadt.h.revision;
  274. m_x_dsdt_ptr = fadt.x_dsdt;
  275. m_preferred_pm_profile = fadt.preferred_pm_profile;
  276. m_sci_int = fadt.sci_int;
  277. m_smi_cmd = fadt.smi_cmd;
  278. m_acpi_enable_value = fadt.acpi_enable_value;
  279. m_acpi_disable_value = fadt.acpi_disable_value;
  280. m_s4bios_req = fadt.s4bios_req;
  281. m_pstate_cnt = fadt.pstate_cnt;
  282. m_PM1a_EVT_BLK = fadt.PM1a_EVT_BLK;
  283. m_PM1b_EVT_BLK = fadt.PM1b_EVT_BLK;
  284. m_PM1a_CNT_BLK = fadt.PM1a_CNT_BLK;
  285. m_PM1b_CNT_BLK = fadt.PM1b_CNT_BLK;
  286. m_PM2_CNT_BLK = fadt.PM2_CNT_BLK;
  287. m_PM_TMR_BLK = fadt.PM_TMR_BLK;
  288. m_GPE0_BLK = fadt.GPE0_BLK;
  289. m_GPE1_BLK = fadt.GPE1_BLK;
  290. m_PM1_EVT_LEN = fadt.PM1_EVT_LEN;
  291. m_PM1_CNT_LEN = fadt.PM1_CNT_LEN;
  292. m_PM2_CNT_LEN = fadt.PM2_CNT_LEN;
  293. m_PM_TMR_LEN = fadt.PM_TMR_LEN;
  294. m_GPE0_BLK_LEN = fadt.GPE0_BLK_LEN;
  295. m_GPE1_BLK_LEN = fadt.GPE1_BLK_LEN;
  296. m_GPE1_BASE = fadt.GPE1_BASE;
  297. m_cst_cnt = fadt.cst_cnt;
  298. m_P_LVL2_LAT = fadt.P_LVL2_LAT;
  299. m_P_LVL3_LAT = fadt.P_LVL3_LAT;
  300. m_flush_size = fadt.flush_size;
  301. m_flush_stride = fadt.flush_stride;
  302. m_duty_offset = fadt.duty_offset;
  303. m_duty_width = fadt.duty_width;
  304. m_day_alrm = fadt.day_alrm;
  305. m_mon_alrm = fadt.mon_alrm;
  306. m_century = fadt.century;
  307. m_ia_pc_boot_arch_flags = fadt.ia_pc_boot_arch_flags;
  308. m_flags = fadt.flags;
  309. m_reset_reg = fadt.reset_reg;
  310. #ifdef ACPI_DEBUG
  311. dbgprintf("ACPI: Reset Register @ IO 0x%x\n", m_reset_reg.address);
  312. dbgprintf("ACPI: Reset Register Address space %x\n", fadt.reset_reg.address_space);
  313. #endif
  314. m_reset_value = fadt.reset_value;
  315. #ifdef ACPI_DEBUG
  316. dbgprintf("ACPI: Reset Register value @ P 0x%x\n", m_reset_value);
  317. #endif
  318. m_x_pm1a_evt_blk = fadt.x_pm1a_evt_blk;
  319. m_x_pm1b_evt_blk = fadt.x_pm1b_evt_blk;
  320. m_x_pm1a_cnt_blk = fadt.x_pm1a_cnt_blk;
  321. m_x_pm1b_cnt_blk = fadt.x_pm1b_cnt_blk;
  322. m_x_pm2_cnt_blk = fadt.x_pm2_cnt_blk;
  323. m_x_pm_tmr_blk = fadt.x_pm_tmr_blk;
  324. m_x_gpe0_blk = fadt.x_gpe0_blk;
  325. m_x_gpe1_blk = fadt.x_gpe1_blk;
  326. m_sleep_control = fadt.sleep_control;
  327. m_sleep_status = fadt.sleep_status;
  328. m_hypervisor_vendor_identity = fadt.hypervisor_vendor_identity;
  329. }
  330. ACPI_RAW::SDTHeader* ACPI::FixedACPIData::get_dsdt()
  331. {
  332. if (m_x_dsdt_ptr != (u32) nullptr)
  333. return (ACPI_RAW::SDTHeader*)m_x_dsdt_ptr;
  334. else {
  335. ASSERT((ACPI_RAW::SDTHeader*)m_dsdt_ptr != nullptr);
  336. return (ACPI_RAW::SDTHeader*)m_dsdt_ptr;
  337. }
  338. }