[J-u-boot.git] / test / dm / acpi.c

// SPDX-License-Identifier: GPL-2.0+
/*
 * Tests for ACPI table generation
 *
 * Copyright 2019 Google LLC
 * Written by Simon Glass <[email protected]>
 */

#include <common.h>
#include <console.h>
#include <dm.h>
#include <malloc.h>
#include <mapmem.h>
#include <version.h>
#include <tables_csum.h>
#include <version.h>
#include <acpi/acpigen.h>
#include <acpi/acpi_device.h>
#include <acpi/acpi_table.h>
#include <asm/global_data.h>
#include <dm/acpi.h>
#include <dm/test.h>
#include <test/ut.h>
#include "acpi.h"

#define BUF_SIZE		4096

/**
 * struct testacpi_plat - Platform data for the test ACPI device
 *
 * @no_name: true to emit an empty ACPI name from testacpi_get_name()
 * @return_error: true to return an error instead of a name
 */
struct testacpi_plat {
	bool return_error;
	bool no_name;
};

static int testacpi_write_tables(const struct udevice *dev,
				 struct acpi_ctx *ctx)
{
	struct acpi_dmar *dmar;
	int ret;

	dmar = (struct acpi_dmar *)ctx->current;
	acpi_create_dmar(dmar, DMAR_INTR_REMAP);
	ctx->current += sizeof(struct acpi_dmar);
	ret = acpi_add_table(ctx, dmar);
	if (ret)
		return log_msg_ret("add", ret);

	return 0;
}

static int testacpi_get_name(const struct udevice *dev, char *out_name)
{
	struct testacpi_plat *plat = dev_get_plat(dev);

	if (plat->return_error)
		return -EINVAL;
	if (plat->no_name) {
		*out_name = '\0';
		return 0;
	}
	if (device_get_uclass_id(dev->parent) == UCLASS_TEST_ACPI)
		return acpi_copy_name(out_name, ACPI_TEST_CHILD_NAME);
	else
		return acpi_copy_name(out_name, ACPI_TEST_DEV_NAME);
}

static int testacpi_fill_ssdt(const struct udevice *dev, struct acpi_ctx *ctx)
{
	const char *data;

	data = dev_read_string(dev, "acpi-ssdt-test-data");
	if (data) {
		while (*data)
			acpigen_emit_byte(ctx, *data++);
	}

	return 0;
}

static int testacpi_inject_dsdt(const struct udevice *dev, struct acpi_ctx *ctx)
{
	const char *data;

	data = dev_read_string(dev, "acpi-dsdt-test-data");
	if (data) {
		while (*data)
			acpigen_emit_byte(ctx, *data++);
	}

	return 0;
}

struct acpi_ops testacpi_ops = {
	.get_name	= testacpi_get_name,
	.write_tables	= testacpi_write_tables,
	.fill_ssdt	= testacpi_fill_ssdt,
	.inject_dsdt	= testacpi_inject_dsdt,
};

static const struct udevice_id testacpi_ids[] = {
	{ .compatible = "denx,u-boot-acpi-test" },
	{ }
};

U_BOOT_DRIVER(testacpi_drv) = {
	.name	= "testacpi_drv",
	.of_match	= testacpi_ids,
	.id	= UCLASS_TEST_ACPI,
	.bind	= dm_scan_fdt_dev,
	.plat_auto	= sizeof(struct testacpi_plat),
	ACPI_OPS_PTR(&testacpi_ops)
};

UCLASS_DRIVER(testacpi) = {
	.name		= "testacpi",
	.id		= UCLASS_TEST_ACPI,
};

