LXR uboot/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 <sjg@chromium.org>
   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 */
  34struct testacpi_plat {
  35        bool return_error;
  36        bool no_name;
  37};
  38
  39static 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
  55static 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
  71static 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
  84static 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
  97struct 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
 104static const struct udevice_id testacpi_ids[] = {
 105        { .compatible = "denx,u-boot-acpi-test" },
 106        { }
 107};
 108
 109U_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
 118UCLASS_DRIVER(testacpi) = {
 119        .name           = "testacpi",
 120        .id             = UCLASS_TEST_ACPI,
 121};
 122
 123/* Test ACPI get_name() */
 124static 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}
 171DM_TEST(dm_test_acpi_get_name, UT_TESTF_SCAN_PDATA | UT_TESTF_SCAN_FDT);
 172
 173/* Test acpi_get_table_revision() */
 174static 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}
 183DM_TEST(dm_test_acpi_get_table_revision,
 184        UT_TESTF_SCAN_PDATA | UT_TESTF_SCAN_FDT);
 185
 186/* Test acpi_create_dmar() */
 187static 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}
 200DM_TEST(dm_test_acpi_create_dmar, UT_TESTF_SCAN_PDATA | UT_TESTF_SCAN_FDT);
 201
 202/* Test acpi_fill_header() */
 203static 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}
 227DM_TEST(dm_test_acpi_fill_header, UT_TESTF_SCAN_PDATA | UT_TESTF_SCAN_FDT);
 228
 229/* Test ACPI write_tables() */
 230static 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}
 268DM_TEST(dm_test_acpi_write_tables, UT_TESTF_SCAN_PDATA | UT_TESTF_SCAN_FDT);
 269
 270/* Test basic ACPI functions */
 271static 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}
 296DM_TEST(dm_test_acpi_basic, UT_TESTF_SCAN_PDATA | UT_TESTF_SCAN_FDT);
 297
 298/* Test acpi_setup_base_tables */
 299static 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}
 343DM_TEST(dm_test_acpi_setup_base_tables,
 344        UT_TESTF_SCAN_PDATA | UT_TESTF_SCAN_FDT);
 345
 346/* Test 'acpi list' command */
 347static 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 %06zx (v02 U-BOOT)", addr,
 364                           sizeof(struct acpi_rsdp));
 365        addr = ALIGN(addr + sizeof(struct acpi_rsdp), 16);
 366        ut_assert_nextline("RSDT %08lx %06zx (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 %06zx (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 %06zx (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 %06zx (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 %06zx (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}
 386DM_TEST(dm_test_acpi_cmd_list, UT_TESTF_SCAN_PDATA | UT_TESTF_SCAN_FDT);
 387
 388/* Test 'acpi dump' command */
 389static 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}
 417DM_TEST(dm_test_acpi_cmd_dump, UT_TESTF_SCAN_PDATA | UT_TESTF_SCAN_FDT);
 418
 419/* Test acpi_device_path() */
 420static 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}
 454DM_TEST(dm_test_acpi_device_path, UT_TESTF_SCAN_PDATA | UT_TESTF_SCAN_FDT);
 455
 456/* Test acpi_device_status() */
 457static 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}
 466DM_TEST(dm_test_acpi_device_status, UT_TESTF_SCAN_PDATA | UT_TESTF_SCAN_FDT);
 467
 468/* Test acpi_fill_ssdt() */
 469static 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}
 497DM_TEST(dm_test_acpi_fill_ssdt, UT_TESTF_SCAN_PDATA | UT_TESTF_SCAN_FDT);
 498
 499/* Test acpi_inject_dsdt() */
 500static 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}
 528DM_TEST(dm_test_acpi_inject_dsdt, UT_TESTF_SCAN_PDATA | UT_TESTF_SCAN_FDT);
 529
 530/* Test 'acpi items' command */
 531static 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}
 569DM_TEST(dm_test_acpi_cmd_items, UT_TESTF_SCAN_PDATA | UT_TESTF_SCAN_FDT);
 570