[thirdparty/u-boot.git] / test / dm / acpi_dp.c

// SPDX-License-Identifier: GPL-2.0+
/*
 * Tests for ACPI code generation via a device-property table
 *
 * Copyright 2019 Google LLC
 * Written by Simon Glass <sjg@chromium.org>
 */

#include <common.h>
#include <dm.h>
#include <uuid.h>
#include <acpi/acpigen.h>
#include <acpi/acpi_dp.h>
#include <asm/unaligned.h>
#include <dm/acpi.h>
#include <dm/test.h>
#include <test/ut.h>
#include "acpi.h"

/* Maximum size of the ACPI context needed for most tests */
#define ACPI_CONTEXT_SIZE	500

#define TEST_INT8	0x7d
#define TEST_INT16	0x2345
#define TEST_INT32	0x12345678
#define TEST_INT64	0x4567890123456
#define TEST_STR	"testing acpi strings"
#define TEST_REF	"\\SB.I2C0.TPM2"
#define EXPECT_REF	"SB__I2C0TPM2"

static int alloc_context(struct acpi_ctx **ctxp)
{
	return acpi_test_alloc_context_size(ctxp, ACPI_CONTEXT_SIZE);

	return 0;
}

static void free_context(struct acpi_ctx **ctxp)
{
	free(*ctxp);
	*ctxp = NULL;
}

/* Test emitting an empty table */
static int dm_test_acpi_dp_new_table(struct unit_test_state *uts)
{
	struct acpi_ctx *ctx;
	struct acpi_dp *dp;
	u8 *ptr;

	ut_assertok(alloc_context(&ctx));

	dp = acpi_dp_new_table("FRED");
	ut_assertnonnull(dp);

	ptr = acpigen_get_current(ctx);
	ut_assertok(acpi_dp_write(ctx, dp));
	ut_asserteq(10, acpigen_get_current(ctx) - ptr);
	ut_asserteq(NAME_OP, *(u8 *)ptr);
	ut_asserteq_strn("FRED", (char *)ptr + 1);
	ut_asserteq(PACKAGE_OP, ptr[5]);
	ut_asserteq(4, acpi_test_get_length(ptr + 6));
	ut_asserteq(0, ptr[9]);

	free_context(&ctx);

	return 0;
}
DM_TEST(dm_test_acpi_dp_new_table, 0);

/* Test emitting an integer */
static int dm_test_acpi_dp_int(struct unit_test_state *uts)
{
	struct acpi_ctx *ctx;
	char uuid[UUID_STR_LEN + 1];
	struct acpi_dp *dp;
	u8 *ptr;

	ut_assertok(alloc_context(&ctx));

	dp = acpi_dp_new_table("FRED");
	ut_assertnonnull(dp);
	ut_assertnonnull(acpi_dp_add_integer(dp, "MARY", TEST_INT32));

	ptr = acpigen_get_current(ctx);
	ut_assertok(acpi_dp_write(ctx, dp));
	ut_asserteq(54, acpigen_get_current(ctx) - ptr);
	ut_asserteq(NAME_OP, *(u8 *)ptr);
	ut_asserteq_strn("FRED", (char *)ptr + 1);
	ut_asserteq(PACKAGE_OP, ptr[5]);
	ut_asserteq(48, acpi_test_get_length(ptr + 6));
	ut_asserteq(2, ptr[9]);

	/* UUID */
	ut_asserteq(BUFFER_OP, ptr[10]);
	ut_asserteq(22, acpi_test_get_length(ptr + 11));
	ut_asserteq(WORD_PREFIX, ptr[14]);
	ut_asserteq(16, get_unaligned((u16 *)(ptr + 15)));
	uuid_bin_to_str(ptr + 17, uuid, 1);
	ut_asserteq_str(ACPI_DP_UUID, uuid);

	/* Container package */
	ut_asserteq(PACKAGE_OP, ptr[33]);
	ut_asserteq(20, acpi_test_get_length(ptr + 34));
	ut_asserteq(1, ptr[37]);

	/* Package with name and (integer) value */
	ut_asserteq(PACKAGE_OP, ptr[38]);
	ut_asserteq(15, acpi_test_get_length(ptr + 39));
	ut_asserteq(2, ptr[42]);
	ut_asserteq(STRING_PREFIX, ptr[43]);
	ut_asserteq_str("MARY", (char *)ptr + 44);

	ut_asserteq(DWORD_PREFIX, ptr[49]);
	ut_asserteq(TEST_INT32, get_unaligned((u32 *)(ptr + 50)));

	free_context(&ctx);

	return 0;
}
DM_TEST(dm_test_acpi_dp_int, 0);

/* Test emitting a 64-bit integer */
static int dm_test_acpi_dp_int64(struct unit_test_state *uts)
{
	struct acpi_ctx *ctx;
	struct acpi_dp *dp;
	u8 *ptr;

	ut_assertok(alloc_context(&ctx));

	dp = acpi_dp_new_table("FRED");
	ut_assertnonnull(dp);
	ut_assertnonnull(acpi_dp_add_integer(dp, "MARY", TEST_INT64));

	ptr = acpigen_get_current(ctx);
	ut_assertok(acpi_dp_write(ctx, dp));
	ut_asserteq(58, acpigen_get_current(ctx) - ptr);

	ut_asserteq(QWORD_PREFIX, ptr[49]);
	ut_asserteq_64(TEST_INT64, get_unaligned((u64 *)(ptr + 50)));

	free_context(&ctx);

	return 0;
}
DM_TEST(dm_test_acpi_dp_int64, 0);