/* Test ACPI get_name() */
static int dm_test_acpi_get_name(struct unit_test_state *uts)
{
	char name[ACPI_NAME_MAX];
	struct udevice *dev, *dev2, *i2c, *spi, *timer, *sound;
	struct udevice *pci, *root;

	/* Test getting the name from the driver */
	ut_assertok(uclass_first_device_err(UCLASS_TEST_ACPI, &dev));
	ut_assertok(acpi_get_name(dev, name));
	ut_asserteq_str(ACPI_TEST_DEV_NAME, name);

	/* Test getting the name from the device tree */
	ut_assertok(uclass_get_device_by_name(UCLASS_TEST_FDT, "a-test",
					      &dev2));
	ut_assertok(acpi_get_name(dev2, name));
	ut_asserteq_str("GHIJ", name);

	/* Test getting the name from acpi_device_get_name() */
	ut_assertok(uclass_first_device(UCLASS_I2C, &i2c));
	ut_assertok(acpi_get_name(i2c, name));
	ut_asserteq_str("I2C0", name);

	ut_assertok(uclass_first_device(UCLASS_SPI, &spi));
	ut_assertok(acpi_get_name(spi, name));
	ut_asserteq_str("SPI0", name);

	/* ACPI doesn't know about the timer */
	ut_assertok(uclass_first_device(UCLASS_TIMER, &timer));
	ut_asserteq(-ENOENT, acpi_get_name(timer, name));

	/* May as well test the rest of the cases */
	ut_assertok(uclass_first_device(UCLASS_SOUND, &sound));
	ut_assertok(acpi_get_name(sound, name));
	ut_asserteq_str("HDAS", name);

	ut_assertok(uclass_first_device(UCLASS_PCI, &pci));
	ut_assertok(acpi_get_name(pci, name));
	ut_asserteq_str("PCI0", name);

	ut_assertok(uclass_first_device(UCLASS_ROOT, &root));
	ut_assertok(acpi_get_name(root, name));
	ut_asserteq_str("\\_SB", name);

	/* Note that we don't have tests for acpi_name_from_id() */

	return 0;
}
DM_TEST(dm_test_acpi_get_name, UT_TESTF_SCAN_PDATA | UT_TESTF_SCAN_FDT);

/* Test acpi_get_table_revision() */
static int dm_test_acpi_get_table_revision(struct unit_test_state *uts)
{
	ut_asserteq(1, acpi_get_table_revision(ACPITAB_MCFG));
	ut_asserteq(2, acpi_get_table_revision(ACPITAB_RSDP));
	ut_asserteq(4, acpi_get_table_revision(ACPITAB_TPM2));
	ut_asserteq(-EINVAL, acpi_get_table_revision(ACPITAB_COUNT));

	return 0;
}
DM_TEST(dm_test_acpi_get_table_revision,
	UT_TESTF_SCAN_PDATA | UT_TESTF_SCAN_FDT);

/* Test acpi_create_dmar() */
static int dm_test_acpi_create_dmar(struct unit_test_state *uts)
{
	struct acpi_dmar dmar;
	struct udevice *cpu;

	ut_assertok(uclass_first_device(UCLASS_CPU, &cpu));
	ut_assertnonnull(cpu);
	ut_assertok(acpi_create_dmar(&dmar, DMAR_INTR_REMAP));
	ut_asserteq(DMAR_INTR_REMAP, dmar.flags);
	ut_asserteq(32 - 1, dmar.host_address_width);

	return 0;
}
DM_TEST(dm_test_acpi_create_dmar, UT_TESTF_SCAN_PDATA | UT_TESTF_SCAN_FDT);

/* Test acpi_fill_header() */
static int dm_test_acpi_fill_header(struct unit_test_state *uts)
{
	struct acpi_table_header hdr;

	/* Make sure these 5 fields are not changed */
	hdr.length = 0x11;
	hdr.revision = 0x22;
	hdr.checksum = 0x33;
	hdr.aslc_revision = 0x44;
	acpi_fill_header(&hdr, "ABCD");

	ut_asserteq_mem("ABCD", hdr.signature, sizeof(hdr.signature));
	ut_asserteq(0x11, hdr.length);
	ut_asserteq(0x22, hdr.revision);
	ut_asserteq(0x33, hdr.checksum);
	ut_asserteq_mem(OEM_ID, hdr.oem_id, sizeof(hdr.oem_id));
	ut_asserteq_mem(OEM_TABLE_ID, hdr.oem_table_id,
			sizeof(hdr.oem_table_id));
	ut_asserteq(U_BOOT_BUILD_DATE, hdr.oem_revision);
	ut_asserteq_mem(ASLC_ID, hdr.aslc_id, sizeof(hdr.aslc_id));
	ut_asserteq(0x44, hdr.aslc_revision);

	return 0;
}
DM_TEST(dm_test_acpi_fill_header, UT_TESTF_SCAN_PDATA | UT_TESTF_SCAN_FDT);

