test/dm/acpi.c

   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 <sjg@chromium.org>
   7  */
   8
   9 #include <common.h>
  10 #include <dm.h>
  11 #include <mapmem.h>
  12 #include <version.h>
  13 #include <acpi/acpi_table.h>
  14 #include <dm/acpi.h>
  15 #include <dm/test.h>
  16 #include <test/ut.h>
  17
  18 #define ACPI_TEST_DEV_NAME      "ABCD"
  19 #define BUF_SIZE                4096
  20
  21 static int testacpi_write_tables(const struct udevice *dev,
  22                                  struct acpi_ctx *ctx)
  23 {
  24         struct acpi_dmar *dmar;
  25         int ret;
  26
  27         dmar = (struct acpi_dmar *)ctx->current;
  28         acpi_create_dmar(dmar, DMAR_INTR_REMAP);
  29         ctx->current += sizeof(struct acpi_dmar);
  30         ret = acpi_add_table(ctx, dmar);
  31         if (ret)
  32                 return log_msg_ret("add", ret);
  33
  34         return 0;
  35 }
  36
  37 static int testacpi_get_name(const struct udevice *dev, char *out_name)
  38 {
  39         return acpi_copy_name(out_name, ACPI_TEST_DEV_NAME);
  40 }
  41
  42 struct acpi_ops testacpi_ops = {
  43         .get_name       = testacpi_get_name,
  44         .write_tables   = testacpi_write_tables,
  45 };
  46
  47 static const struct udevice_id testacpi_ids[] = {
  48         { .compatible = "denx,u-boot-acpi-test" },
  49         { }
  50 };
  51
  52 U_BOOT_DRIVER(testacpi_drv) = {
  53         .name   = "testacpi_drv",
  54         .of_match       = testacpi_ids,
  55         .id     = UCLASS_TEST_ACPI,
  56         ACPI_OPS_PTR(&testacpi_ops)
  57 };
  58
  59 UCLASS_DRIVER(testacpi) = {
  60         .name           = "testacpi",
  61         .id             = UCLASS_TEST_ACPI,
  62 };
  63
  64 /* Test ACPI get_name() */
  65 static int dm_test_acpi_get_name(struct unit_test_state *uts)
  66 {
  67         char name[ACPI_NAME_MAX];
  68         struct udevice *dev;
  69
  70         ut_assertok(uclass_first_device_err(UCLASS_TEST_ACPI, &dev));
  71         ut_assertok(acpi_get_name(dev, name));
  72         ut_asserteq_str(ACPI_TEST_DEV_NAME, name);
  73
  74         return 0;
  75 }
  76 DM_TEST(dm_test_acpi_get_name, DM_TESTF_SCAN_PDATA | DM_TESTF_SCAN_FDT);
  77
  78 /* Test acpi_get_table_revision() */
  79 static int dm_test_acpi_get_table_revision(struct unit_test_state *uts)
  80 {
  81         ut_asserteq(1, acpi_get_table_revision(ACPITAB_MCFG));
  82         ut_asserteq(2, acpi_get_table_revision(ACPITAB_RSDP));
  83         ut_asserteq(4, acpi_get_table_revision(ACPITAB_TPM2));
  84         ut_asserteq(-EINVAL, acpi_get_table_revision(ACPITAB_COUNT));
  85
  86         return 0;
  87 }
  88 DM_TEST(dm_test_acpi_get_table_revision,
  89         DM_TESTF_SCAN_PDATA | DM_TESTF_SCAN_FDT);
  90
  91 /* Test acpi_create_dmar() */
  92 static int dm_test_acpi_create_dmar(struct unit_test_state *uts)
  93 {
  94         struct acpi_dmar dmar;
  95
  96         ut_assertok(acpi_create_dmar(&dmar, DMAR_INTR_REMAP));
  97         ut_asserteq(DMAR_INTR_REMAP, dmar.flags);
  98         ut_asserteq(32 - 1, dmar.host_address_width);
  99
 100         return 0;
 101 }
 102 DM_TEST(dm_test_acpi_create_dmar, DM_TESTF_SCAN_PDATA | DM_TESTF_SCAN_FDT);
 103
 104 /* Test acpi_fill_header() */
 105 static int dm_test_acpi_fill_header(struct unit_test_state *uts)
 106 {
 107         struct acpi_table_header hdr;
 108
 109         /* Make sure these 5 fields are not changed */
 110         hdr.length = 0x11;
 111         hdr.revision = 0x22;
 112         hdr.checksum = 0x33;
 113         hdr.aslc_revision = 0x44;
 114         acpi_fill_header(&hdr, "ABCD");
 115
 116         ut_asserteq_mem("ABCD", hdr.signature, sizeof(hdr.signature));
 117         ut_asserteq(0x11, hdr.length);
 118         ut_asserteq(0x22, hdr.revision);
 119         ut_asserteq(0x33, hdr.checksum);
 120         ut_asserteq_mem(OEM_ID, hdr.oem_id, sizeof(hdr.oem_id));
 121         ut_asserteq_mem(OEM_TABLE_ID, hdr.oem_table_id,
 122                         sizeof(hdr.oem_table_id));
 123         ut_asserteq(U_BOOT_BUILD_DATE, hdr.oem_revision);
 124         ut_asserteq_mem(ASLC_ID, hdr.aslc_id, sizeof(hdr.aslc_id));
 125         ut_asserteq(0x44, hdr.aslc_revision);
 126
 127         return 0;
 128 }
 129 DM_TEST(dm_test_acpi_fill_header, DM_TESTF_SCAN_PDATA | DM_TESTF_SCAN_FDT);
 130
 131 /* Test ACPI write_tables() */
 132 static int dm_test_acpi_write_tables(struct unit_test_state *uts)
 133 {
 134         struct acpi_dmar *dmar;
 135         struct acpi_xsdt *xsdt;
 136         struct acpi_ctx ctx;
 137         void *buf;
 138
 139         buf = malloc(BUF_SIZE);
 140         ut_assertnonnull(buf);
 141
 142         ctx.current = buf;
 143         ctx.rsdp = ctx.current;
 144         acpi_inc_align(&ctx, sizeof(struct acpi_rsdp));
 145         ctx.rsdt = ctx.current;
 146         acpi_inc_align(&ctx, sizeof(struct acpi_rsdt));
 147         xsdt = ctx.current;
 148         acpi_inc_align(&ctx, sizeof(struct acpi_xsdt));
 149         ctx.rsdp->xsdt_address = map_to_sysmem(xsdt);
 150         dmar = ctx.current;
 151
 152         ut_assertok(acpi_write_dev_tables(&ctx));
 153
 154         /*
 155          * We should have two dmar tables, one for each "denx,u-boot-acpi-test"
 156          * device
 157          */
 158         ut_asserteq_ptr(dmar + 2, ctx.current);
 159         ut_asserteq(DMAR_INTR_REMAP, dmar->flags);
 160         ut_asserteq(32 - 1, dmar->host_address_width);
 161
 162         ut_asserteq(DMAR_INTR_REMAP, dmar[1].flags);
 163         ut_asserteq(32 - 1, dmar[1].host_address_width);
 164
 165         return 0;
 166 }
 167 DM_TEST(dm_test_acpi_write_tables, DM_TESTF_SCAN_PDATA | DM_TESTF_SCAN_FDT);
 168
 169 /* Test basic ACPI functions */
 170 static int dm_test_acpi_basic(struct unit_test_state *uts)
 171 {
 172         struct acpi_ctx ctx;
 173
 174         /* Check align works */
 175         ctx.current = (void *)5;
 176         acpi_align(&ctx);
 177         ut_asserteq_ptr((void *)16, ctx.current);
 178
 179         /* Check that align does nothing if already aligned */
 180         acpi_align(&ctx);
 181         ut_asserteq_ptr((void *)16, ctx.current);
 182         acpi_align64(&ctx);
 183         ut_asserteq_ptr((void *)64, ctx.current);
 184         acpi_align64(&ctx);
 185         ut_asserteq_ptr((void *)64, ctx.current);
 186
 187         /* Check incrementing */
 188         acpi_inc(&ctx, 3);
 189         ut_asserteq_ptr((void *)67, ctx.current);
 190         acpi_inc_align(&ctx, 3);
 191         ut_asserteq_ptr((void *)80, ctx.current);
 192
 193         return 0;
 194 }
 195 DM_TEST(dm_test_acpi_basic, DM_TESTF_SCAN_PDATA | DM_TESTF_SCAN_FDT);