/* Test emitting a 16-bit integer */
static int dm_test_acpi_dp_int16(struct unit_test_state *uts)
{
	struct acpi_ctx *ctx;
	struct acpi_dp *dp;
	u8 *ptr;

	ut_assertok(alloc_context(&ctx));

	dp = acpi_dp_new_table("FRED");
	ut_assertnonnull(dp);
	ut_assertnonnull(acpi_dp_add_integer(dp, "MARY", TEST_INT16));

	ptr = acpigen_get_current(ctx);
	ut_assertok(acpi_dp_write(ctx, dp));
	ut_asserteq(52, acpigen_get_current(ctx) - ptr);

	ut_asserteq(WORD_PREFIX, ptr[49]);
	ut_asserteq(TEST_INT16, get_unaligned((u16 *)(ptr + 50)));

	free_context(&ctx);

	return 0;
}
DM_TEST(dm_test_acpi_dp_int16, 0);

/* Test emitting a 8-bit integer */
static int dm_test_acpi_dp_int8(struct unit_test_state *uts)
{
	struct acpi_ctx *ctx;
	struct acpi_dp *dp;
	u8 *ptr;

	ut_assertok(alloc_context(&ctx));

	dp = acpi_dp_new_table("FRED");
	ut_assertnonnull(dp);
	ut_assertnonnull(acpi_dp_add_integer(dp, "MARY", TEST_INT8));

	ptr = acpigen_get_current(ctx);
	ut_assertok(acpi_dp_write(ctx, dp));
	ut_asserteq(51, acpigen_get_current(ctx) - ptr);

	ut_asserteq(BYTE_PREFIX, ptr[49]);
	ut_asserteq(TEST_INT8, ptr[50]);

	free_context(&ctx);

	return 0;
}
DM_TEST(dm_test_acpi_dp_int8, 0);

/* Test emitting multiple values */
static int dm_test_acpi_dp_multiple(struct unit_test_state *uts)
{
	struct acpi_ctx *ctx;
	struct acpi_dp *dp;
	u8 *ptr;

	ut_assertok(alloc_context(&ctx));

	dp = acpi_dp_new_table("FRED");
	ut_assertnonnull(dp);
	ut_assertnonnull(acpi_dp_add_integer(dp, "int16", TEST_INT16));
	ut_assertnonnull(acpi_dp_add_string(dp, "str", TEST_STR));
	ut_assertnonnull(acpi_dp_add_reference(dp, "ref", TEST_REF));

	ptr = acpigen_get_current(ctx);
	ut_assertok(acpi_dp_write(ctx, dp));
	ut_asserteq(110, acpigen_get_current(ctx) - ptr);

	ut_asserteq(WORD_PREFIX, ptr[0x32]);
	ut_asserteq(TEST_INT16, get_unaligned((u16 *)(ptr + 0x33)));
	ut_asserteq(STRING_PREFIX, ptr[0x3f]);
	ut_asserteq_str(TEST_STR, (char *)ptr + 0x40);
	ut_asserteq(ROOT_PREFIX, ptr[0x5f]);
	ut_asserteq(MULTI_NAME_PREFIX, ptr[0x60]);
	ut_asserteq(3, ptr[0x61]);
	ut_asserteq_strn(EXPECT_REF, (char *)ptr + 0x62);

	free_context(&ctx);

	return 0;
}
DM_TEST(dm_test_acpi_dp_multiple, 0);

/* Test emitting an array */
static int dm_test_acpi_dp_array(struct unit_test_state *uts)
{
	struct acpi_ctx *ctx;
	struct acpi_dp *dp;
	u64 speed[4];
	u8 *ptr;

	ut_assertok(alloc_context(&ctx));

	dp = acpi_dp_new_table("FRED");
	ut_assertnonnull(dp);
	speed[0] = TEST_INT8;
	speed[1] = TEST_INT16;
	speed[2] = TEST_INT32;
	speed[3] = TEST_INT64;
	ut_assertnonnull(acpi_dp_add_integer_array(dp, "speeds", speed,
						   ARRAY_SIZE(speed)));

	ptr = acpigen_get_current(ctx);
	ut_assertok(acpi_dp_write(ctx, dp));
	ut_asserteq(75, acpigen_get_current(ctx) - ptr);

	ut_asserteq(BYTE_PREFIX, ptr[0x38]);
	ut_asserteq(TEST_INT8, ptr[0x39]);

	ut_asserteq(WORD_PREFIX, ptr[0x3a]);
	ut_asserteq(TEST_INT16, get_unaligned((u16 *)(ptr + 0x3b)));

	ut_asserteq(DWORD_PREFIX, ptr[0x3d]);
	ut_asserteq(TEST_INT32, get_unaligned((u32 *)(ptr + 0x3e)));

	ut_asserteq(QWORD_PREFIX, ptr[0x42]);
	ut_asserteq_64(TEST_INT64, get_unaligned((u64 *)(ptr + 0x43)));

	free_context(&ctx);

	return 0;
}
DM_TEST(dm_test_acpi_dp_array, 0);

