test/dm/acpi.c

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