acpi.c 16 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452453454455456457458459460461462463464465466467468469470471472473474475476477478479480481482483484485486487488489490491492493494495496497498499500501502503504505506507508509510511512513514515516517518519520521522523524525526527528529530531532533534535536537538539540541542543544545546547548549550551552553554555556557558559560561562563564565566567568569
  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/acpigen.h>
  17. #include <acpi/acpi_device.h>
  18. #include <acpi/acpi_table.h>
  19. #include <asm/global_data.h>
  20. #include <dm/acpi.h>
  21. #include <dm/test.h>
  22. #include <test/ut.h>
  23. #include "acpi.h"
  24. #define BUF_SIZE 4096
  25. /**
  26. * struct testacpi_plat - Platform data for the test ACPI device
  27. *
  28. * @no_name: true to emit an empty ACPI name from testacpi_get_name()
  29. * @return_error: true to return an error instead of a name
  30. */
  31. struct testacpi_plat {
  32. bool return_error;
  33. bool no_name;
  34. };
  35. static int testacpi_write_tables(const struct udevice *dev,
  36. struct acpi_ctx *ctx)
  37. {
  38. struct acpi_dmar *dmar;
  39. int ret;
  40. dmar = (struct acpi_dmar *)ctx->current;
  41. acpi_create_dmar(dmar, DMAR_INTR_REMAP);
  42. ctx->current += sizeof(struct acpi_dmar);
  43. ret = acpi_add_table(ctx, dmar);
  44. if (ret)
  45. return log_msg_ret("add", ret);
  46. return 0;
  47. }
  48. static int testacpi_get_name(const struct udevice *dev, char *out_name)
  49. {
  50. struct testacpi_plat *plat = dev_get_plat(dev);
  51. if (plat->return_error)
  52. return -EINVAL;
  53. if (plat->no_name) {
  54. *out_name = '\0';
  55. return 0;
  56. }
  57. if (device_get_uclass_id(dev->parent) == UCLASS_TEST_ACPI)
  58. return acpi_copy_name(out_name, ACPI_TEST_CHILD_NAME);
  59. else
  60. return acpi_copy_name(out_name, ACPI_TEST_DEV_NAME);
  61. }
  62. static int testacpi_fill_ssdt(const struct udevice *dev, struct acpi_ctx *ctx)
  63. {
  64. const char *data;
  65. data = dev_read_string(dev, "acpi-ssdt-test-data");
  66. if (data) {
  67. while (*data)
  68. acpigen_emit_byte(ctx, *data++);
  69. }
  70. return 0;
  71. }
  72. static int testacpi_inject_dsdt(const struct udevice *dev, struct acpi_ctx *ctx)
  73. {
  74. const char *data;
  75. data = dev_read_string(dev, "acpi-dsdt-test-data");
  76. if (data) {
  77. while (*data)
  78. acpigen_emit_byte(ctx, *data++);
  79. }
  80. return 0;
  81. }
  82. struct acpi_ops testacpi_ops = {
  83. .get_name = testacpi_get_name,
  84. .write_tables = testacpi_write_tables,
  85. .fill_ssdt = testacpi_fill_ssdt,
  86. .inject_dsdt = testacpi_inject_dsdt,
  87. };
  88. static const struct udevice_id testacpi_ids[] = {
  89. { .compatible = "denx,u-boot-acpi-test" },
  90. { }
  91. };
  92. U_BOOT_DRIVER(testacpi_drv) = {
  93. .name = "testacpi_drv",
  94. .of_match = testacpi_ids,
  95. .id = UCLASS_TEST_ACPI,
  96. .bind = dm_scan_fdt_dev,
  97. .plat_auto = sizeof(struct testacpi_plat),
  98. ACPI_OPS_PTR(&testacpi_ops)
  99. };
  100. UCLASS_DRIVER(testacpi) = {
  101. .name = "testacpi",
  102. .id = UCLASS_TEST_ACPI,
  103. };
  104. /* Test ACPI get_name() */
  105. static int dm_test_acpi_get_name(struct unit_test_state *uts)
  106. {
  107. char name[ACPI_NAME_MAX];
  108. struct udevice *dev, *dev2, *i2c, *spi, *timer, *sound;
  109. struct udevice *pci, *root;
  110. /* Test getting the name from the driver */
  111. ut_assertok(uclass_first_device_err(UCLASS_TEST_ACPI, &dev));
  112. ut_assertok(acpi_get_name(dev, name));
  113. ut_asserteq_str(ACPI_TEST_DEV_NAME, name);
  114. /* Test getting the name from the device tree */
  115. ut_assertok(uclass_get_device_by_name(UCLASS_TEST_FDT, "a-test",
  116. &dev2));
  117. ut_assertok(acpi_get_name(dev2, name));
  118. ut_asserteq_str("GHIJ", name);
  119. /* Test getting the name from acpi_device_get_name() */
  120. ut_assertok(uclass_first_device(UCLASS_I2C, &i2c));
  121. ut_assertok(acpi_get_name(i2c, name));
  122. ut_asserteq_str("I2C0", name);
  123. ut_assertok(uclass_first_device(UCLASS_SPI, &spi));
  124. ut_assertok(acpi_get_name(spi, name));
  125. ut_asserteq_str("SPI0", name);
  126. /* ACPI doesn't know about the timer */
  127. ut_assertok(uclass_first_device(UCLASS_TIMER, &timer));
  128. ut_asserteq(-ENOENT, acpi_get_name(timer, name));
  129. /* May as well test the rest of the cases */
  130. ut_assertok(uclass_first_device(UCLASS_SOUND, &sound));
  131. ut_assertok(acpi_get_name(sound, name));
  132. ut_asserteq_str("HDAS", name);
  133. ut_assertok(uclass_first_device(UCLASS_PCI, &pci));
  134. ut_assertok(acpi_get_name(pci, name));
  135. ut_asserteq_str("PCI0", name);
  136. ut_assertok(uclass_first_device(UCLASS_ROOT, &root));
  137. ut_assertok(acpi_get_name(root, name));
  138. ut_asserteq_str("\\_SB", name);
  139. /* Note that we don't have tests for acpi_name_from_id() */
  140. return 0;
  141. }
  142. DM_TEST(dm_test_acpi_get_name, UT_TESTF_SCAN_PDATA | UT_TESTF_SCAN_FDT);
  143. /* Test acpi_get_table_revision() */
  144. static int dm_test_acpi_get_table_revision(struct unit_test_state *uts)
  145. {
  146. ut_asserteq(1, acpi_get_table_revision(ACPITAB_MCFG));
  147. ut_asserteq(2, acpi_get_table_revision(ACPITAB_RSDP));
  148. ut_asserteq(4, acpi_get_table_revision(ACPITAB_TPM2));
  149. ut_asserteq(-EINVAL, acpi_get_table_revision(ACPITAB_COUNT));
  150. return 0;
  151. }
  152. DM_TEST(dm_test_acpi_get_table_revision,
  153. UT_TESTF_SCAN_PDATA | UT_TESTF_SCAN_FDT);
  154. /* Test acpi_create_dmar() */
  155. static int dm_test_acpi_create_dmar(struct unit_test_state *uts)
  156. {
  157. struct acpi_dmar dmar;
  158. struct udevice *cpu;
  159. ut_assertok(uclass_first_device(UCLASS_CPU, &cpu));
  160. ut_assertnonnull(cpu);
  161. ut_assertok(acpi_create_dmar(&dmar, DMAR_INTR_REMAP));
  162. ut_asserteq(DMAR_INTR_REMAP, dmar.flags);
  163. ut_asserteq(32 - 1, dmar.host_address_width);
  164. return 0;
  165. }
  166. DM_TEST(dm_test_acpi_create_dmar, UT_TESTF_SCAN_PDATA | UT_TESTF_SCAN_FDT);
  167. /* Test acpi_fill_header() */
  168. static int dm_test_acpi_fill_header(struct unit_test_state *uts)
  169. {
  170. struct acpi_table_header hdr;
  171. /* Make sure these 5 fields are not changed */
  172. hdr.length = 0x11;
  173. hdr.revision = 0x22;
  174. hdr.checksum = 0x33;
  175. hdr.aslc_revision = 0x44;
  176. acpi_fill_header(&hdr, "ABCD");
  177. ut_asserteq_mem("ABCD", hdr.signature, sizeof(hdr.signature));
  178. ut_asserteq(0x11, hdr.length);
  179. ut_asserteq(0x22, hdr.revision);
  180. ut_asserteq(0x33, hdr.checksum);
  181. ut_asserteq_mem(OEM_ID, hdr.oem_id, sizeof(hdr.oem_id));
  182. ut_asserteq_mem(OEM_TABLE_ID, hdr.oem_table_id,
  183. sizeof(hdr.oem_table_id));
  184. ut_asserteq(U_BOOT_BUILD_DATE, hdr.oem_revision);
  185. ut_asserteq_mem(ASLC_ID, hdr.aslc_id, sizeof(hdr.aslc_id));
  186. ut_asserteq(0x44, hdr.aslc_revision);
  187. return 0;
  188. }
  189. DM_TEST(dm_test_acpi_fill_header, UT_TESTF_SCAN_PDATA | UT_TESTF_SCAN_FDT);
  190. /* Test ACPI write_tables() */
  191. static int dm_test_acpi_write_tables(struct unit_test_state *uts)
  192. {
  193. struct acpi_dmar *dmar;
  194. struct acpi_ctx ctx;
  195. void *buf;
  196. int i;
  197. buf = malloc(BUF_SIZE);
  198. ut_assertnonnull(buf);
  199. acpi_setup_base_tables(&ctx, buf);
  200. dmar = ctx.current;
  201. ut_assertok(acpi_write_dev_tables(&ctx));
  202. /*
  203. * We should have three dmar tables, one for each
  204. * "denx,u-boot-acpi-test" device
  205. */
  206. ut_asserteq_ptr(dmar + 3, ctx.current);
  207. ut_asserteq(DMAR_INTR_REMAP, dmar->flags);
  208. ut_asserteq(32 - 1, dmar->host_address_width);
  209. ut_asserteq(DMAR_INTR_REMAP, dmar[1].flags);
  210. ut_asserteq(32 - 1, dmar[1].host_address_width);
  211. ut_asserteq(DMAR_INTR_REMAP, dmar[2].flags);
  212. ut_asserteq(32 - 1, dmar[2].host_address_width);
  213. /* Check that the pointers were added correctly */
  214. for (i = 0; i < 3; i++) {
  215. ut_asserteq(map_to_sysmem(dmar + i), ctx.rsdt->entry[i]);
  216. ut_asserteq(map_to_sysmem(dmar + i), ctx.xsdt->entry[i]);
  217. }
  218. ut_asserteq(0, ctx.rsdt->entry[3]);
  219. ut_asserteq(0, ctx.xsdt->entry[3]);
  220. return 0;
  221. }
  222. DM_TEST(dm_test_acpi_write_tables, UT_TESTF_SCAN_PDATA | UT_TESTF_SCAN_FDT);
  223. /* Test basic ACPI functions */
  224. static int dm_test_acpi_basic(struct unit_test_state *uts)
  225. {
  226. struct acpi_ctx ctx;
  227. /* Check align works */
  228. ctx.current = (void *)5;
  229. acpi_align(&ctx);
  230. ut_asserteq_ptr((void *)16, ctx.current);
  231. /* Check that align does nothing if already aligned */
  232. acpi_align(&ctx);
  233. ut_asserteq_ptr((void *)16, ctx.current);
  234. acpi_align64(&ctx);
  235. ut_asserteq_ptr((void *)64, ctx.current);
  236. acpi_align64(&ctx);
  237. ut_asserteq_ptr((void *)64, ctx.current);
  238. /* Check incrementing */
  239. acpi_inc(&ctx, 3);
  240. ut_asserteq_ptr((void *)67, ctx.current);
  241. acpi_inc_align(&ctx, 3);
  242. ut_asserteq_ptr((void *)80, ctx.current);
  243. return 0;
  244. }
  245. DM_TEST(dm_test_acpi_basic, UT_TESTF_SCAN_PDATA | UT_TESTF_SCAN_FDT);
  246. /* Test acpi_setup_base_tables */
  247. static int dm_test_acpi_setup_base_tables(struct unit_test_state *uts)
  248. {
  249. struct acpi_rsdp *rsdp;
  250. struct acpi_rsdt *rsdt;
  251. struct acpi_xsdt *xsdt;
  252. struct acpi_ctx ctx;
  253. void *buf, *end;
  254. /*
  255. * Use an unaligned address deliberately, by allocating an aligned
  256. * address and then adding 4 to it
  257. */
  258. buf = memalign(64, BUF_SIZE);
  259. ut_assertnonnull(buf);
  260. acpi_setup_base_tables(&ctx, buf + 4);
  261. ut_asserteq(map_to_sysmem(PTR_ALIGN(buf + 4, 16)), gd->arch.acpi_start);
  262. rsdp = buf + 16;
  263. ut_asserteq_ptr(rsdp, ctx.rsdp);
  264. ut_asserteq_mem(RSDP_SIG, rsdp->signature, sizeof(rsdp->signature));
  265. ut_asserteq(sizeof(*rsdp), rsdp->length);
  266. ut_assertok(table_compute_checksum(rsdp, 20));
  267. ut_assertok(table_compute_checksum(rsdp, sizeof(*rsdp)));
  268. rsdt = PTR_ALIGN((void *)rsdp + sizeof(*rsdp), 16);
  269. ut_asserteq_ptr(rsdt, ctx.rsdt);
  270. ut_asserteq_mem("RSDT", rsdt->header.signature, ACPI_NAME_LEN);
  271. ut_asserteq(sizeof(*rsdt), rsdt->header.length);
  272. ut_assertok(table_compute_checksum(rsdt, sizeof(*rsdt)));
  273. xsdt = PTR_ALIGN((void *)rsdt + sizeof(*rsdt), 16);
  274. ut_asserteq_ptr(xsdt, ctx.xsdt);
  275. ut_asserteq_mem("XSDT", xsdt->header.signature, ACPI_NAME_LEN);
  276. ut_asserteq(sizeof(*xsdt), xsdt->header.length);
  277. ut_assertok(table_compute_checksum(xsdt, sizeof(*xsdt)));
  278. end = PTR_ALIGN((void *)xsdt + sizeof(*xsdt), 64);
  279. ut_asserteq_ptr(end, ctx.current);
  280. ut_asserteq(map_to_sysmem(rsdt), rsdp->rsdt_address);
  281. ut_asserteq(map_to_sysmem(xsdt), rsdp->xsdt_address);
  282. return 0;
  283. }
  284. DM_TEST(dm_test_acpi_setup_base_tables,
  285. UT_TESTF_SCAN_PDATA | UT_TESTF_SCAN_FDT);
  286. /* Test 'acpi list' command */
  287. static int dm_test_acpi_cmd_list(struct unit_test_state *uts)
  288. {
  289. struct acpi_ctx ctx;
  290. ulong addr;
  291. void *buf;
  292. buf = memalign(16, BUF_SIZE);
  293. ut_assertnonnull(buf);
  294. acpi_setup_base_tables(&ctx, buf);
  295. ut_assertok(acpi_write_dev_tables(&ctx));
  296. console_record_reset();
  297. run_command("acpi list", 0);
  298. addr = (ulong)map_to_sysmem(buf);
  299. ut_assert_nextline("ACPI tables start at %lx", addr);
  300. ut_assert_nextline("RSDP %08lx %06zx (v02 U-BOOT)", addr,
  301. sizeof(struct acpi_rsdp));
  302. addr = ALIGN(addr + sizeof(struct acpi_rsdp), 16);
  303. ut_assert_nextline("RSDT %08lx %06zx (v01 U-BOOT U-BOOTBL %x INTL 0)",
  304. addr, sizeof(struct acpi_table_header) +
  305. 3 * sizeof(u32), U_BOOT_BUILD_DATE);
  306. addr = ALIGN(addr + sizeof(struct acpi_rsdt), 16);
  307. ut_assert_nextline("XSDT %08lx %06zx (v01 U-BOOT U-BOOTBL %x INTL 0)",
  308. addr, sizeof(struct acpi_table_header) +
  309. 3 * sizeof(u64), U_BOOT_BUILD_DATE);
  310. addr = ALIGN(addr + sizeof(struct acpi_xsdt), 64);
  311. ut_assert_nextline("DMAR %08lx %06zx (v01 U-BOOT U-BOOTBL %x INTL 0)",
  312. addr, sizeof(struct acpi_dmar), U_BOOT_BUILD_DATE);
  313. addr = ALIGN(addr + sizeof(struct acpi_dmar), 16);
  314. ut_assert_nextline("DMAR %08lx %06zx (v01 U-BOOT U-BOOTBL %x INTL 0)",
  315. addr, sizeof(struct acpi_dmar), U_BOOT_BUILD_DATE);
  316. addr = ALIGN(addr + sizeof(struct acpi_dmar), 16);
  317. ut_assert_nextline("DMAR %08lx %06zx (v01 U-BOOT U-BOOTBL %x INTL 0)",
  318. addr, sizeof(struct acpi_dmar), U_BOOT_BUILD_DATE);
  319. ut_assert_console_end();
  320. return 0;
  321. }
  322. DM_TEST(dm_test_acpi_cmd_list, UT_TESTF_SCAN_PDATA | UT_TESTF_SCAN_FDT);
  323. /* Test 'acpi dump' command */
  324. static int dm_test_acpi_cmd_dump(struct unit_test_state *uts)
  325. {
  326. struct acpi_ctx ctx;
  327. ulong addr;
  328. void *buf;
  329. buf = memalign(16, BUF_SIZE);
  330. ut_assertnonnull(buf);
  331. acpi_setup_base_tables(&ctx, buf);
  332. ut_assertok(acpi_write_dev_tables(&ctx));
  333. /* First search for a non-existent table */
  334. console_record_reset();
  335. run_command("acpi dump rdst", 0);
  336. ut_assert_nextline("Table 'RDST' not found");
  337. ut_assert_console_end();
  338. /* Now a real table */
  339. console_record_reset();
  340. run_command("acpi dump dmar", 0);
  341. addr = ALIGN(map_to_sysmem(ctx.xsdt) + sizeof(struct acpi_xsdt), 64);
  342. ut_assert_nextline("DMAR @ %08lx", addr);
  343. ut_assert_nextlines_are_dump(0x30);
  344. ut_assert_console_end();
  345. return 0;
  346. }
  347. DM_TEST(dm_test_acpi_cmd_dump, UT_TESTF_SCAN_PDATA | UT_TESTF_SCAN_FDT);
  348. /* Test acpi_device_path() */
  349. static int dm_test_acpi_device_path(struct unit_test_state *uts)
  350. {
  351. struct testacpi_plat *plat;
  352. char buf[ACPI_PATH_MAX];
  353. struct udevice *dev, *child;
  354. ut_assertok(uclass_first_device_err(UCLASS_TEST_ACPI, &dev));
  355. ut_assertok(acpi_device_path(dev, buf, sizeof(buf)));
  356. ut_asserteq_str("\\_SB." ACPI_TEST_DEV_NAME, buf);
  357. /* Test running out of space */
  358. buf[5] = '\0';
  359. ut_asserteq(-ENOSPC, acpi_device_path(dev, buf, 5));
  360. ut_asserteq('\0', buf[5]);
  361. /* Test a three-component name */
  362. ut_assertok(device_first_child_err(dev, &child));
  363. ut_assertok(acpi_device_path(child, buf, sizeof(buf)));
  364. ut_asserteq_str("\\_SB." ACPI_TEST_DEV_NAME "." ACPI_TEST_CHILD_NAME,
  365. buf);
  366. /* Test handling of a device which doesn't produce a name */
  367. plat = dev_get_plat(dev);
  368. plat->no_name = true;
  369. ut_assertok(acpi_device_path(child, buf, sizeof(buf)));
  370. ut_asserteq_str("\\_SB." ACPI_TEST_CHILD_NAME, buf);
  371. /* Test handling of a device which returns an error */
  372. plat = dev_get_plat(dev);
  373. plat->return_error = true;
  374. ut_asserteq(-EINVAL, acpi_device_path(child, buf, sizeof(buf)));
  375. return 0;
  376. }
  377. DM_TEST(dm_test_acpi_device_path, UT_TESTF_SCAN_PDATA | UT_TESTF_SCAN_FDT);
  378. /* Test acpi_device_status() */
  379. static int dm_test_acpi_device_status(struct unit_test_state *uts)
  380. {
  381. struct udevice *dev;
  382. ut_assertok(uclass_first_device_err(UCLASS_TEST_ACPI, &dev));
  383. ut_asserteq(ACPI_DSTATUS_ALL_ON, acpi_device_status(dev));
  384. return 0;
  385. }
  386. DM_TEST(dm_test_acpi_device_status, UT_TESTF_SCAN_PDATA | UT_TESTF_SCAN_FDT);
  387. /* Test acpi_fill_ssdt() */
  388. static int dm_test_acpi_fill_ssdt(struct unit_test_state *uts)
  389. {
  390. struct acpi_ctx ctx;
  391. u8 *buf;
  392. buf = malloc(BUF_SIZE);
  393. ut_assertnonnull(buf);
  394. acpi_reset_items();
  395. ctx.current = buf;
  396. buf[4] = 'z'; /* sentinel */
  397. ut_assertok(acpi_fill_ssdt(&ctx));
  398. /*
  399. * These values come from acpi-test2's acpi-ssdt-test-data property.
  400. * This device comes first because of u-boot,acpi-ssdt-order
  401. */
  402. ut_asserteq('c', buf[0]);
  403. ut_asserteq('d', buf[1]);
  404. /* These values come from acpi-test's acpi-ssdt-test-data property */
  405. ut_asserteq('a', buf[2]);
  406. ut_asserteq('b', buf[3]);
  407. ut_asserteq('z', buf[4]);
  408. return 0;
  409. }
  410. DM_TEST(dm_test_acpi_fill_ssdt, UT_TESTF_SCAN_PDATA | UT_TESTF_SCAN_FDT);
  411. /* Test acpi_inject_dsdt() */
  412. static int dm_test_acpi_inject_dsdt(struct unit_test_state *uts)
  413. {
  414. struct acpi_ctx ctx;
  415. u8 *buf;
  416. buf = malloc(BUF_SIZE);
  417. ut_assertnonnull(buf);
  418. acpi_reset_items();
  419. ctx.current = buf;
  420. buf[4] = 'z'; /* sentinel */
  421. ut_assertok(acpi_inject_dsdt(&ctx));
  422. /*
  423. * These values come from acpi-test's acpi-dsdt-test-data property.
  424. * There is no u-boot,acpi-dsdt-order so device-tree order is used.
  425. */
  426. ut_asserteq('h', buf[0]);
  427. ut_asserteq('i', buf[1]);
  428. /* These values come from acpi-test's acpi-dsdt-test-data property */
  429. ut_asserteq('j', buf[2]);
  430. ut_asserteq('k', buf[3]);
  431. ut_asserteq('z', buf[4]);
  432. return 0;
  433. }
  434. DM_TEST(dm_test_acpi_inject_dsdt, UT_TESTF_SCAN_PDATA | UT_TESTF_SCAN_FDT);
  435. /* Test 'acpi items' command */
  436. static int dm_test_acpi_cmd_items(struct unit_test_state *uts)
  437. {
  438. struct acpi_ctx ctx;
  439. void *buf;
  440. buf = malloc(BUF_SIZE);
  441. ut_assertnonnull(buf);
  442. acpi_reset_items();
  443. ctx.current = buf;
  444. ut_assertok(acpi_fill_ssdt(&ctx));
  445. console_record_reset();
  446. run_command("acpi items", 0);
  447. ut_assert_nextline("dev 'acpi-test', type 1, size 2");
  448. ut_assert_nextline("dev 'acpi-test2', type 1, size 2");
  449. ut_assert_console_end();
  450. acpi_reset_items();
  451. ctx.current = buf;
  452. ut_assertok(acpi_inject_dsdt(&ctx));
  453. console_record_reset();
  454. run_command("acpi items", 0);
  455. ut_assert_nextline("dev 'acpi-test', type 2, size 2");
  456. ut_assert_nextline("dev 'acpi-test2', type 2, size 2");
  457. ut_assert_console_end();
  458. console_record_reset();
  459. run_command("acpi items -d", 0);
  460. ut_assert_nextline("dev 'acpi-test', type 2, size 2");
  461. ut_assert_nextlines_are_dump(2);
  462. ut_assert_nextline("%s", "");
  463. ut_assert_nextline("dev 'acpi-test2', type 2, size 2");
  464. ut_assert_nextlines_are_dump(2);
  465. ut_assert_nextline("%s", "");
  466. ut_assert_console_end();
  467. return 0;
  468. }
  469. DM_TEST(dm_test_acpi_cmd_items, UT_TESTF_SCAN_PDATA | UT_TESTF_SCAN_FDT);