/* Test emitting a child */
static int dm_test_acpi_dp_child(struct unit_test_state *uts)
{
	struct acpi_ctx *ctx;
	struct acpi_dp *dp, *child1, *child2;
	char uuid[UUID_STR_LEN + 1];
	u8 *ptr, *pptr;
	int i;

	ut_assertok(alloc_context(&ctx));

	child1 = acpi_dp_new_table("child");
	ut_assertnonnull(child1);
	ut_assertnonnull(acpi_dp_add_integer(child1, "height", TEST_INT16));

	child2 = acpi_dp_new_table("child");
	ut_assertnonnull(child2);
	ut_assertnonnull(acpi_dp_add_integer(child2, "age", TEST_INT8));

	dp = acpi_dp_new_table("FRED");
	ut_assertnonnull(dp);

	ut_assertnonnull(acpi_dp_add_child(dp, "anna", child1));
	ut_assertnonnull(acpi_dp_add_child(dp, "john", child2));

	ptr = acpigen_get_current(ctx);
	ut_assertok(acpi_dp_write(ctx, dp));
	ut_asserteq(178, acpigen_get_current(ctx) - ptr);

	/* UUID for child extension using Hierarchical Data Extension UUID */
	ut_asserteq(BUFFER_OP, ptr[10]);
	ut_asserteq(22, acpi_test_get_length(ptr + 11));
	ut_asserteq(WORD_PREFIX, ptr[14]);
	ut_asserteq(16, get_unaligned((u16 *)(ptr + 15)));
	uuid_bin_to_str(ptr + 17, uuid, 1);
	ut_asserteq_str(ACPI_DP_CHILD_UUID, uuid);

	/* Package with two children */
	ut_asserteq(PACKAGE_OP, ptr[0x21]);
	ut_asserteq(0x28, acpi_test_get_length(ptr + 0x22));
	ut_asserteq(2, ptr[0x25]);

	/* First we expect the two children as string/value */
	pptr = ptr + 0x26;
	for (i = 0; i < 2; i++) {
		ut_asserteq(PACKAGE_OP, pptr[0]);
		ut_asserteq(0x11, acpi_test_get_length(pptr + 1));
		ut_asserteq(2, pptr[4]);
		ut_asserteq(STRING_PREFIX, pptr[5]);
		ut_asserteq_str(i ? "john" : "anna", (char *)pptr + 6);
		ut_asserteq(STRING_PREFIX, pptr[11]);
		ut_asserteq_str("child", (char *)pptr + 12);
		pptr += 0x12;
	}

	/* Write the two children */
	ut_asserteq(0x4a, pptr - ptr);
	for (i = 0; i < 2; i++) {
		const char *prop = i ? "age" : "height";
		const int datalen = i ? 1 : 2;
		int len = strlen(prop) + 1;

		ut_asserteq(NAME_OP, pptr[0]);
		ut_asserteq_strn("chil", (char *)pptr + 1);
		ut_asserteq(PACKAGE_OP, pptr[5]);
		ut_asserteq(0x27 + len + datalen, acpi_test_get_length(pptr + 6));
		ut_asserteq(2, pptr[9]);

		/* UUID */
		ut_asserteq(BUFFER_OP, pptr[10]);
		ut_asserteq(22, acpi_test_get_length(pptr + 11));
		ut_asserteq(WORD_PREFIX, pptr[14]);
		ut_asserteq(16, get_unaligned((u16 *)(pptr + 15)));
		uuid_bin_to_str(pptr + 17, uuid, 1);
		ut_asserteq_str(ACPI_DP_UUID, uuid);
		pptr += 33;

		/* Containing package */
		ut_asserteq(i ? 0xa1 : 0x6b, pptr - ptr);
		ut_asserteq(PACKAGE_OP, pptr[0]);
		ut_asserteq(0xb + len + datalen, acpi_test_get_length(pptr + 1));
		ut_asserteq(1, pptr[4]);

		/* Package containing the property-name string and the value */
		pptr += 5;
		ut_asserteq(i ? 0xa6 : 0x70, pptr - ptr);
		ut_asserteq(PACKAGE_OP, pptr[0]);
		ut_asserteq(6 + len + datalen, acpi_test_get_length(pptr + 1));
		ut_asserteq(2, pptr[4]);

		ut_asserteq(STRING_PREFIX, pptr[5]);
		ut_asserteq_str(i ? "age" : "height", (char *)pptr + 6);
		pptr += 6 + len;
		if (i) {
			ut_asserteq(BYTE_PREFIX, pptr[0]);
			ut_asserteq(TEST_INT8, pptr[1]);
		} else {
			ut_asserteq(WORD_PREFIX, pptr[0]);
			ut_asserteq(TEST_INT16,
				    get_unaligned((u16 *)(pptr + 1)));
		}
		pptr += 1 + datalen;
	}
	ut_asserteq(178, pptr - ptr);

	free_context(&ctx);

	return 0;
}
DM_TEST(dm_test_acpi_dp_child, 0);

/* Test emitting a GPIO */
static int dm_test_acpi_dp_gpio(struct unit_test_state *uts)
{
	struct acpi_ctx *ctx;
	struct acpi_dp *dp;
	u8 *ptr, *pptr;

	ut_assertok(alloc_context(&ctx));

	dp = acpi_dp_new_table("FRED");
	ut_assertnonnull(dp);

	/* Try a few different parameters */
	ut_assertnonnull(acpi_dp_add_gpio(dp, "reset", TEST_REF, 0x23, 0x24,
					  ACPI_GPIO_ACTIVE_HIGH));
	ut_assertnonnull(acpi_dp_add_gpio(dp, "allow", TEST_REF, 0, 0,
					  ACPI_GPIO_ACTIVE_LOW));

	ptr = acpigen_get_current(ctx);
	ut_assertok(acpi_dp_write(ctx, dp));
	ut_asserteq(0x6e, acpigen_get_current(ctx) - ptr);

	pptr = ptr + 0x2c; //0x3a;
	ut_asserteq_str("reset", (char *)pptr);
	ut_asserteq_strn(EXPECT_REF, (char *)pptr + 0xe);
	ut_asserteq(0x23, pptr[0x1b]);
	ut_asserteq(0x24, pptr[0x1d]);
	ut_asserteq(ZERO_OP, pptr[0x1e]);

	pptr = ptr + 0x51;
	ut_asserteq_str("allow", (char *)pptr);
	ut_asserteq_strn(EXPECT_REF, (char *)pptr + 0xe);
	ut_asserteq(ZERO_OP, pptr[0x1a]);
	ut_asserteq(ZERO_OP, pptr[0x1b]);
	ut_asserteq(ONE_OP, pptr[0x1c]);

	return 0;
}
DM_TEST(dm_test_acpi_dp_gpio, 0);

