1 // SPDX-License-Identifier: GPL-2.0+
3 * Tests for ACPI table generation
5 * Copyright 2019 Google LLC
14 #include <tables_csum.h>
15 #include <version_string.h>
16 #include <acpi/acpigen.h>
17 #include <acpi/acpi_device.h>
18 #include <acpi/acpi_table.h>
19 #include <asm/global_data.h>
27 #define OEM_REVISION ((((version_num / 1000) % 10) << 28) | \
28 (((version_num / 100) % 10) << 24) | \
29 (((version_num / 10) % 10) << 20) | \
30 ((version_num % 10) << 16) | \
31 (((version_num_patch / 10) % 10) << 12) | \
32 ((version_num_patch % 10) << 8) | \
36 * struct testacpi_plat - Platform data for the test ACPI device
38 * @no_name: true to emit an empty ACPI name from testacpi_get_name()
39 * @return_error: true to return an error instead of a name
41 struct testacpi_plat {
47 * setup_ctx_and_base_tables() - Set up context along with RSDP, RSDT and XSDT
49 * Set up the context with the given start position. Some basic tables are
50 * always needed, so set them up as well.
52 * @ctx: Context to set up
54 static int setup_ctx_and_base_tables(struct unit_test_state *uts,
55 struct acpi_ctx *ctx, ulong start)
57 struct acpi_writer *entry = ACPI_WRITER_GET(0base);
59 acpi_setup_ctx(ctx, start);
61 ctx->tab_start = ctx->current;
62 ut_assertok(acpi_write_one(ctx, entry));
67 static int testacpi_write_tables(const struct udevice *dev,
70 struct acpi_dmar *dmar;
73 dmar = (struct acpi_dmar *)ctx->current;
74 acpi_create_dmar(dmar, DMAR_INTR_REMAP);
75 ctx->current += sizeof(struct acpi_dmar);
76 ret = acpi_add_table(ctx, dmar);
78 return log_msg_ret("add", ret);
83 static int testacpi_get_name(const struct udevice *dev, char *out_name)
85 struct testacpi_plat *plat = dev_get_plat(dev);
87 if (plat->return_error)
93 if (device_get_uclass_id(dev->parent) == UCLASS_TEST_ACPI)
94 return acpi_copy_name(out_name, ACPI_TEST_CHILD_NAME);
96 return acpi_copy_name(out_name, ACPI_TEST_DEV_NAME);
99 static int testacpi_fill_ssdt(const struct udevice *dev, struct acpi_ctx *ctx)
103 data = dev_read_string(dev, "acpi-ssdt-test-data");
106 acpigen_emit_byte(ctx, *data++);
112 static int testacpi_inject_dsdt(const struct udevice *dev, struct acpi_ctx *ctx)
116 data = dev_read_string(dev, "acpi-dsdt-test-data");
119 acpigen_emit_byte(ctx, *data++);
125 struct acpi_ops testacpi_ops = {
126 .get_name = testacpi_get_name,
127 .write_tables = testacpi_write_tables,
128 .fill_ssdt = testacpi_fill_ssdt,
129 .inject_dsdt = testacpi_inject_dsdt,
132 static const struct udevice_id testacpi_ids[] = {
133 { .compatible = "denx,u-boot-acpi-test" },
137 U_BOOT_DRIVER(testacpi_drv) = {
138 .name = "testacpi_drv",
139 .of_match = testacpi_ids,
140 .id = UCLASS_TEST_ACPI,
141 .bind = dm_scan_fdt_dev,
142 .plat_auto = sizeof(struct testacpi_plat),
143 ACPI_OPS_PTR(&testacpi_ops)
146 UCLASS_DRIVER(testacpi) = {
148 .id = UCLASS_TEST_ACPI,
151 /* Test ACPI get_name() */
152 static int dm_test_acpi_get_name(struct unit_test_state *uts)
154 char name[ACPI_NAME_MAX];
155 struct udevice *dev, *dev2, *i2c, *spi, *timer, *sound;
156 struct udevice *pci, *root;
158 /* Test getting the name from the driver */
159 ut_assertok(uclass_first_device_err(UCLASS_TEST_ACPI, &dev));
160 ut_assertok(acpi_get_name(dev, name));
161 ut_asserteq_str(ACPI_TEST_DEV_NAME, name);
163 /* Test getting the name from the device tree */
164 ut_assertok(uclass_get_device_by_name(UCLASS_TEST_FDT, "a-test",
166 ut_assertok(acpi_get_name(dev2, name));
167 ut_asserteq_str("GHIJ", name);
169 /* Test getting the name from acpi_device_get_name() */
170 ut_assertok(uclass_first_device_err(UCLASS_I2C, &i2c));
171 ut_assertok(acpi_get_name(i2c, name));
172 ut_asserteq_str("I2C0", name);
174 ut_assertok(uclass_first_device_err(UCLASS_SPI, &spi));
175 ut_assertok(acpi_get_name(spi, name));
176 ut_asserteq_str("SPI0", name);
178 /* ACPI doesn't know about the timer */
179 ut_assertok(uclass_first_device_err(UCLASS_TIMER, &timer));
180 ut_asserteq(-ENOENT, acpi_get_name(timer, name));
182 /* May as well test the rest of the cases */
183 ut_assertok(uclass_first_device_err(UCLASS_SOUND, &sound));
184 ut_assertok(acpi_get_name(sound, name));
185 ut_asserteq_str("HDAS", name);
187 ut_assertok(uclass_first_device_err(UCLASS_PCI, &pci));
188 ut_assertok(acpi_get_name(pci, name));
189 ut_asserteq_str("PCI0", name);
191 ut_assertok(uclass_first_device_err(UCLASS_ROOT, &root));
192 ut_assertok(acpi_get_name(root, name));
193 ut_asserteq_str("\\_SB", name);
195 /* Note that we don't have tests for acpi_name_from_id() */
199 DM_TEST(dm_test_acpi_get_name, UT_TESTF_SCAN_PDATA | UT_TESTF_SCAN_FDT);
201 /* Test acpi_get_table_revision() */
202 static int dm_test_acpi_get_table_revision(struct unit_test_state *uts)
204 ut_asserteq(1, acpi_get_table_revision(ACPITAB_MCFG));
205 ut_asserteq(2, acpi_get_table_revision(ACPITAB_RSDP));
206 ut_asserteq(4, acpi_get_table_revision(ACPITAB_TPM2));
207 ut_asserteq(-EINVAL, acpi_get_table_revision(ACPITAB_COUNT));
211 DM_TEST(dm_test_acpi_get_table_revision,
212 UT_TESTF_SCAN_PDATA | UT_TESTF_SCAN_FDT);
214 /* Test acpi_create_dmar() */
215 static int dm_test_acpi_create_dmar(struct unit_test_state *uts)
217 struct acpi_dmar dmar;
220 ut_assertok(uclass_first_device_err(UCLASS_CPU, &cpu));
221 ut_assertnonnull(cpu);
222 ut_assertok(acpi_create_dmar(&dmar, DMAR_INTR_REMAP));
223 ut_asserteq(DMAR_INTR_REMAP, dmar.flags);
224 ut_asserteq(32 - 1, dmar.host_address_width);
228 DM_TEST(dm_test_acpi_create_dmar, UT_TESTF_SCAN_PDATA | UT_TESTF_SCAN_FDT);
230 /* Test acpi_fill_header() */
231 static int dm_test_acpi_fill_header(struct unit_test_state *uts)
233 struct acpi_table_header hdr;
235 /* Make sure these 5 fields are not changed */
239 hdr.aslc_revision = 0x44;
240 acpi_fill_header(&hdr, "ABCD");
242 ut_asserteq_mem("ABCD", hdr.signature, sizeof(hdr.signature));
243 ut_asserteq(0x11, hdr.length);
244 ut_asserteq(0x22, hdr.revision);
245 ut_asserteq(0x33, hdr.checksum);
246 ut_asserteq_mem(OEM_ID, hdr.oem_id, sizeof(hdr.oem_id));
247 ut_asserteq_mem(OEM_TABLE_ID, hdr.oem_table_id,
248 sizeof(hdr.oem_table_id));
249 ut_asserteq(OEM_REVISION, hdr.oem_revision);
250 ut_asserteq_mem(ASLC_ID, hdr.aslc_id, sizeof(hdr.aslc_id));
251 ut_asserteq(0x44, hdr.aslc_revision);
255 DM_TEST(dm_test_acpi_fill_header, UT_TESTF_SCAN_PDATA | UT_TESTF_SCAN_FDT);
257 /* Test ACPI write_tables() */
258 static int dm_test_acpi_write_tables(struct unit_test_state *uts)
260 struct acpi_dmar *dmar;
266 buf = malloc(BUF_SIZE);
267 ut_assertnonnull(buf);
268 addr = map_to_sysmem(buf);
270 ut_assertok(setup_ctx_and_base_tables(uts, &ctx, addr));
272 ut_assertok(acpi_write_dev_tables(&ctx));
275 * We should have three dmar tables, one for each
276 * "denx,u-boot-acpi-test" device
278 ut_asserteq_ptr(dmar + 3, ctx.current);
279 ut_asserteq(DMAR_INTR_REMAP, dmar->flags);
280 ut_asserteq(32 - 1, dmar->host_address_width);
282 ut_asserteq(DMAR_INTR_REMAP, dmar[1].flags);
283 ut_asserteq(32 - 1, dmar[1].host_address_width);
285 ut_asserteq(DMAR_INTR_REMAP, dmar[2].flags);
286 ut_asserteq(32 - 1, dmar[2].host_address_width);
288 /* Check that the pointers were added correctly */
289 for (i = 0; i < 3; i++) {
290 ut_asserteq(map_to_sysmem(dmar + i), ctx.rsdt->entry[i]);
291 ut_asserteq(map_to_sysmem(dmar + i), ctx.xsdt->entry[i]);
293 ut_asserteq(0, ctx.rsdt->entry[3]);
294 ut_asserteq(0, ctx.xsdt->entry[3]);
298 DM_TEST(dm_test_acpi_write_tables, UT_TESTF_SCAN_PDATA | UT_TESTF_SCAN_FDT);
300 /* Test basic ACPI functions */
301 static int dm_test_acpi_basic(struct unit_test_state *uts)
305 /* Check align works */
306 ctx.current = (void *)5;
308 ut_asserteq_ptr((void *)16, ctx.current);
310 /* Check that align does nothing if already aligned */
312 ut_asserteq_ptr((void *)16, ctx.current);
314 ut_asserteq_ptr((void *)64, ctx.current);
316 ut_asserteq_ptr((void *)64, ctx.current);
318 /* Check incrementing */
320 ut_asserteq_ptr((void *)67, ctx.current);
321 acpi_inc_align(&ctx, 3);
322 ut_asserteq_ptr((void *)80, ctx.current);
326 DM_TEST(dm_test_acpi_basic, UT_TESTF_SCAN_PDATA | UT_TESTF_SCAN_FDT);
328 /* Test setup_ctx_and_base_tables */
329 static int dm_test_setup_ctx_and_base_tables(struct unit_test_state *uts)
331 struct acpi_rsdp *rsdp;
332 struct acpi_rsdt *rsdt;
333 struct acpi_xsdt *xsdt;
339 * Use an unaligned address deliberately, by allocating an aligned
340 * address and then adding 4 to it
342 buf = memalign(64, BUF_SIZE);
343 ut_assertnonnull(buf);
344 addr = map_to_sysmem(buf);
345 ut_assertok(setup_ctx_and_base_tables(uts, &ctx, addr + 4));
346 ut_asserteq(map_to_sysmem(PTR_ALIGN(buf + 4, 16)), gd_acpi_start());
349 ut_asserteq_ptr(rsdp, ctx.rsdp);
350 ut_asserteq_mem(RSDP_SIG, rsdp->signature, sizeof(rsdp->signature));
351 ut_asserteq(sizeof(*rsdp), rsdp->length);
352 ut_assertok(table_compute_checksum(rsdp, 20));
353 ut_assertok(table_compute_checksum(rsdp, sizeof(*rsdp)));
355 rsdt = PTR_ALIGN((void *)rsdp + sizeof(*rsdp), 16);
356 ut_asserteq_ptr(rsdt, ctx.rsdt);
357 ut_asserteq_mem("RSDT", rsdt->header.signature, ACPI_NAME_LEN);
358 ut_asserteq(sizeof(*rsdt), rsdt->header.length);
359 ut_assertok(table_compute_checksum(rsdt, sizeof(*rsdt)));
361 xsdt = PTR_ALIGN((void *)rsdt + sizeof(*rsdt), 16);
362 ut_asserteq_ptr(xsdt, ctx.xsdt);
363 ut_asserteq_mem("XSDT", xsdt->header.signature, ACPI_NAME_LEN);
364 ut_asserteq(sizeof(*xsdt), xsdt->header.length);
365 ut_assertok(table_compute_checksum(xsdt, sizeof(*xsdt)));
367 end = PTR_ALIGN((void *)xsdt + sizeof(*xsdt), 64);
368 ut_asserteq_ptr(end, ctx.current);
370 ut_asserteq(map_to_sysmem(rsdt), rsdp->rsdt_address);
371 ut_asserteq(map_to_sysmem(xsdt), rsdp->xsdt_address);
375 DM_TEST(dm_test_setup_ctx_and_base_tables,
376 UT_TESTF_SCAN_PDATA | UT_TESTF_SCAN_FDT);
378 /* Test 'acpi list' command */
379 static int dm_test_acpi_cmd_list(struct unit_test_state *uts)
385 buf = memalign(16, BUF_SIZE);
386 ut_assertnonnull(buf);
387 addr = map_to_sysmem(buf);
388 ut_assertok(setup_ctx_and_base_tables(uts, &ctx, addr));
390 ut_assertok(acpi_write_dev_tables(&ctx));
392 console_record_reset();
393 run_command("acpi list", 0);
394 ut_assert_nextline("Name Base Size Detail");
395 ut_assert_nextline("---- -------- ----- ------");
396 ut_assert_nextline("RSDP %08lx %5zx v02 U-BOOT", addr,
397 sizeof(struct acpi_rsdp));
398 addr = ALIGN(addr + sizeof(struct acpi_rsdp), 16);
399 ut_assert_nextline("RSDT %08lx %5zx v01 U-BOOT U-BOOTBL %x INTL 0",
400 addr, sizeof(struct acpi_table_header) +
401 3 * sizeof(u32), OEM_REVISION);
402 addr = ALIGN(addr + sizeof(struct acpi_rsdt), 16);
403 ut_assert_nextline("XSDT %08lx %5zx v01 U-BOOT U-BOOTBL %x INTL 0",
404 addr, sizeof(struct acpi_table_header) +
405 3 * sizeof(u64), OEM_REVISION);
406 addr = ALIGN(addr + sizeof(struct acpi_xsdt), 64);
407 ut_assert_nextline("DMAR %08lx %5zx v01 U-BOOT U-BOOTBL %x INTL 0",
408 addr, sizeof(struct acpi_dmar), OEM_REVISION);
409 addr = ALIGN(addr + sizeof(struct acpi_dmar), 16);
410 ut_assert_nextline("DMAR %08lx %5zx v01 U-BOOT U-BOOTBL %x INTL 0",
411 addr, sizeof(struct acpi_dmar), OEM_REVISION);
412 addr = ALIGN(addr + sizeof(struct acpi_dmar), 16);
413 ut_assert_nextline("DMAR %08lx %5zx v01 U-BOOT U-BOOTBL %x INTL 0",
414 addr, sizeof(struct acpi_dmar), OEM_REVISION);
415 ut_assert_console_end();
419 DM_TEST(dm_test_acpi_cmd_list, UT_TESTF_SCAN_PDATA | UT_TESTF_SCAN_FDT);
421 /* Test 'acpi dump' command */
422 static int dm_test_acpi_cmd_dump(struct unit_test_state *uts)
428 buf = memalign(16, BUF_SIZE);
429 ut_assertnonnull(buf);
430 addr = map_to_sysmem(buf);
431 ut_assertok(setup_ctx_and_base_tables(uts, &ctx, addr));
433 ut_assertok(acpi_write_dev_tables(&ctx));
435 /* First search for a non-existent table */
436 console_record_reset();
437 run_command("acpi dump rdst", 0);
438 ut_assert_nextline("Table 'RDST' not found");
439 ut_assert_console_end();
441 /* Now a real table */
442 console_record_reset();
443 run_command("acpi dump dmar", 0);
444 addr = ALIGN(map_to_sysmem(ctx.xsdt) + sizeof(struct acpi_xsdt), 64);
445 ut_assert_nextline("DMAR @ %08lx", addr);
446 ut_assert_nextlines_are_dump(0x30);
447 ut_assert_console_end();
451 DM_TEST(dm_test_acpi_cmd_dump, UT_TESTF_SCAN_PDATA | UT_TESTF_SCAN_FDT);
453 /* Test acpi_device_path() */
454 static int dm_test_acpi_device_path(struct unit_test_state *uts)
456 struct testacpi_plat *plat;
457 char buf[ACPI_PATH_MAX];
458 struct udevice *dev, *child;
460 ut_assertok(uclass_first_device_err(UCLASS_TEST_ACPI, &dev));
461 ut_assertok(acpi_device_path(dev, buf, sizeof(buf)));
462 ut_asserteq_str("\\_SB." ACPI_TEST_DEV_NAME, buf);
464 /* Test running out of space */
466 ut_asserteq(-ENOSPC, acpi_device_path(dev, buf, 5));
467 ut_asserteq('\0', buf[5]);
469 /* Test a three-component name */
470 ut_assertok(device_first_child_err(dev, &child));
471 ut_assertok(acpi_device_path(child, buf, sizeof(buf)));
472 ut_asserteq_str("\\_SB." ACPI_TEST_DEV_NAME "." ACPI_TEST_CHILD_NAME,
475 /* Test handling of a device which doesn't produce a name */
476 plat = dev_get_plat(dev);
477 plat->no_name = true;
478 ut_assertok(acpi_device_path(child, buf, sizeof(buf)));
479 ut_asserteq_str("\\_SB." ACPI_TEST_CHILD_NAME, buf);
481 /* Test handling of a device which returns an error */
482 plat = dev_get_plat(dev);
483 plat->return_error = true;
484 ut_asserteq(-EINVAL, acpi_device_path(child, buf, sizeof(buf)));
488 DM_TEST(dm_test_acpi_device_path, UT_TESTF_SCAN_PDATA | UT_TESTF_SCAN_FDT);
490 /* Test acpi_device_status() */
491 static int dm_test_acpi_device_status(struct unit_test_state *uts)
495 ut_assertok(uclass_first_device_err(UCLASS_TEST_ACPI, &dev));
496 ut_asserteq(ACPI_DSTATUS_ALL_ON, acpi_device_status(dev));
500 DM_TEST(dm_test_acpi_device_status, UT_TESTF_SCAN_PDATA | UT_TESTF_SCAN_FDT);
502 /* Test acpi_fill_ssdt() */
503 static int dm_test_acpi_fill_ssdt(struct unit_test_state *uts)
508 buf = malloc(BUF_SIZE);
509 ut_assertnonnull(buf);
513 buf[4] = 'z'; /* sentinel */
514 ut_assertok(acpi_fill_ssdt(&ctx));
517 * These values come from acpi-test2's acpi-ssdt-test-data property.
518 * This device comes first because of u-boot,acpi-ssdt-order
520 ut_asserteq('c', buf[0]);
521 ut_asserteq('d', buf[1]);
523 /* These values come from acpi-test's acpi-ssdt-test-data property */
524 ut_asserteq('a', buf[2]);
525 ut_asserteq('b', buf[3]);
527 ut_asserteq('z', buf[4]);
531 DM_TEST(dm_test_acpi_fill_ssdt, UT_TESTF_SCAN_PDATA | UT_TESTF_SCAN_FDT);
533 /* Test acpi_inject_dsdt() */
534 static int dm_test_acpi_inject_dsdt(struct unit_test_state *uts)
539 buf = malloc(BUF_SIZE);
540 ut_assertnonnull(buf);
544 buf[4] = 'z'; /* sentinel */
545 ut_assertok(acpi_inject_dsdt(&ctx));
548 * These values come from acpi-test's acpi-dsdt-test-data property.
549 * There is no u-boot,acpi-dsdt-order so device-tree order is used.
551 ut_asserteq('h', buf[0]);
552 ut_asserteq('i', buf[1]);
554 /* These values come from acpi-test's acpi-dsdt-test-data property */
555 ut_asserteq('j', buf[2]);
556 ut_asserteq('k', buf[3]);
558 ut_asserteq('z', buf[4]);
562 DM_TEST(dm_test_acpi_inject_dsdt, UT_TESTF_SCAN_PDATA | UT_TESTF_SCAN_FDT);
564 /* Test 'acpi items' command */
565 static int dm_test_acpi_cmd_items(struct unit_test_state *uts)
571 buf = malloc(BUF_SIZE);
572 ut_assertnonnull(buf);
573 addr = map_to_sysmem(buf);
577 ut_assertok(acpi_fill_ssdt(&ctx));
578 console_record_reset();
579 run_command("acpi items", 0);
580 ut_assert_nextline("Seq Type Base Size Device/Writer");
581 ut_assert_nextline("--- ----- -------- ---- -------------");
582 ut_assert_nextline(" 0 ssdt %8lx 2 acpi-test", addr);
583 ut_assert_nextline(" 1 ssdt %8lx 2 acpi-test2", addr + 2);
584 ut_assert_console_end();
588 ut_assertok(acpi_inject_dsdt(&ctx));
589 console_record_reset();
590 run_command("acpi items", 0);
591 ut_assert_nextlinen("Seq");
592 ut_assert_nextlinen("---");
593 ut_assert_nextline(" 0 dsdt %8lx 2 acpi-test", addr);
594 ut_assert_nextline(" 1 dsdt %8lx 2 acpi-test2", addr + 2);
595 ut_assert_console_end();
597 console_record_reset();
598 run_command("acpi items -d", 0);
599 ut_assert_nextlinen("Seq");
600 ut_assert_nextlinen("---");
601 ut_assert_nextline(" 0 dsdt %8lx 2 acpi-test", addr);
602 ut_assert_nextlines_are_dump(2);
603 ut_assert_nextline("%s", "");
604 ut_assert_nextline(" 1 dsdt %8lx 2 acpi-test2", addr + 2);
605 ut_assert_nextlines_are_dump(2);
606 ut_assert_nextline("%s", "");
607 ut_assert_console_end();
611 DM_TEST(dm_test_acpi_cmd_items, UT_TESTF_SCAN_PDATA | UT_TESTF_SCAN_FDT);
613 /* Test 'acpi set' command */
614 static int dm_test_acpi_cmd_set(struct unit_test_state *uts)
620 gd_set_acpi_start(0);
622 console_record_reset();
623 ut_asserteq(0, gd_acpi_start());
624 ut_assertok(run_command("acpi set", 0));
625 ut_assert_nextline("ACPI pointer: 0");
627 buf = memalign(16, BUF_SIZE);
628 ut_assertnonnull(buf);
629 addr = map_to_sysmem(buf);
630 ut_assertok(setup_ctx_and_base_tables(uts, &ctx, addr));
632 ut_assertok(acpi_write_dev_tables(&ctx));
634 ut_assertok(run_command("acpi set", 0));
635 ut_assert_nextline("ACPI pointer: %lx", addr);
637 ut_assertok(run_command("acpi set 0", 0));
638 ut_assert_nextline("Setting ACPI pointer to 0");
639 ut_asserteq(0, gd_acpi_start());
641 ut_assertok(run_commandf("acpi set %lx", addr));
642 ut_assert_nextline("Setting ACPI pointer to %lx", addr);
643 ut_asserteq(addr, gd_acpi_start());
645 ut_assert_console_end();
649 DM_TEST(dm_test_acpi_cmd_set, UT_TESTF_SCAN_PDATA | UT_TESTF_SCAN_FDT);