1 // SPDX-License-Identifier: GPL-2.0+
3 * Tests for ACPI table generation
5 * Copyright 2019 Google LLC
6 * Written by Simon Glass <sjg@chromium.org>
13 #include <tables_csum.h>
15 #include <acpi/acpi_table.h>
20 #define ACPI_TEST_DEV_NAME "ABCD"
23 static int testacpi_write_tables(const struct udevice *dev,
26 struct acpi_dmar *dmar;
29 dmar = (struct acpi_dmar *)ctx->current;
30 acpi_create_dmar(dmar, DMAR_INTR_REMAP);
31 ctx->current += sizeof(struct acpi_dmar);
32 ret = acpi_add_table(ctx, dmar);
34 return log_msg_ret("add", ret);
39 static int testacpi_get_name(const struct udevice *dev, char *out_name)
41 return acpi_copy_name(out_name, ACPI_TEST_DEV_NAME);
44 struct acpi_ops testacpi_ops = {
45 .get_name = testacpi_get_name,
46 .write_tables = testacpi_write_tables,
49 static const struct udevice_id testacpi_ids[] = {
50 { .compatible = "denx,u-boot-acpi-test" },
54 U_BOOT_DRIVER(testacpi_drv) = {
55 .name = "testacpi_drv",
56 .of_match = testacpi_ids,
57 .id = UCLASS_TEST_ACPI,
58 ACPI_OPS_PTR(&testacpi_ops)
61 UCLASS_DRIVER(testacpi) = {
63 .id = UCLASS_TEST_ACPI,
66 /* Test ACPI get_name() */
67 static int dm_test_acpi_get_name(struct unit_test_state *uts)
69 char name[ACPI_NAME_MAX];
72 ut_assertok(uclass_first_device_err(UCLASS_TEST_ACPI, &dev));
73 ut_assertok(acpi_get_name(dev, name));
74 ut_asserteq_str(ACPI_TEST_DEV_NAME, name);
78 DM_TEST(dm_test_acpi_get_name, DM_TESTF_SCAN_PDATA | DM_TESTF_SCAN_FDT);
80 /* Test acpi_get_table_revision() */
81 static int dm_test_acpi_get_table_revision(struct unit_test_state *uts)
83 ut_asserteq(1, acpi_get_table_revision(ACPITAB_MCFG));
84 ut_asserteq(2, acpi_get_table_revision(ACPITAB_RSDP));
85 ut_asserteq(4, acpi_get_table_revision(ACPITAB_TPM2));
86 ut_asserteq(-EINVAL, acpi_get_table_revision(ACPITAB_COUNT));
90 DM_TEST(dm_test_acpi_get_table_revision,
91 DM_TESTF_SCAN_PDATA | DM_TESTF_SCAN_FDT);
93 /* Test acpi_create_dmar() */
94 static int dm_test_acpi_create_dmar(struct unit_test_state *uts)
96 struct acpi_dmar dmar;
98 ut_assertok(acpi_create_dmar(&dmar, DMAR_INTR_REMAP));
99 ut_asserteq(DMAR_INTR_REMAP, dmar.flags);
100 ut_asserteq(32 - 1, dmar.host_address_width);
104 DM_TEST(dm_test_acpi_create_dmar, DM_TESTF_SCAN_PDATA | DM_TESTF_SCAN_FDT);
106 /* Test acpi_fill_header() */
107 static int dm_test_acpi_fill_header(struct unit_test_state *uts)
109 struct acpi_table_header hdr;
111 /* Make sure these 5 fields are not changed */
115 hdr.aslc_revision = 0x44;
116 acpi_fill_header(&hdr, "ABCD");
118 ut_asserteq_mem("ABCD", hdr.signature, sizeof(hdr.signature));
119 ut_asserteq(0x11, hdr.length);
120 ut_asserteq(0x22, hdr.revision);
121 ut_asserteq(0x33, hdr.checksum);
122 ut_asserteq_mem(OEM_ID, hdr.oem_id, sizeof(hdr.oem_id));
123 ut_asserteq_mem(OEM_TABLE_ID, hdr.oem_table_id,
124 sizeof(hdr.oem_table_id));
125 ut_asserteq(U_BOOT_BUILD_DATE, hdr.oem_revision);
126 ut_asserteq_mem(ASLC_ID, hdr.aslc_id, sizeof(hdr.aslc_id));
127 ut_asserteq(0x44, hdr.aslc_revision);
131 DM_TEST(dm_test_acpi_fill_header, DM_TESTF_SCAN_PDATA | DM_TESTF_SCAN_FDT);
133 /* Test ACPI write_tables() */
134 static int dm_test_acpi_write_tables(struct unit_test_state *uts)
136 struct acpi_dmar *dmar;
140 buf = malloc(BUF_SIZE);
141 ut_assertnonnull(buf);
143 acpi_setup_base_tables(&ctx, buf);
145 ut_assertok(acpi_write_dev_tables(&ctx));
148 * We should have two dmar tables, one for each "denx,u-boot-acpi-test"
151 ut_asserteq_ptr(dmar + 2, ctx.current);
152 ut_asserteq(DMAR_INTR_REMAP, dmar->flags);
153 ut_asserteq(32 - 1, dmar->host_address_width);
155 ut_asserteq(DMAR_INTR_REMAP, dmar[1].flags);
156 ut_asserteq(32 - 1, dmar[1].host_address_width);
158 /* Check that the pointers were added correctly */
159 ut_asserteq(map_to_sysmem(dmar), ctx.rsdt->entry[0]);
160 ut_asserteq(map_to_sysmem(dmar + 1), ctx.rsdt->entry[1]);
161 ut_asserteq(0, ctx.rsdt->entry[2]);
165 DM_TEST(dm_test_acpi_write_tables, DM_TESTF_SCAN_PDATA | DM_TESTF_SCAN_FDT);
167 /* Test basic ACPI functions */
168 static int dm_test_acpi_basic(struct unit_test_state *uts)
172 /* Check align works */
173 ctx.current = (void *)5;
175 ut_asserteq_ptr((void *)16, ctx.current);
177 /* Check that align does nothing if already aligned */
179 ut_asserteq_ptr((void *)16, ctx.current);
181 ut_asserteq_ptr((void *)64, ctx.current);
183 ut_asserteq_ptr((void *)64, ctx.current);
185 /* Check incrementing */
187 ut_asserteq_ptr((void *)67, ctx.current);
188 acpi_inc_align(&ctx, 3);
189 ut_asserteq_ptr((void *)80, ctx.current);
193 DM_TEST(dm_test_acpi_basic, DM_TESTF_SCAN_PDATA | DM_TESTF_SCAN_FDT);
195 /* Test acpi_setup_base_tables */
196 static int dm_test_acpi_setup_base_tables(struct unit_test_state *uts)
198 struct acpi_rsdp *rsdp;
199 struct acpi_rsdt *rsdt;
200 struct acpi_xsdt *xsdt;
205 * Use an unaligned address deliberately, by allocating an aligned
206 * address and then adding 4 to it
208 buf = memalign(64, BUF_SIZE);
209 ut_assertnonnull(buf);
210 acpi_setup_base_tables(&ctx, buf + 4);
213 ut_asserteq_ptr(rsdp, ctx.rsdp);
214 ut_assertok(memcmp(RSDP_SIG, rsdp->signature, sizeof(rsdp->signature)));
215 ut_asserteq(sizeof(*rsdp), rsdp->length);
216 ut_assertok(table_compute_checksum(rsdp, 20));
217 ut_assertok(table_compute_checksum(rsdp, sizeof(*rsdp)));
219 rsdt = PTR_ALIGN((void *)rsdp + sizeof(*rsdp), 16);
220 ut_asserteq_ptr(rsdt, ctx.rsdt);
221 ut_assertok(memcmp("RSDT", rsdt->header.signature, ACPI_NAME_LEN));
222 ut_asserteq(sizeof(*rsdt), rsdt->header.length);
223 ut_assertok(table_compute_checksum(rsdt, sizeof(*rsdt)));
225 xsdt = PTR_ALIGN((void *)rsdt + sizeof(*rsdt), 16);
226 ut_assertok(memcmp("XSDT", xsdt->header.signature, ACPI_NAME_LEN));
227 ut_asserteq(sizeof(*xsdt), xsdt->header.length);
228 ut_assertok(table_compute_checksum(xsdt, sizeof(*xsdt)));
230 end = PTR_ALIGN((void *)xsdt + sizeof(*xsdt), 64);
231 ut_asserteq_ptr(end, ctx.current);
233 ut_asserteq(map_to_sysmem(rsdt), rsdp->rsdt_address);
234 ut_asserteq(map_to_sysmem(xsdt), rsdp->xsdt_address);
238 DM_TEST(dm_test_acpi_setup_base_tables,
239 DM_TESTF_SCAN_PDATA | DM_TESTF_SCAN_FDT);