/* Test copying info from the device tree to ACPI tables */
static int dm_test_acpi_dp_copy(struct unit_test_state *uts)
{
	struct acpi_ctx *ctx;
	struct udevice *dev;
	struct acpi_dp *dp;
	ofnode node;
	u8 *ptr;

	ut_assertok(alloc_context(&ctx));

	dp = acpi_dp_new_table("FRED");
	ut_assertnonnull(dp);

	ut_assertok(uclass_get_device(UCLASS_TEST_FDT, 0, &dev));
	ut_asserteq_str("a-test", dev->name);

	ut_assertok(acpi_dp_dev_copy_int(dev, dp, "int-value"));
	ut_asserteq(-EINVAL, acpi_dp_dev_copy_int(dev, dp, "missing-value"));
	ut_assertok(acpi_dp_dev_copy_int(dev, dp, "uint-value"));

	ut_assertok(acpi_dp_dev_copy_str(dev, dp, "str-value"));
	ut_asserteq(-EINVAL, acpi_dp_dev_copy_str(dev, dp, "missing-value"));

	node = ofnode_path("/chosen");
	ut_assert(ofnode_valid(node));
	ut_assertok(acpi_dp_ofnode_copy_int(node, dp, "int-values"));
	ut_asserteq(-EINVAL,
		    acpi_dp_ofnode_copy_int(node, dp, "missing-value"));

	ut_assertok(acpi_dp_ofnode_copy_str(node, dp, "setting"));
	ut_asserteq(-EINVAL,
		    acpi_dp_ofnode_copy_str(node, dp, "missing-value"));

	ptr = acpigen_get_current(ctx);
	ut_assertok(acpi_dp_write(ctx, dp));
	ut_asserteq(0x9d, acpigen_get_current(ctx) - ptr);

	ut_asserteq(STRING_PREFIX, ptr[0x2b]);
	ut_asserteq_str("int-value", (char *)ptr + 0x2c);
	ut_asserteq(WORD_PREFIX, ptr[0x36]);
	ut_asserteq(1234, get_unaligned((u16 *)(ptr + 0x37)));

	ut_asserteq(STRING_PREFIX, ptr[0x3e]);
	ut_asserteq_str("uint-value", (char *)ptr + 0x3f);
	ut_asserteq(DWORD_PREFIX, ptr[0x4a]);
	ut_asserteq(-1234, get_unaligned((u32 *)(ptr + 0x4b)));

	ut_asserteq(STRING_PREFIX, ptr[0x54]);
	ut_asserteq_str("str-value", (char *)ptr + 0x55);
	ut_asserteq(STRING_PREFIX, ptr[0x5f]);
	ut_asserteq_str("test string", (char *)ptr + 0x60);

	ut_asserteq(STRING_PREFIX, ptr[0x71]);
	ut_asserteq_str("int-values", (char *)ptr + 0x72);
	ut_asserteq(WORD_PREFIX, ptr[0x7d]);
	ut_asserteq(0x1937, get_unaligned((u16 *)(ptr + 0x7e)));

	ut_asserteq(STRING_PREFIX, ptr[0x85]);
	ut_asserteq_str("setting", (char *)ptr + 0x86);
	ut_asserteq(STRING_PREFIX, ptr[0x8e]);
	ut_asserteq_str("sunrise ohoka", (char *)(ptr + 0x8f));

	return 0;
}
DM_TEST(dm_test_acpi_dp_copy, UT_TESTF_SCAN_PDATA | UT_TESTF_SCAN_FDT);
Commit	Line	Data
0e5a0a00 SG	1	// SPDX-License-Identifier: GPL-2.0+
	2	/*
	3	* Tests for ACPI code generation via a device-property table
	4	*
	5	* Copyright 2019 Google LLC
	6	* Written by Simon Glass <sjg@chromium.org>
	7	*/
	8
