acpi.c 8.8 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317
  1. // SPDX-License-Identifier: GPL-2.0+
  2. /*
  3. * Tests for ACPI table generation
  4. *
  5. * Copyright 2019 Google LLC
  6. * Written by Simon Glass <sjg@chromium.org>
  7. */
  8. #include <common.h>
  9. #include <console.h>
  10. #include <dm.h>
  11. #include <malloc.h>
  12. #include <mapmem.h>
  13. #include <version.h>
  14. #include <tables_csum.h>
  15. #include <version.h>
  16. #include <acpi/acpi_table.h>
  17. #include <dm/acpi.h>
  18. #include <dm/test.h>
  19. #include <test/ut.h>
  20. #define ACPI_TEST_DEV_NAME "ABCD"
  21. #define BUF_SIZE 4096
  22. static int testacpi_write_tables(const struct udevice *dev,
  23. struct acpi_ctx *ctx)
  24. {
  25. struct acpi_dmar *dmar;
  26. int ret;
  27. dmar = (struct acpi_dmar *)ctx->current;
  28. acpi_create_dmar(dmar, DMAR_INTR_REMAP);
  29. ctx->current += sizeof(struct acpi_dmar);
  30. ret = acpi_add_table(ctx, dmar);
  31. if (ret)
  32. return log_msg_ret("add", ret);
  33. return 0;
  34. }
  35. static int testacpi_get_name(const struct udevice *dev, char *out_name)
  36. {
  37. return acpi_copy_name(out_name, ACPI_TEST_DEV_NAME);
  38. }
  39. struct acpi_ops testacpi_ops = {
  40. .get_name = testacpi_get_name,
  41. .write_tables = testacpi_write_tables,
  42. };
  43. static const struct udevice_id testacpi_ids[] = {
  44. { .compatible = "denx,u-boot-acpi-test" },
  45. { }
  46. };
  47. U_BOOT_DRIVER(testacpi_drv) = {
  48. .name = "testacpi_drv",
  49. .of_match = testacpi_ids,
  50. .id = UCLASS_TEST_ACPI,
  51. ACPI_OPS_PTR(&testacpi_ops)
  52. };
  53. UCLASS_DRIVER(testacpi) = {
  54. .name = "testacpi",
  55. .id = UCLASS_TEST_ACPI,
  56. };
  57. /* Test ACPI get_name() */
  58. static int dm_test_acpi_get_name(struct unit_test_state *uts)
  59. {
  60. char name[ACPI_NAME_MAX];
  61. struct udevice *dev;
  62. ut_assertok(uclass_first_device_err(UCLASS_TEST_ACPI, &dev));
  63. ut_assertok(acpi_get_name(dev, name));
  64. ut_asserteq_str(ACPI_TEST_DEV_NAME, name);
  65. return 0;
  66. }
  67. DM_TEST(dm_test_acpi_get_name, DM_TESTF_SCAN_PDATA | DM_TESTF_SCAN_FDT);
  68. /* Test acpi_get_table_revision() */
  69. static int dm_test_acpi_get_table_revision(struct unit_test_state *uts)
  70. {
  71. ut_asserteq(1, acpi_get_table_revision(ACPITAB_MCFG));
  72. ut_asserteq(2, acpi_get_table_revision(ACPITAB_RSDP));
  73. ut_asserteq(4, acpi_get_table_revision(ACPITAB_TPM2));
  74. ut_asserteq(-EINVAL, acpi_get_table_revision(ACPITAB_COUNT));
  75. return 0;
  76. }
  77. DM_TEST(dm_test_acpi_get_table_revision,
  78. DM_TESTF_SCAN_PDATA | DM_TESTF_SCAN_FDT);
  79. /* Test acpi_create_dmar() */
  80. static int dm_test_acpi_create_dmar(struct unit_test_state *uts)
  81. {
  82. struct acpi_dmar dmar;
  83. ut_assertok(acpi_create_dmar(&dmar, DMAR_INTR_REMAP));
  84. ut_asserteq(DMAR_INTR_REMAP, dmar.flags);
  85. ut_asserteq(32 - 1, dmar.host_address_width);
  86. return 0;
  87. }
  88. DM_TEST(dm_test_acpi_create_dmar, DM_TESTF_SCAN_PDATA | DM_TESTF_SCAN_FDT);
  89. /* Test acpi_fill_header() */
  90. static int dm_test_acpi_fill_header(struct unit_test_state *uts)
  91. {
  92. struct acpi_table_header hdr;
  93. /* Make sure these 5 fields are not changed */
  94. hdr.length = 0x11;
  95. hdr.revision = 0x22;
  96. hdr.checksum = 0x33;
  97. hdr.aslc_revision = 0x44;
  98. acpi_fill_header(&hdr, "ABCD");
  99. ut_asserteq_mem("ABCD", hdr.signature, sizeof(hdr.signature));
  100. ut_asserteq(0x11, hdr.length);
  101. ut_asserteq(0x22, hdr.revision);
  102. ut_asserteq(0x33, hdr.checksum);
  103. ut_asserteq_mem(OEM_ID, hdr.oem_id, sizeof(hdr.oem_id));
  104. ut_asserteq_mem(OEM_TABLE_ID, hdr.oem_table_id,
  105. sizeof(hdr.oem_table_id));
  106. ut_asserteq(U_BOOT_BUILD_DATE, hdr.oem_revision);
  107. ut_asserteq_mem(ASLC_ID, hdr.aslc_id, sizeof(hdr.aslc_id));
  108. ut_asserteq(0x44, hdr.aslc_revision);
  109. return 0;
  110. }
  111. DM_TEST(dm_test_acpi_fill_header, DM_TESTF_SCAN_PDATA | DM_TESTF_SCAN_FDT);
  112. /* Test ACPI write_tables() */
  113. static int dm_test_acpi_write_tables(struct unit_test_state *uts)
  114. {
  115. struct acpi_dmar *dmar;
  116. struct acpi_ctx ctx;
  117. void *buf;
  118. buf = malloc(BUF_SIZE);
  119. ut_assertnonnull(buf);
  120. acpi_setup_base_tables(&ctx, buf);
  121. dmar = ctx.current;
  122. ut_assertok(acpi_write_dev_tables(&ctx));
  123. /*
  124. * We should have two dmar tables, one for each "denx,u-boot-acpi-test"
  125. * device
  126. */
  127. ut_asserteq_ptr(dmar + 2, ctx.current);
  128. ut_asserteq(DMAR_INTR_REMAP, dmar->flags);
  129. ut_asserteq(32 - 1, dmar->host_address_width);
  130. ut_asserteq(DMAR_INTR_REMAP, dmar[1].flags);
  131. ut_asserteq(32 - 1, dmar[1].host_address_width);
  132. /* Check that the pointers were added correctly */
  133. ut_asserteq(map_to_sysmem(dmar), ctx.rsdt->entry[0]);
  134. ut_asserteq(map_to_sysmem(dmar + 1), ctx.rsdt->entry[1]);
  135. ut_asserteq(0, ctx.rsdt->entry[2]);
  136. ut_asserteq(map_to_sysmem(dmar), ctx.xsdt->entry[0]);
  137. ut_asserteq(map_to_sysmem(dmar + 1), ctx.xsdt->entry[1]);
  138. ut_asserteq(0, ctx.xsdt->entry[2]);
  139. return 0;
  140. }
  141. DM_TEST(dm_test_acpi_write_tables, DM_TESTF_SCAN_PDATA | DM_TESTF_SCAN_FDT);
  142. /* Test basic ACPI functions */
  143. static int dm_test_acpi_basic(struct unit_test_state *uts)
  144. {
  145. struct acpi_ctx ctx;
  146. /* Check align works */
  147. ctx.current = (void *)5;
  148. acpi_align(&ctx);
  149. ut_asserteq_ptr((void *)16, ctx.current);
  150. /* Check that align does nothing if already aligned */
  151. acpi_align(&ctx);
  152. ut_asserteq_ptr((void *)16, ctx.current);
  153. acpi_align64(&ctx);
  154. ut_asserteq_ptr((void *)64, ctx.current);
  155. acpi_align64(&ctx);
  156. ut_asserteq_ptr((void *)64, ctx.current);
  157. /* Check incrementing */
  158. acpi_inc(&ctx, 3);
  159. ut_asserteq_ptr((void *)67, ctx.current);
  160. acpi_inc_align(&ctx, 3);
  161. ut_asserteq_ptr((void *)80, ctx.current);
  162. return 0;
  163. }
  164. DM_TEST(dm_test_acpi_basic, DM_TESTF_SCAN_PDATA | DM_TESTF_SCAN_FDT);
  165. /* Test acpi_setup_base_tables */
  166. static int dm_test_acpi_setup_base_tables(struct unit_test_state *uts)
  167. {
  168. struct acpi_rsdp *rsdp;
  169. struct acpi_rsdt *rsdt;
  170. struct acpi_xsdt *xsdt;
  171. struct acpi_ctx ctx;
  172. void *buf, *end;
  173. /*
  174. * Use an unaligned address deliberately, by allocating an aligned
  175. * address and then adding 4 to it
  176. */
  177. buf = memalign(64, BUF_SIZE);
  178. ut_assertnonnull(buf);
  179. acpi_setup_base_tables(&ctx, buf + 4);
  180. ut_asserteq(map_to_sysmem(PTR_ALIGN(buf + 4, 16)), gd->arch.acpi_start);
  181. rsdp = buf + 16;
  182. ut_asserteq_ptr(rsdp, ctx.rsdp);
  183. ut_asserteq_mem(RSDP_SIG, rsdp->signature, sizeof(rsdp->signature));
  184. ut_asserteq(sizeof(*rsdp), rsdp->length);
  185. ut_assertok(table_compute_checksum(rsdp, 20));
  186. ut_assertok(table_compute_checksum(rsdp, sizeof(*rsdp)));
  187. rsdt = PTR_ALIGN((void *)rsdp + sizeof(*rsdp), 16);
  188. ut_asserteq_ptr(rsdt, ctx.rsdt);
  189. ut_asserteq_mem("RSDT", rsdt->header.signature, ACPI_NAME_LEN);
  190. ut_asserteq(sizeof(*rsdt), rsdt->header.length);
  191. ut_assertok(table_compute_checksum(rsdt, sizeof(*rsdt)));
  192. xsdt = PTR_ALIGN((void *)rsdt + sizeof(*rsdt), 16);
  193. ut_asserteq_ptr(xsdt, ctx.xsdt);
  194. ut_asserteq_mem("XSDT", xsdt->header.signature, ACPI_NAME_LEN);
  195. ut_asserteq(sizeof(*xsdt), xsdt->header.length);
  196. ut_assertok(table_compute_checksum(xsdt, sizeof(*xsdt)));
  197. end = PTR_ALIGN((void *)xsdt + sizeof(*xsdt), 64);
  198. ut_asserteq_ptr(end, ctx.current);
  199. ut_asserteq(map_to_sysmem(rsdt), rsdp->rsdt_address);
  200. ut_asserteq(map_to_sysmem(xsdt), rsdp->xsdt_address);
  201. return 0;
  202. }
  203. DM_TEST(dm_test_acpi_setup_base_tables,
  204. DM_TESTF_SCAN_PDATA | DM_TESTF_SCAN_FDT);
  205. /* Test 'acpi list' command */
  206. static int dm_test_acpi_cmd_list(struct unit_test_state *uts)
  207. {
  208. struct acpi_ctx ctx;
  209. ulong addr;
  210. void *buf;
  211. buf = memalign(16, BUF_SIZE);
  212. ut_assertnonnull(buf);
  213. acpi_setup_base_tables(&ctx, buf);
  214. ut_assertok(acpi_write_dev_tables(&ctx));
  215. console_record_reset();
  216. run_command("acpi list", 0);
  217. addr = (ulong)map_to_sysmem(buf);
  218. ut_assert_nextline("ACPI tables start at %lx", addr);
  219. ut_assert_nextline("RSDP %08lx %06lx (v02 U-BOOT)", addr,
  220. sizeof(struct acpi_rsdp));
  221. addr = ALIGN(addr + sizeof(struct acpi_rsdp), 16);
  222. ut_assert_nextline("RSDT %08lx %06lx (v01 U-BOOT U-BOOTBL %u INTL 0)",
  223. addr, sizeof(struct acpi_table_header) +
  224. 2 * sizeof(u32), U_BOOT_BUILD_DATE);
  225. addr = ALIGN(addr + sizeof(struct acpi_rsdt), 16);
  226. ut_assert_nextline("XSDT %08lx %06lx (v01 U-BOOT U-BOOTBL %u INTL 0)",
  227. addr, sizeof(struct acpi_table_header) +
  228. 2 * sizeof(u64), U_BOOT_BUILD_DATE);
  229. addr = ALIGN(addr + sizeof(struct acpi_xsdt), 64);
  230. ut_assert_nextline("DMAR %08lx %06lx (v01 U-BOOT U-BOOTBL %u INTL 0)",
  231. addr, sizeof(struct acpi_dmar), U_BOOT_BUILD_DATE);
  232. addr = ALIGN(addr + sizeof(struct acpi_dmar), 16);
  233. ut_assert_nextline("DMAR %08lx %06lx (v01 U-BOOT U-BOOTBL %u INTL 0)",
  234. addr, sizeof(struct acpi_dmar), U_BOOT_BUILD_DATE);
  235. ut_assert_console_end();
  236. return 0;
  237. }
  238. DM_TEST(dm_test_acpi_cmd_list, DM_TESTF_SCAN_PDATA | DM_TESTF_SCAN_FDT);
  239. /* Test 'acpi dump' command */
  240. static int dm_test_acpi_cmd_dump(struct unit_test_state *uts)
  241. {
  242. struct acpi_ctx ctx;
  243. ulong addr;
  244. void *buf;
  245. buf = memalign(16, BUF_SIZE);
  246. ut_assertnonnull(buf);
  247. acpi_setup_base_tables(&ctx, buf);
  248. ut_assertok(acpi_write_dev_tables(&ctx));
  249. /* First search for a non-existent table */
  250. console_record_reset();
  251. run_command("acpi dump rdst", 0);
  252. ut_assert_nextline("Table 'RDST' not found");
  253. ut_assert_console_end();
  254. /* Now a real table */
  255. console_record_reset();
  256. run_command("acpi dump dmar", 0);
  257. addr = ALIGN(map_to_sysmem(ctx.xsdt) + sizeof(struct acpi_xsdt), 64);
  258. ut_assert_nextline("DMAR @ %08lx", addr);
  259. ut_assert_nextlines_are_dump(0x30);
  260. ut_assert_console_end();
  261. return 0;
  262. }
  263. DM_TEST(dm_test_acpi_cmd_dump, DM_TESTF_SCAN_PDATA | DM_TESTF_SCAN_FDT);