/* Test ACPI write_tables() */
static int dm_test_acpi_write_tables(struct unit_test_state *uts)
{
	struct acpi_dmar *dmar;
	struct acpi_ctx ctx;
	void *buf;
	int i;

	buf = malloc(BUF_SIZE);
	ut_assertnonnull(buf);

	acpi_setup_base_tables(&ctx, buf);
	dmar = ctx.current;
	ut_assertok(acpi_write_dev_tables(&ctx));

	/*
	 * We should have three dmar tables, one for each
	 * "denx,u-boot-acpi-test" device
	 */
	ut_asserteq_ptr(dmar + 3, ctx.current);
	ut_asserteq(DMAR_INTR_REMAP, dmar->flags);
	ut_asserteq(32 - 1, dmar->host_address_width);

	ut_asserteq(DMAR_INTR_REMAP, dmar[1].flags);
	ut_asserteq(32 - 1, dmar[1].host_address_width);

	ut_asserteq(DMAR_INTR_REMAP, dmar[2].flags);
	ut_asserteq(32 - 1, dmar[2].host_address_width);

	/* Check that the pointers were added correctly */
	for (i = 0; i < 3; i++) {
		ut_asserteq(map_to_sysmem(dmar + i), ctx.rsdt->entry[i]);
		ut_asserteq(map_to_sysmem(dmar + i), ctx.xsdt->entry[i]);
	}
	ut_asserteq(0, ctx.rsdt->entry[3]);
	ut_asserteq(0, ctx.xsdt->entry[3]);

	return 0;
}
DM_TEST(dm_test_acpi_write_tables, UT_TESTF_SCAN_PDATA | UT_TESTF_SCAN_FDT);

/* Test basic ACPI functions */
static int dm_test_acpi_basic(struct unit_test_state *uts)
{
	struct acpi_ctx ctx;

	/* Check align works */
	ctx.current = (void *)5;
	acpi_align(&ctx);
	ut_asserteq_ptr((void *)16, ctx.current);

	/* Check that align does nothing if already aligned */
	acpi_align(&ctx);
	ut_asserteq_ptr((void *)16, ctx.current);
	acpi_align64(&ctx);
	ut_asserteq_ptr((void *)64, ctx.current);
	acpi_align64(&ctx);
	ut_asserteq_ptr((void *)64, ctx.current);

	/* Check incrementing */
	acpi_inc(&ctx, 3);
	ut_asserteq_ptr((void *)67, ctx.current);
	acpi_inc_align(&ctx, 3);
	ut_asserteq_ptr((void *)80, ctx.current);

	return 0;
}
DM_TEST(dm_test_acpi_basic, UT_TESTF_SCAN_PDATA | UT_TESTF_SCAN_FDT);

/* Test acpi_setup_base_tables */
static int dm_test_acpi_setup_base_tables(struct unit_test_state *uts)
{
	struct acpi_rsdp *rsdp;
	struct acpi_rsdt *rsdt;
	struct acpi_xsdt *xsdt;
	struct acpi_ctx ctx;
	void *buf, *end;

	/*
	 * Use an unaligned address deliberately, by allocating an aligned
	 * address and then adding 4 to it
	 */
	buf = memalign(64, BUF_SIZE);
	ut_assertnonnull(buf);
	acpi_setup_base_tables(&ctx, buf + 4);
	ut_asserteq(map_to_sysmem(PTR_ALIGN(buf + 4, 16)), gd->arch.acpi_start);

	rsdp = buf + 16;
	ut_asserteq_ptr(rsdp, ctx.rsdp);
	ut_asserteq_mem(RSDP_SIG, rsdp->signature, sizeof(rsdp->signature));
	ut_asserteq(sizeof(*rsdp), rsdp->length);
	ut_assertok(table_compute_checksum(rsdp, 20));
	ut_assertok(table_compute_checksum(rsdp, sizeof(*rsdp)));

	rsdt = PTR_ALIGN((void *)rsdp + sizeof(*rsdp), 16);
	ut_asserteq_ptr(rsdt, ctx.rsdt);
	ut_asserteq_mem("RSDT", rsdt->header.signature, ACPI_NAME_LEN);
	ut_asserteq(sizeof(*rsdt), rsdt->header.length);
	ut_assertok(table_compute_checksum(rsdt, sizeof(*rsdt)));

	xsdt = PTR_ALIGN((void *)rsdt + sizeof(*rsdt), 16);
	ut_asserteq_ptr(xsdt, ctx.xsdt);
	ut_asserteq_mem("XSDT", xsdt->header.signature, ACPI_NAME_LEN);
	ut_asserteq(sizeof(*xsdt), xsdt->header.length);
	ut_assertok(table_compute_checksum(xsdt, sizeof(*xsdt)));

	end = PTR_ALIGN((void *)xsdt + sizeof(*xsdt), 64);
	ut_asserteq_ptr(end, ctx.current);

	ut_asserteq(map_to_sysmem(rsdt), rsdp->rsdt_address);
	ut_asserteq(map_to_sysmem(xsdt), rsdp->xsdt_address);

	return 0;
}
DM_TEST(dm_test_acpi_setup_base_tables,
	UT_TESTF_SCAN_PDATA | UT_TESTF_SCAN_FDT);