d678a59d	9	#include <common.h>
0e5a0a00 SG	10	#include <dm.h>
	11	#include <uuid.h>
	12	#include <acpi/acpigen.h>
	13	#include <acpi/acpi_dp.h>
	14	#include <asm/unaligned.h>
	15	#include <dm/acpi.h>
	16	#include <dm/test.h>
	17	#include <test/ut.h>
	18	#include "acpi.h"
	19
	20	/* Maximum size of the ACPI context needed for most tests */
	21	#define ACPI_CONTEXT_SIZE 500
	22
	23	#define TEST_INT8 0x7d
	24	#define TEST_INT16 0x2345
	25	#define TEST_INT32 0x12345678
	26	#define TEST_INT64 0x4567890123456
	27	#define TEST_STR "testing acpi strings"
	28	#define TEST_REF "\\SB.I2C0.TPM2"
	29	#define EXPECT_REF "SB__I2C0TPM2"
	30
	31	static int alloc_context(struct acpi_ctx **ctxp)
	32	{
	33	return acpi_test_alloc_context_size(ctxp, ACPI_CONTEXT_SIZE);
	34
	35	return 0;
	36	}
	37
	38	static void free_context(struct acpi_ctx **ctxp)
	39	{
	40	free(*ctxp);
	41	*ctxp = NULL;
	42	}
	43
	44	/* Test emitting an empty table */
	45	static int dm_test_acpi_dp_new_table(struct unit_test_state *uts)
	46	{
	47	struct acpi_ctx *ctx;
	48	struct acpi_dp *dp;
	49	u8 *ptr;
	50
	51	ut_assertok(alloc_context(&ctx));
	52
	53	dp = acpi_dp_new_table("FRED");
	54	ut_assertnonnull(dp);
	55
	56	ptr = acpigen_get_current(ctx);
	57	ut_assertok(acpi_dp_write(ctx, dp));
	58	ut_asserteq(10, acpigen_get_current(ctx) - ptr);
	59	ut_asserteq(NAME_OP, (u8 )ptr);
	60	ut_asserteq_strn("FRED", (char *)ptr + 1);
	61	ut_asserteq(PACKAGE_OP, ptr[5]);
	62	ut_asserteq(4, acpi_test_get_length(ptr + 6));
	63	ut_asserteq(0, ptr[9]);
	64
	65	free_context(&ctx);
	66
	67	return 0;
	68	}
	69	DM_TEST(dm_test_acpi_dp_new_table, 0);
	70
	71	/* Test emitting an integer */
	72	static int dm_test_acpi_dp_int(struct unit_test_state *uts)
	73	{
74	struct acpi_ctx *ctx;
75	char uuid[UUID_STR_LEN + 1];
76	struct acpi_dp *dp;
77	u8 *ptr;
78
79	ut_assertok(alloc_context(&ctx));
80
81	dp = acpi_dp_new_table("FRED");
82	ut_assertnonnull(dp);
83	ut_assertnonnull(acpi_dp_add_integer(dp, "MARY", TEST_INT32));
84
85	ptr = acpigen_get_current(ctx);
86	ut_assertok(acpi_dp_write(ctx, dp));
87	ut_asserteq(54, acpigen_get_current(ctx) - ptr);
88	ut_asserteq(NAME_OP, (u8 )ptr);
89	ut_asserteq_strn("FRED", (char *)ptr + 1);
90	ut_asserteq(PACKAGE_OP, ptr[5]);
91	ut_asserteq(48, acpi_test_get_length(ptr + 6));
92	ut_asserteq(2, ptr[9]);
93
94	/* UUID */
95	ut_asserteq(BUFFER_OP, ptr[10]);
96	ut_asserteq(22, acpi_test_get_length(ptr + 11));
97	ut_asserteq(WORD_PREFIX, ptr[14]);
98	ut_asserteq(16, get_unaligned((u16 *)(ptr + 15)));
99	uuid_bin_to_str(ptr + 17, uuid, 1);
100	ut_asserteq_str(ACPI_DP_UUID, uuid);
101
102	/* Container package */
103	ut_asserteq(PACKAGE_OP, ptr[33]);
104	ut_asserteq(20, acpi_test_get_length(ptr + 34));
105	ut_asserteq(1, ptr[37]);
106
107	/* Package with name and (integer) value */
108	ut_asserteq(PACKAGE_OP, ptr[38]);
109	ut_asserteq(15, acpi_test_get_length(ptr + 39));
110	ut_asserteq(2, ptr[42]);
111	ut_asserteq(STRING_PREFIX, ptr[43]);
112	ut_asserteq_str("MARY", (char *)ptr + 44);
113
114	ut_asserteq(DWORD_PREFIX, ptr[49]);
115	ut_asserteq(TEST_INT32, get_unaligned((u32 *)(ptr + 50)));
116
117	free_context(&ctx);
118
119	return 0;
120	}
121	DM_TEST(dm_test_acpi_dp_int, 0);
122
123	/* Test emitting a 64-bit integer */
124	static int dm_test_acpi_dp_int64(struct unit_test_state *uts)
125	{
126	struct acpi_ctx *ctx;
127	struct acpi_dp *dp;
128	u8 *ptr;
129
130	ut_assertok(alloc_context(&ctx));
131
132	dp = acpi_dp_new_table("FRED");
133	ut_assertnonnull(dp);
134	ut_assertnonnull(acpi_dp_add_integer(dp, "MARY", TEST_INT64));
135
136	ptr = acpigen_get_current(ctx);
137	ut_assertok(acpi_dp_write(ctx, dp));
138	ut_asserteq(58, acpigen_get_current(ctx) - ptr);
139
140	ut_asserteq(QWORD_PREFIX, ptr[49]);
141	ut_asserteq_64(TEST_INT64, get_unaligned((u64 *)(ptr + 50)));
142
143	free_context(&ctx);
144
145	return 0;
146	}
147	DM_TEST(dm_test_acpi_dp_int64, 0);
148
149	/* Test emitting a 16-bit integer */
150	static int dm_test_acpi_dp_int16(struct unit_test_state *uts)
151	{
152	struct acpi_ctx *ctx;
153	struct acpi_dp *dp;
154	u8 *ptr;
155
156	ut_assertok(alloc_context(&ctx));
157
158	dp = acpi_dp_new_table("FRED");
159	ut_assertnonnull(dp);
160	ut_assertnonnull(acpi_dp_add_integer(dp, "MARY", TEST_INT16));
161
162	ptr = acpigen_get_current(ctx);
163	ut_assertok(acpi_dp_write(ctx, dp));
164	ut_asserteq(52, acpigen_get_current(ctx) - ptr);
165
166	ut_asserteq(WORD_PREFIX, ptr[49]);
167	ut_asserteq(TEST_INT16, get_unaligned((u16 *)(ptr + 50)));
168
169	free_context(&ctx);
170
171	return 0;
172	}
173	DM_TEST(dm_test_acpi_dp_int16, 0);
174
175	/* Test emitting a 8-bit integer */
176	static int dm_test_acpi_dp_int8(struct unit_test_state *uts)
177	{
178	struct acpi_ctx *ctx;
179	struct acpi_dp *dp;
180	u8 *ptr;
181
182	ut_assertok(alloc_context(&ctx));
183
184	dp = acpi_dp_new_table("FRED");
185	ut_assertnonnull(dp);
186	ut_assertnonnull(acpi_dp_add_integer(dp, "MARY", TEST_INT8));
187
188	ptr = acpigen_get_current(ctx);
189	ut_assertok(acpi_dp_write(ctx, dp));
190	ut_asserteq(51, acpigen_get_current(ctx) - ptr);
191
192	ut_asserteq(BYTE_PREFIX, ptr[49]);
193	ut_asserteq(TEST_INT8, ptr[50]);
194
195	free_context(&ctx);
196
197	return 0;
198	}
199	DM_TEST(dm_test_acpi_dp_int8, 0);
200
201	/* Test emitting multiple values */
202	static int dm_test_acpi_dp_multiple(struct unit_test_state *uts)
203	{
204	struct acpi_ctx *ctx;
205	struct acpi_dp *dp;
206	u8 *ptr;
207
208	ut_assertok(alloc_context(&ctx));
209
210	dp = acpi_dp_new_table("FRED");
211	ut_assertnonnull(dp);
212	ut_assertnonnull(acpi_dp_add_integer(dp, "int16", TEST_INT16));
213	ut_assertnonnull(acpi_dp_add_string(dp, "str", TEST_STR));
214	ut_assertnonnull(acpi_dp_add_reference(dp, "ref", TEST_REF));
215
216	ptr = acpigen_get_current(ctx);
217	ut_assertok(acpi_dp_write(ctx, dp));
218	ut_asserteq(110, acpigen_get_current(ctx) - ptr);
219
220	ut_asserteq(WORD_PREFIX, ptr[0x32]);
221	ut_asserteq(TEST_INT16, get_unaligned((u16 *)(ptr + 0x33)));
222	ut_asserteq(STRING_PREFIX, ptr[0x3f]);
223	ut_asserteq_str(TEST_STR, (char *)ptr + 0x40);
224	ut_asserteq(ROOT_PREFIX, ptr[0x5f]);
225	ut_asserteq(MULTI_NAME_PREFIX, ptr[0x60]);
226	ut_asserteq(3, ptr[0x61]);
227	ut_asserteq_strn(EXPECT_REF, (char *)ptr + 0x62);
228
229	free_context(&ctx);
230
231	return 0;
232	}
233	DM_TEST(dm_test_acpi_dp_multiple, 0);
234
235	/* Test emitting an array */
236	static int dm_test_acpi_dp_array(struct unit_test_state *uts)
237	{
238	struct acpi_ctx *ctx;
239	struct acpi_dp *dp;
240	u64 speed[4];
241	u8 *ptr;
242
243	ut_assertok(alloc_context(&ctx));
244
245	dp = acpi_dp_new_table("FRED");
246	ut_assertnonnull(dp);
247	speed[0] = TEST_INT8;
248	speed[1] = TEST_INT16;
249	speed[2] = TEST_INT32;
250	speed[3] = TEST_INT64;
251	ut_assertnonnull(acpi_dp_add_integer_array(dp, "speeds", speed,
252	ARRAY_SIZE(speed)));
253
254	ptr = acpigen_get_current(ctx);
255	ut_assertok(acpi_dp_write(ctx, dp));
256	ut_asserteq(75, acpigen_get_current(ctx) - ptr);
257
258	ut_asserteq(BYTE_PREFIX, ptr[0x38]);
259	ut_asserteq(TEST_INT8, ptr[0x39]);
260
261	ut_asserteq(WORD_PREFIX, ptr[0x3a]);
262	ut_asserteq(TEST_INT16, get_unaligned((u16 *)(ptr + 0x3b)));
263
264	ut_asserteq(DWORD_PREFIX, ptr[0x3d]);
265	ut_asserteq(TEST_INT32, get_unaligned((u32 *)(ptr + 0x3e)));
266
267	ut_asserteq(QWORD_PREFIX, ptr[0x42]);
268	ut_asserteq_64(TEST_INT64, get_unaligned((u64 *)(ptr + 0x43)));
269
270	free_context(&ctx);
271
272	return 0;
273	}
274	DM_TEST(dm_test_acpi_dp_array, 0);
275
276	/* Test emitting a child */
277	static int dm_test_acpi_dp_child(struct unit_test_state *uts)
278	{
279	struct acpi_ctx *ctx;
280	struct acpi_dp dp, child1, *child2;
281	char uuid[UUID_STR_LEN + 1];
282	u8 ptr, pptr;
283	int i;
284
285	ut_assertok(alloc_context(&ctx));
286
287	child1 = acpi_dp_new_table("child");
288	ut_assertnonnull(child1);
289	ut_assertnonnull(acpi_dp_add_integer(child1, "height", TEST_INT16));
290
291	child2 = acpi_dp_new_table("child");
292	ut_assertnonnull(child2);
293	ut_assertnonnull(acpi_dp_add_integer(child2, "age", TEST_INT8));
294
295	dp = acpi_dp_new_table("FRED");
296	ut_assertnonnull(dp);
297
298	ut_assertnonnull(acpi_dp_add_child(dp, "anna", child1));
299	ut_assertnonnull(acpi_dp_add_child(dp, "john", child2));
300
301	ptr = acpigen_get_current(ctx);
302	ut_assertok(acpi_dp_write(ctx, dp));
303	ut_asserteq(178, acpigen_get_current(ctx) - ptr);
304
305	/* UUID for child extension using Hierarchical Data Extension UUID */
306	ut_asserteq(BUFFER_OP, ptr[10]);
307	ut_asserteq(22, acpi_test_get_length(ptr + 11));
308	ut_asserteq(WORD_PREFIX, ptr[14]);
309	ut_asserteq(16, get_unaligned((u16 *)(ptr + 15)));
310	uuid_bin_to_str(ptr + 17, uuid, 1);
311	ut_asserteq_str(ACPI_DP_CHILD_UUID, uuid);
312
313	/* Package with two children */
314	ut_asserteq(PACKAGE_OP, ptr[0x21]);
315	ut_asserteq(0x28, acpi_test_get_length(ptr + 0x22));
316	ut_asserteq(2, ptr[0x25]);
317
318	/* First we expect the two children as string/value */
319	pptr = ptr + 0x26;
320	for (i = 0; i < 2; i++) {
321	ut_asserteq(PACKAGE_OP, pptr[0]);
322	ut_asserteq(0x11, acpi_test_get_length(pptr + 1));
323	ut_asserteq(2, pptr[4]);
324	ut_asserteq(STRING_PREFIX, pptr[5]);
325	ut_asserteq_str(i ? "john" : "anna", (char *)pptr + 6);
326	ut_asserteq(STRING_PREFIX, pptr[11]);
327	ut_asserteq_str("child", (char *)pptr + 12);
328	pptr += 0x12;
329	}
330
331	/* Write the two children */
332	ut_asserteq(0x4a, pptr - ptr);
333	for (i = 0; i < 2; i++) {
334	const char *prop = i ? "age" : "height";
335	const int datalen = i ? 1 : 2;
336	int len = strlen(prop) + 1;
337
338	ut_asserteq(NAME_OP, pptr[0]);
339	ut_asserteq_strn("chil", (char *)pptr + 1);
340	ut_asserteq(PACKAGE_OP, pptr[5]);
341	ut_asserteq(0x27 + len + datalen, acpi_test_get_length(pptr + 6));
342	ut_asserteq(2, pptr[9]);
343
344	/* UUID */
345	ut_asserteq(BUFFER_OP, pptr[10]);
346	ut_asserteq(22, acpi_test_get_length(pptr + 11));
347	ut_asserteq(WORD_PREFIX, pptr[14]);
348	ut_asserteq(16, get_unaligned((u16 *)(pptr + 15)));
349	uuid_bin_to_str(pptr + 17, uuid, 1);
350	ut_asserteq_str(ACPI_DP_UUID, uuid);
351	pptr += 33;
352
353	/* Containing package */
354	ut_asserteq(i ? 0xa1 : 0x6b, pptr - ptr);
355	ut_asserteq(PACKAGE_OP, pptr[0]);
356	ut_asserteq(0xb + len + datalen, acpi_test_get_length(pptr + 1));
357	ut_asserteq(1, pptr[4]);
358
359	/* Package containing the property-name string and the value */
360	pptr += 5;
361	ut_asserteq(i ? 0xa6 : 0x70, pptr - ptr);
362	ut_asserteq(PACKAGE_OP, pptr[0]);
363	ut_asserteq(6 + len + datalen, acpi_test_get_length(pptr + 1));
364	ut_asserteq(2, pptr[4]);
365
366	ut_asserteq(STRING_PREFIX, pptr[5]);
367	ut_asserteq_str(i ? "age" : "height", (char *)pptr + 6);
368	pptr += 6 + len;
369	if (i) {
370	ut_asserteq(BYTE_PREFIX, pptr[0]);
371	ut_asserteq(TEST_INT8, pptr[1]);
372	} else {
373	ut_asserteq(WORD_PREFIX, pptr[0]);
374	ut_asserteq(TEST_INT16,
375	get_unaligned((u16 *)(pptr + 1)));
376	}
377	pptr += 1 + datalen;
378	}
379	ut_asserteq(178, pptr - ptr);
380
381	free_context(&ctx);
382
383	return 0;
384	}
385	DM_TEST(dm_test_acpi_dp_child, 0);
23572346 SG	386
	387	/* Test emitting a GPIO */
	388	static int dm_test_acpi_dp_gpio(struct unit_test_state *uts)
	389	{
	390	struct acpi_ctx *ctx;
	391	struct acpi_dp *dp;
	392	u8 ptr, pptr;
	393
	394	ut_assertok(alloc_context(&ctx));
	395
	396	dp = acpi_dp_new_table("FRED");
	397	ut_assertnonnull(dp);
	398
	399	/* Try a few different parameters */
	400	ut_assertnonnull(acpi_dp_add_gpio(dp, "reset", TEST_REF, 0x23, 0x24,
23dd0ea4	401	ACPI_GPIO_ACTIVE_HIGH));
23572346	402	ut_assertnonnull(acpi_dp_add_gpio(dp, "allow", TEST_REF, 0, 0,
23dd0ea4	403	ACPI_GPIO_ACTIVE_LOW));
23572346 SG	404
	405	ptr = acpigen_get_current(ctx);
	406	ut_assertok(acpi_dp_write(ctx, dp));
	407	ut_asserteq(0x6e, acpigen_get_current(ctx) - ptr);
	408
	409	pptr = ptr + 0x2c; //0x3a;
	410	ut_asserteq_str("reset", (char *)pptr);
	411	ut_asserteq_strn(EXPECT_REF, (char *)pptr + 0xe);
	412	ut_asserteq(0x23, pptr[0x1b]);
	413	ut_asserteq(0x24, pptr[0x1d]);
	414	ut_asserteq(ZERO_OP, pptr[0x1e]);
	415
	416	pptr = ptr + 0x51;
	417	ut_asserteq_str("allow", (char *)pptr);
	418	ut_asserteq_strn(EXPECT_REF, (char *)pptr + 0xe);
	419	ut_asserteq(ZERO_OP, pptr[0x1a]);
	420	ut_asserteq(ZERO_OP, pptr[0x1b]);
	421	ut_asserteq(ONE_OP, pptr[0x1c]);
	422
	423	return 0;
	424	}
	425	DM_TEST(dm_test_acpi_dp_gpio, 0);
