| // 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); |