/* Test 'acpi list' command */
static int dm_test_acpi_cmd_list(struct unit_test_state *uts)
{
	struct acpi_ctx ctx;
	ulong addr;
	void *buf;

	buf = memalign(16, BUF_SIZE);
	ut_assertnonnull(buf);
	acpi_setup_base_tables(&ctx, buf);

	ut_assertok(acpi_write_dev_tables(&ctx));

	console_record_reset();
	run_command("acpi list", 0);
	addr = (ulong)map_to_sysmem(buf);
	ut_assert_nextline("ACPI tables start at %lx", addr);
	ut_assert_nextline("RSDP %08lx %06lx (v02 U-BOOT)", addr,
			   sizeof(struct acpi_rsdp));
	addr = ALIGN(addr + sizeof(struct acpi_rsdp), 16);
	ut_assert_nextline("RSDT %08lx %06lx (v01 U-BOOT U-BOOTBL %x INTL 0)",
			   addr, sizeof(struct acpi_table_header) +
			   3 * sizeof(u32), U_BOOT_BUILD_DATE);
	addr = ALIGN(addr + sizeof(struct acpi_rsdt), 16);
	ut_assert_nextline("XSDT %08lx %06lx (v01 U-BOOT U-BOOTBL %x INTL 0)",
			   addr, sizeof(struct acpi_table_header) +
			   3 * sizeof(u64), U_BOOT_BUILD_DATE);
	addr = ALIGN(addr + sizeof(struct acpi_xsdt), 64);
	ut_assert_nextline("DMAR %08lx %06lx (v01 U-BOOT U-BOOTBL %x INTL 0)",
			   addr, sizeof(struct acpi_dmar), U_BOOT_BUILD_DATE);
	addr = ALIGN(addr + sizeof(struct acpi_dmar), 16);
	ut_assert_nextline("DMAR %08lx %06lx (v01 U-BOOT U-BOOTBL %x INTL 0)",
			   addr, sizeof(struct acpi_dmar), U_BOOT_BUILD_DATE);
	addr = ALIGN(addr + sizeof(struct acpi_dmar), 16);
	ut_assert_nextline("DMAR %08lx %06lx (v01 U-BOOT U-BOOTBL %x INTL 0)",
			   addr, sizeof(struct acpi_dmar), U_BOOT_BUILD_DATE);
	ut_assert_console_end();

	return 0;
}
DM_TEST(dm_test_acpi_cmd_list, UT_TESTF_SCAN_PDATA | UT_TESTF_SCAN_FDT);

/* Test 'acpi dump' command */
static int dm_test_acpi_cmd_dump(struct unit_test_state *uts)
{
	struct acpi_ctx ctx;
	ulong addr;
	void *buf;

	buf = memalign(16, BUF_SIZE);
	ut_assertnonnull(buf);
	acpi_setup_base_tables(&ctx, buf);

	ut_assertok(acpi_write_dev_tables(&ctx));

	/* First search for a non-existent table */
	console_record_reset();
	run_command("acpi dump rdst", 0);
	ut_assert_nextline("Table 'RDST' not found");
	ut_assert_console_end();

	/* Now a real table */
	console_record_reset();
	run_command("acpi dump dmar", 0);
	addr = ALIGN(map_to_sysmem(ctx.xsdt) + sizeof(struct acpi_xsdt), 64);
	ut_assert_nextline("DMAR @ %08lx", addr);
	ut_assert_nextlines_are_dump(0x30);
	ut_assert_console_end();

	return 0;
}
DM_TEST(dm_test_acpi_cmd_dump, UT_TESTF_SCAN_PDATA | UT_TESTF_SCAN_FDT);

