acpi.c 16 KB

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