06679000 SG	426
	427	/* Test copying info from the device tree to ACPI tables */
	428	static int dm_test_acpi_dp_copy(struct unit_test_state *uts)
	429	{
	430	struct acpi_ctx *ctx;
	431	struct udevice *dev;
	432	struct acpi_dp *dp;
	433	ofnode node;
	434	u8 *ptr;
	435
	436	ut_assertok(alloc_context(&ctx));
	437
	438	dp = acpi_dp_new_table("FRED");
	439	ut_assertnonnull(dp);
	440
	441	ut_assertok(uclass_get_device(UCLASS_TEST_FDT, 0, &dev));
	442	ut_asserteq_str("a-test", dev->name);
	443
	444	ut_assertok(acpi_dp_dev_copy_int(dev, dp, "int-value"));
	445	ut_asserteq(-EINVAL, acpi_dp_dev_copy_int(dev, dp, "missing-value"));
	446	ut_assertok(acpi_dp_dev_copy_int(dev, dp, "uint-value"));
	447
	448	ut_assertok(acpi_dp_dev_copy_str(dev, dp, "str-value"));
	449	ut_asserteq(-EINVAL, acpi_dp_dev_copy_str(dev, dp, "missing-value"));
	450
	451	node = ofnode_path("/chosen");
	452	ut_assert(ofnode_valid(node));
	453	ut_assertok(acpi_dp_ofnode_copy_int(node, dp, "int-values"));
	454	ut_asserteq(-EINVAL,
	455	acpi_dp_ofnode_copy_int(node, dp, "missing-value"));
	456
	457	ut_assertok(acpi_dp_ofnode_copy_str(node, dp, "setting"));
	458	ut_asserteq(-EINVAL,
	459	acpi_dp_ofnode_copy_str(node, dp, "missing-value"));
	460
	461	ptr = acpigen_get_current(ctx);
	462	ut_assertok(acpi_dp_write(ctx, dp));
	463	ut_asserteq(0x9d, acpigen_get_current(ctx) - ptr);
	464
	465	ut_asserteq(STRING_PREFIX, ptr[0x2b]);
	466	ut_asserteq_str("int-value", (char *)ptr + 0x2c);
	467	ut_asserteq(WORD_PREFIX, ptr[0x36]);
	468	ut_asserteq(1234, get_unaligned((u16 *)(ptr + 0x37)));
	469
	470	ut_asserteq(STRING_PREFIX, ptr[0x3e]);
	471	ut_asserteq_str("uint-value", (char *)ptr + 0x3f);
	472	ut_asserteq(DWORD_PREFIX, ptr[0x4a]);
	473	ut_asserteq(-1234, get_unaligned((u32 *)(ptr + 0x4b)));
	474
	475	ut_asserteq(STRING_PREFIX, ptr[0x54]);
	476	ut_asserteq_str("str-value", (char *)ptr + 0x55);
	477	ut_asserteq(STRING_PREFIX, ptr[0x5f]);
	478	ut_asserteq_str("test string", (char *)ptr + 0x60);
	479
	480	ut_asserteq(STRING_PREFIX, ptr[0x71]);
	481	ut_asserteq_str("int-values", (char *)ptr + 0x72);
	482	ut_asserteq(WORD_PREFIX, ptr[0x7d]);
	483	ut_asserteq(0x1937, get_unaligned((u16 *)(ptr + 0x7e)));
	484
	485	ut_asserteq(STRING_PREFIX, ptr[0x85]);
	486	ut_asserteq_str("setting", (char *)ptr + 0x86);
	487	ut_asserteq(STRING_PREFIX, ptr[0x8e]);
	488	ut_asserteq_str("sunrise ohoka", (char *)(ptr + 0x8f));
	489
490	return 0;
491	}
e180c2b1	492	DM_TEST(dm_test_acpi_dp_copy, UT_TESTF_SCAN_PDATA \| UT_TESTF_SCAN_FDT);