/* Test acpi_device_path() */
static int dm_test_acpi_device_path(struct unit_test_state *uts)
{
	struct testacpi_plat *plat;
	char buf[ACPI_PATH_MAX];
	struct udevice *dev, *child;

	ut_assertok(uclass_first_device_err(UCLASS_TEST_ACPI, &dev));
	ut_assertok(acpi_device_path(dev, buf, sizeof(buf)));
	ut_asserteq_str("\\_SB." ACPI_TEST_DEV_NAME, buf);

	/* Test running out of space */
	buf[5] = '\0';
	ut_asserteq(-ENOSPC, acpi_device_path(dev, buf, 5));
	ut_asserteq('\0', buf[5]);

	/* Test a three-component name */
	ut_assertok(device_first_child_err(dev, &child));
	ut_assertok(acpi_device_path(child, buf, sizeof(buf)));
	ut_asserteq_str("\\_SB." ACPI_TEST_DEV_NAME "." ACPI_TEST_CHILD_NAME,
			buf);

	/* Test handling of a device which doesn't produce a name */
	plat = dev_get_plat(dev);
	plat->no_name = true;
	ut_assertok(acpi_device_path(child, buf, sizeof(buf)));
	ut_asserteq_str("\\_SB." ACPI_TEST_CHILD_NAME, buf);

	/* Test handling of a device which returns an error */
	plat = dev_get_plat(dev);
	plat->return_error = true;
	ut_asserteq(-EINVAL, acpi_device_path(child, buf, sizeof(buf)));

	return 0;
}
DM_TEST(dm_test_acpi_device_path, UT_TESTF_SCAN_PDATA | UT_TESTF_SCAN_FDT);

/* Test acpi_device_status() */
static int dm_test_acpi_device_status(struct unit_test_state *uts)
{
	struct udevice *dev;

	ut_assertok(uclass_first_device_err(UCLASS_TEST_ACPI, &dev));
	ut_asserteq(ACPI_DSTATUS_ALL_ON, acpi_device_status(dev));

	return 0;
}
DM_TEST(dm_test_acpi_device_status, UT_TESTF_SCAN_PDATA | UT_TESTF_SCAN_FDT);

/* Test acpi_fill_ssdt() */
static int dm_test_acpi_fill_ssdt(struct unit_test_state *uts)
{
	struct acpi_ctx ctx;
	u8 *buf;

	buf = malloc(BUF_SIZE);
	ut_assertnonnull(buf);

	acpi_reset_items();
	ctx.current = buf;
	buf[4] = 'z';	/* sentinel */
	ut_assertok(acpi_fill_ssdt(&ctx));

	/*
	 * These values come from acpi-test2's acpi-ssdt-test-data property.
	 * This device comes first because of u-boot,acpi-ssdt-order
	 */
	ut_asserteq('c', buf[0]);
	ut_asserteq('d', buf[1]);

	/* These values come from acpi-test's acpi-ssdt-test-data property */
	ut_asserteq('a', buf[2]);
	ut_asserteq('b', buf[3]);

	ut_asserteq('z', buf[4]);

	return 0;
}
DM_TEST(dm_test_acpi_fill_ssdt, UT_TESTF_SCAN_PDATA | UT_TESTF_SCAN_FDT);

/* Test acpi_inject_dsdt() */
static int dm_test_acpi_inject_dsdt(struct unit_test_state *uts)
{
	struct acpi_ctx ctx;
	u8 *buf;

	buf = malloc(BUF_SIZE);
	ut_assertnonnull(buf);

	acpi_reset_items();
	ctx.current = buf;
	buf[4] = 'z';	/* sentinel */
	ut_assertok(acpi_inject_dsdt(&ctx));

	/*
	 * These values come from acpi-test's acpi-dsdt-test-data property.
	 * There is no u-boot,acpi-dsdt-order so device-tree order is used.
	 */
	ut_asserteq('h', buf[0]);
	ut_asserteq('i', buf[1]);

	/* These values come from acpi-test's acpi-dsdt-test-data property */
	ut_asserteq('j', buf[2]);
	ut_asserteq('k', buf[3]);

	ut_asserteq('z', buf[4]);

	return 0;
}
DM_TEST(dm_test_acpi_inject_dsdt, UT_TESTF_SCAN_PDATA | UT_TESTF_SCAN_FDT);

/* Test 'acpi items' command */
static int dm_test_acpi_cmd_items(struct unit_test_state *uts)
{
	struct acpi_ctx ctx;
	void *buf;

	buf = malloc(BUF_SIZE);
	ut_assertnonnull(buf);

	acpi_reset_items();
	ctx.current = buf;
	ut_assertok(acpi_fill_ssdt(&ctx));
	console_record_reset();
	run_command("acpi items", 0);
	ut_assert_nextline("dev 'acpi-test', type 1, size 2");
	ut_assert_nextline("dev 'acpi-test2', type 1, size 2");
	ut_assert_console_end();

	acpi_reset_items();
	ctx.current = buf;
	ut_assertok(acpi_inject_dsdt(&ctx));
	console_record_reset();
	run_command("acpi items", 0);
	ut_assert_nextline("dev 'acpi-test', type 2, size 2");
	ut_assert_nextline("dev 'acpi-test2', type 2, size 2");
	ut_assert_console_end();

	console_record_reset();
	run_command("acpi items -d", 0);
	ut_assert_nextline("dev 'acpi-test', type 2, size 2");
	ut_assert_nextlines_are_dump(2);
	ut_assert_nextline("%s", "");
	ut_assert_nextline("dev 'acpi-test2', type 2, size 2");
	ut_assert_nextlines_are_dump(2);
	ut_assert_nextline("%s", "");
	ut_assert_console_end();

	return 0;
}
DM_TEST(dm_test_acpi_cmd_items, UT_TESTF_SCAN_PDATA | UT_TESTF_SCAN_FDT);
Commit	Line	Data
f50cc952 SG	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>
0b885bcf	10	#include <console.h>
f50cc952	11	#include <dm.h>
7e586f69	12	#include <malloc.h>
29b35112	13	#include <mapmem.h>
0b885bcf	14	#include <version.h>
7e586f69	15	#include <tables_csum.h>
93f7f827	16	#include <version.h>
b5183172	17	#include <acpi/acpigen.h>
1361a53c	18	#include <acpi/acpi_device.h>
91fe8b79	19	#include <acpi/acpi_table.h>
401d1c4f	20	#include <asm/global_data.h>
f50cc952 SG	21	#include <dm/acpi.h>
	22	#include <dm/test.h>
	23	#include <test/ut.h>
82659cc9	24	#include "acpi.h"
f50cc952	25
93f7f827 SG	26	#define BUF_SIZE 4096
93f7f827 SG	27
1361a53c	28	/**
8a8d24bd	29	* struct testacpi_plat - Platform data for the test ACPI device
1361a53c SG	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	*/
8a8d24bd	34	struct testacpi_plat {
1361a53c SG	35	bool return_error;
	36	bool no_name;
	37	};
	38
93f7f827 SG	39	static int testacpi_write_tables(const struct udevice *dev,
	40	struct acpi_ctx *ctx)
	41	{
	42	struct acpi_dmar *dmar;
29b35112	43	int ret;
93f7f827 SG	44
	45	dmar = (struct acpi_dmar *)ctx->current;
	46	acpi_create_dmar(dmar, DMAR_INTR_REMAP);
	47	ctx->current += sizeof(struct acpi_dmar);
29b35112 SG	48	ret = acpi_add_table(ctx, dmar);
	49	if (ret)
	50	return log_msg_ret("add", ret);
93f7f827 SG	51
	52	return 0;
	53	}
f50cc952 SG	54
	55	static int testacpi_get_name(const struct udevice dev, char out_name)
	56	{
8a8d24bd	57	struct testacpi_plat *plat = dev_get_plat(dev);
1361a53c SG	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);
f50cc952 SG	69	}
f50cc952 SG	70
b5183172 SG	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
01694589 SG	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
f50cc952 SG	97	struct acpi_ops testacpi_ops = {
f50cc952 SG	98	.get_name = testacpi_get_name,
93f7f827	99	.write_tables = testacpi_write_tables,
b5183172	100	.fill_ssdt = testacpi_fill_ssdt,
01694589	101	.inject_dsdt = testacpi_inject_dsdt,
f50cc952 SG	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,
1361a53c	113	.bind = dm_scan_fdt_dev,
8a8d24bd	114	.plat_auto = sizeof(struct testacpi_plat),
f50cc952 SG	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];
d1e85308	127	struct udevice dev, dev2, i2c, spi, timer, sound;
fefac0b0	128	struct udevice pci, root;
f50cc952	129
fefac0b0	130	/* Test getting the name from the driver */
f50cc952 SG	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
fefac0b0 SG	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
fefac0b0 SG	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
f50cc952 SG	169	return 0;
f50cc952 SG	170	}
e180c2b1	171	DM_TEST(dm_test_acpi_get_name, UT_TESTF_SCAN_PDATA \| UT_TESTF_SCAN_FDT);
91fe8b79 SG	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,
e180c2b1	184	UT_TESTF_SCAN_PDATA \| UT_TESTF_SCAN_FDT);
bfeb5d46	185
bfeb5d46 SG	186	/* Test acpi_create_dmar() */
	187	static int dm_test_acpi_create_dmar(struct unit_test_state *uts)
	188	{
	189	struct acpi_dmar dmar;
331caeaf	190	struct udevice *cpu;
bfeb5d46	191
331caeaf HS	192	ut_assertok(uclass_first_device(UCLASS_CPU, &cpu));
331caeaf HS	193	ut_assertnonnull(cpu);
bfeb5d46 SG	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	}
e180c2b1	200	DM_TEST(dm_test_acpi_create_dmar, UT_TESTF_SCAN_PDATA \| UT_TESTF_SCAN_FDT);
93f7f827 SG	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	}
e180c2b1	227	DM_TEST(dm_test_acpi_fill_header, UT_TESTF_SCAN_PDATA \| UT_TESTF_SCAN_FDT);
93f7f827 SG	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;
1361a53c	235	int i;
93f7f827 SG	236
	237	buf = malloc(BUF_SIZE);
	238	ut_assertnonnull(buf);
	239
7e586f69	240	acpi_setup_base_tables(&ctx, buf);
29b35112	241	dmar = ctx.current;
93f7f827	242	ut_assertok(acpi_write_dev_tables(&ctx));
93f7f827 SG	243
93f7f827 SG	244	/*
1361a53c SG	245	* We should have three dmar tables, one for each
1361a53c SG	246	* "denx,u-boot-acpi-test" device
93f7f827	247	*/
1361a53c	248	ut_asserteq_ptr(dmar + 3, ctx.current);
93f7f827 SG	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
1361a53c SG	255	ut_asserteq(DMAR_INTR_REMAP, dmar[2].flags);
1361a53c SG	256	ut_asserteq(32 - 1, dmar[2].host_address_width);
7e586f69	257
1361a53c SG	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]);
b38309b7	265
93f7f827 SG	266	return 0;
93f7f827 SG	267	}
e180c2b1	268	DM_TEST(dm_test_acpi_write_tables, UT_TESTF_SCAN_PDATA \| UT_TESTF_SCAN_FDT);
86e1778d SG	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	}
e180c2b1	296	DM_TEST(dm_test_acpi_basic, UT_TESTF_SCAN_PDATA \| UT_TESTF_SCAN_FDT);
7e586f69 SG	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);
0b885bcf	314	ut_asserteq(map_to_sysmem(PTR_ALIGN(buf + 4, 16)), gd->arch.acpi_start);
7e586f69 SG	315
	316	rsdp = buf + 16;
	317	ut_asserteq_ptr(rsdp, ctx.rsdp);
f91f366b	318	ut_asserteq_mem(RSDP_SIG, rsdp->signature, sizeof(rsdp->signature));
7e586f69 SG	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);
f91f366b	325	ut_asserteq_mem("RSDT", rsdt->header.signature, ACPI_NAME_LEN);
7e586f69 SG	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);
b38309b7	330	ut_asserteq_ptr(xsdt, ctx.xsdt);
f91f366b	331	ut_asserteq_mem("XSDT", xsdt->header.signature, ACPI_NAME_LEN);
7e586f69 SG	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,
e180c2b1	344	UT_TESTF_SCAN_PDATA \| UT_TESTF_SCAN_FDT);
0b885bcf SG	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);
4364a3f8	366	ut_assert_nextline("RSDT %08lx %06lx (v01 U-BOOT U-BOOTBL %x INTL 0)",
0b885bcf	367	addr, sizeof(struct acpi_table_header) +
1361a53c	368	3 * sizeof(u32), U_BOOT_BUILD_DATE);
0b885bcf	369	addr = ALIGN(addr + sizeof(struct acpi_rsdt), 16);
4364a3f8	370	ut_assert_nextline("XSDT %08lx %06lx (v01 U-BOOT U-BOOTBL %x INTL 0)",
0b885bcf	371	addr, sizeof(struct acpi_table_header) +
1361a53c	372	3 * sizeof(u64), U_BOOT_BUILD_DATE);
0b885bcf	373	addr = ALIGN(addr + sizeof(struct acpi_xsdt), 64);
4364a3f8	374	ut_assert_nextline("DMAR %08lx %06lx (v01 U-BOOT U-BOOTBL %x INTL 0)",
0b885bcf SG	375	addr, sizeof(struct acpi_dmar), U_BOOT_BUILD_DATE);
0b885bcf SG	376	addr = ALIGN(addr + sizeof(struct acpi_dmar), 16);
4364a3f8	377	ut_assert_nextline("DMAR %08lx %06lx (v01 U-BOOT U-BOOTBL %x INTL 0)",
1361a53c SG	378	addr, sizeof(struct acpi_dmar), U_BOOT_BUILD_DATE);
1361a53c SG	379	addr = ALIGN(addr + sizeof(struct acpi_dmar), 16);
4364a3f8	380	ut_assert_nextline("DMAR %08lx %06lx (v01 U-BOOT U-BOOTBL %x INTL 0)",
0b885bcf SG	381	addr, sizeof(struct acpi_dmar), U_BOOT_BUILD_DATE);
	382	ut_assert_console_end();
	383
	384	return 0;
	385	}
e180c2b1	386	DM_TEST(dm_test_acpi_cmd_list, UT_TESTF_SCAN_PDATA \| UT_TESTF_SCAN_FDT);
0b885bcf SG	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	}
e180c2b1	417	DM_TEST(dm_test_acpi_cmd_dump, UT_TESTF_SCAN_PDATA \| UT_TESTF_SCAN_FDT);
1361a53c SG	418
	419	/* Test acpi_device_path() */
	420	static int dm_test_acpi_device_path(struct unit_test_state *uts)
	421	{
8a8d24bd	422	struct testacpi_plat *plat;
1361a53c SG	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 */
c69cda25	442	plat = dev_get_plat(dev);
1361a53c SG	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 */
c69cda25	448	plat = dev_get_plat(dev);
1361a53c SG	449	plat->return_error = true;
	450	ut_asserteq(-EINVAL, acpi_device_path(child, buf, sizeof(buf)));
	451
	452	return 0;
	453	}
e180c2b1	454	DM_TEST(dm_test_acpi_device_path, UT_TESTF_SCAN_PDATA \| UT_TESTF_SCAN_FDT);
2715b362 SG	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	}
e180c2b1	466	DM_TEST(dm_test_acpi_device_status, UT_TESTF_SCAN_PDATA \| UT_TESTF_SCAN_FDT);
b5183172 SG	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
18434aec	477	acpi_reset_items();
b5183172 SG	478	ctx.current = buf;
	479	buf[4] = 'z'; /* sentinel */
	480	ut_assertok(acpi_fill_ssdt(&ctx));
	481
0f7b111f SG	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]);
b5183172	488
0f7b111f SG	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]);
b5183172 SG	492
	493	ut_asserteq('z', buf[4]);
	494
	495	return 0;
	496	}
e180c2b1	497	DM_TEST(dm_test_acpi_fill_ssdt, UT_TESTF_SCAN_PDATA \| UT_TESTF_SCAN_FDT);
01694589 SG	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
18434aec	508	acpi_reset_items();
01694589 SG	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	}
e180c2b1	528	DM_TEST(dm_test_acpi_inject_dsdt, UT_TESTF_SCAN_PDATA \| UT_TESTF_SCAN_FDT);
a4f82089 SG	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
18434aec	539	acpi_reset_items();
a4f82089 SG	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
18434aec	548	acpi_reset_items();
a4f82089 SG	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	}
e180c2b1	569	DM_TEST(dm_test_acpi_cmd_items, UT_TESTF_SCAN_PDATA \| UT_TESTF_SCAN_FDT);