Djam/u-boot
1
0
Fork 0
mirror of https://github.com/u-boot/u-boot.git synced 2025-04-21 20:34:38 +00:00
Code Issues Projects Releases Packages Wiki Activity Actions

acpi: Put table-setup code in its own function

Browse source 
We always write three basic tables to ACPI at the start. Move this into
its own function, along with acpi_fill_header(), so we can write a test
for this code.

Signed-off-by: Simon Glass <sjg@chromium.org>
This commit is contained in:
Simon Glass 2020-04-26 09:19:51 -06:00 • committed by Bin Meng
parent 29b351122e
commit 7e586f6907
4 changed files with 147 additions and 86 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

77
arch/x86/lib/acpi_table.c
View file

@ -31,58 +31,6 @@ extern const unsigned char AmlCode[];
/* ACPI RSDP address to be used in boot parameters */ /* ACPI RSDP address to be used in boot parameters */
static ulong acpi_rsdp_addr; static ulong acpi_rsdp_addr;
static void acpi_write_rsdp(struct acpi_rsdp *rsdp, struct acpi_rsdt *rsdt,
struct acpi_xsdt *xsdt)
{
memset(rsdp, 0, sizeof(struct acpi_rsdp));
memcpy(rsdp->signature, RSDP_SIG, 8);
memcpy(rsdp->oem_id, OEM_ID, 6);
rsdp->length = sizeof(struct acpi_rsdp);
rsdp->rsdt_address = (u32)rsdt;
rsdp->xsdt_address = (u64)(u32)xsdt;
rsdp->revision = ACPI_RSDP_REV_ACPI_2_0;
/* Calculate checksums */
rsdp->checksum = table_compute_checksum((void *)rsdp, 20);
rsdp->ext_checksum = table_compute_checksum((void *)rsdp,
sizeof(struct acpi_rsdp));
}
static void acpi_write_rsdt(struct acpi_rsdt *rsdt)
{
struct acpi_table_header *header = &(rsdt->header);
/* Fill out header fields */
acpi_fill_header(header, "RSDT");
header->length = sizeof(struct acpi_rsdt);
header->revision = 1;
/* Entries are filled in later, we come with an empty set */
/* Fix checksum */
header->checksum = table_compute_checksum((void *)rsdt,
sizeof(struct acpi_rsdt));
}
static void acpi_write_xsdt(struct acpi_xsdt *xsdt)
{
struct acpi_table_header *header = &(xsdt->header);
/* Fill out header fields */
acpi_fill_header(header, "XSDT");
header->length = sizeof(struct acpi_xsdt);
header->revision = 1;
/* Entries are filled in later, we come with an empty set */
/* Fix checksum */
header->checksum = table_compute_checksum((void *)xsdt,
sizeof(struct acpi_xsdt));
}
static void acpi_create_facs(struct acpi_facs *facs) static void acpi_create_facs(struct acpi_facs *facs)
{ {
memset((void *)facs, 0, sizeof(struct acpi_facs)); memset((void *)facs, 0, sizeof(struct acpi_facs));
@ -411,7 +359,6 @@ static void acpi_create_spcr(struct acpi_spcr *spcr)
ulong write_acpi_tables(ulong start_addr) ulong write_acpi_tables(ulong start_addr)
{ {
struct acpi_ctx sctx, *ctx = &sctx; struct acpi_ctx sctx, *ctx = &sctx;
struct acpi_xsdt *xsdt;
struct acpi_facs *facs; struct acpi_facs *facs;
struct acpi_table_header *dsdt; struct acpi_table_header *dsdt;
struct acpi_fadt *fadt; struct acpi_fadt *fadt;
@ -424,32 +371,10 @@ ulong write_acpi_tables(ulong start_addr)
int i; int i;
start = map_sysmem(start_addr, 0); start = map_sysmem(start_addr, 0);
ctx->current = start;
/* Align ACPI tables to 16 byte */
acpi_align(ctx);
debug("ACPI: Writing ACPI tables at %lx\n", start_addr); debug("ACPI: Writing ACPI tables at %lx\n", start_addr);
/* We need at least an RSDP and an RSDT Table */ acpi_setup_base_tables(ctx, start);
ctx->rsdp = ctx->current;
acpi_inc_align(ctx, sizeof(struct acpi_rsdp));
ctx->rsdt = ctx->current;
acpi_inc_align(ctx, sizeof(struct acpi_rsdt));
xsdt = ctx->current;
acpi_inc_align(ctx, sizeof(struct acpi_xsdt));
/*
* Per ACPI spec, the FACS table address must be aligned to a 64 byte
* boundary (Windows checks this, but Linux does not).
*/
acpi_align64(ctx);
/* clear all table memory */
memset((void *)start, 0, ctx->current - start);
acpi_write_rsdp(ctx->rsdp, ctx->rsdt, xsdt);
acpi_write_rsdt(ctx->rsdt);
acpi_write_xsdt(xsdt);
debug("ACPI: * FACS\n"); debug("ACPI: * FACS\n");
facs = ctx->current; facs = ctx->current;

10
include/acpi/acpi_table.h
View file

@ -560,6 +560,16 @@ void acpi_inc_align(struct acpi_ctx *ctx, uint amount);
*/ */
int acpi_add_table(struct acpi_ctx *ctx, void *table); int acpi_add_table(struct acpi_ctx *ctx, void *table);
/**
* acpi_setup_base_tables() - Set up context along with RSDP, RSDT and XSDT
*
* Set up the context with the given start position. Some basic tables are
* always needed, so set them up as well.
*
* @ctx: Context to set up
*/
void acpi_setup_base_tables(struct acpi_ctx *ctx, void *start);
#endif /* !__ACPI__*/ #endif /* !__ACPI__*/
#include <asm/acpi_table.h> #include <asm/acpi_table.h>

82
lib/acpi/acpi_table.c
View file

@ -181,3 +181,85 @@ int acpi_add_table(struct acpi_ctx *ctx, void *table)
return 0; return 0;
} }
static void acpi_write_rsdp(struct acpi_rsdp *rsdp, struct acpi_rsdt *rsdt,
struct acpi_xsdt *xsdt)
{
memset(rsdp, 0, sizeof(struct acpi_rsdp));
memcpy(rsdp->signature, RSDP_SIG, 8);
memcpy(rsdp->oem_id, OEM_ID, 6);
rsdp->length = sizeof(struct acpi_rsdp);
rsdp->rsdt_address = map_to_sysmem(rsdt);
rsdp->xsdt_address = map_to_sysmem(xsdt);
rsdp->revision = ACPI_RSDP_REV_ACPI_2_0;
/* Calculate checksums */
rsdp->checksum = table_compute_checksum(rsdp, 20);
rsdp->ext_checksum = table_compute_checksum(rsdp,
sizeof(struct acpi_rsdp));
}
static void acpi_write_rsdt(struct acpi_rsdt *rsdt)
{
struct acpi_table_header *header = &rsdt->header;
/* Fill out header fields */
acpi_fill_header(header, "RSDT");
header->length = sizeof(struct acpi_rsdt);
header->revision = 1;
/* Entries are filled in later, we come with an empty set */
/* Fix checksum */
header->checksum = table_compute_checksum(rsdt,
sizeof(struct acpi_rsdt));
}
static void acpi_write_xsdt(struct acpi_xsdt *xsdt)
{
struct acpi_table_header *header = &xsdt->header;
/* Fill out header fields */
acpi_fill_header(header, "XSDT");
header->length = sizeof(struct acpi_xsdt);
header->revision = 1;
/* Entries are filled in later, we come with an empty set */
/* Fix checksum */
header->checksum = table_compute_checksum(xsdt,
sizeof(struct acpi_xsdt));
}
void acpi_setup_base_tables(struct acpi_ctx *ctx, void *start)
{
struct acpi_xsdt *xsdt;
ctx->current = start;
/* Align ACPI tables to 16 byte */
acpi_align(ctx);
/* We need at least an RSDP and an RSDT Table */
ctx->rsdp = ctx->current;
acpi_inc_align(ctx, sizeof(struct acpi_rsdp));
ctx->rsdt = ctx->current;
acpi_inc_align(ctx, sizeof(struct acpi_rsdt));
xsdt = ctx->current;
acpi_inc_align(ctx, sizeof(struct acpi_xsdt));
/* clear all table memory */
memset((void *)start, '\0', ctx->current - start);
acpi_write_rsdp(ctx->rsdp, ctx->rsdt, xsdt);
acpi_write_rsdt(ctx->rsdt);
acpi_write_xsdt(xsdt);
/*
* Per ACPI spec, the FACS table address must be aligned to a 64 byte
* boundary (Windows checks this, but Linux does not).
*/
acpi_align64(ctx);
}

64
test/dm/acpi.c
View file

@ -8,7 +8,9 @@
#include <common.h> #include <common.h>
#include <dm.h> #include <dm.h>
#include <malloc.h>
#include <mapmem.h> #include <mapmem.h>
#include <tables_csum.h>
#include <version.h> #include <version.h>
#include <acpi/acpi_table.h> #include <acpi/acpi_table.h>
#include <dm/acpi.h> #include <dm/acpi.h>
@ -132,23 +134,14 @@ DM_TEST(dm_test_acpi_fill_header, DM_TESTF_SCAN_PDATA | DM_TESTF_SCAN_FDT);
static int dm_test_acpi_write_tables(struct unit_test_state *uts) static int dm_test_acpi_write_tables(struct unit_test_state *uts)
{ {
struct acpi_dmar *dmar; struct acpi_dmar *dmar;
struct acpi_xsdt *xsdt;
struct acpi_ctx ctx; struct acpi_ctx ctx;
void *buf; void *buf;
buf = malloc(BUF_SIZE); buf = malloc(BUF_SIZE);
ut_assertnonnull(buf); ut_assertnonnull(buf);
ctx.current = buf; acpi_setup_base_tables(&ctx, buf);
ctx.rsdp = ctx.current;
acpi_inc_align(&ctx, sizeof(struct acpi_rsdp));
ctx.rsdt = ctx.current;
acpi_inc_align(&ctx, sizeof(struct acpi_rsdt));
xsdt = ctx.current;
acpi_inc_align(&ctx, sizeof(struct acpi_xsdt));
ctx.rsdp->xsdt_address = map_to_sysmem(xsdt);
dmar = ctx.current; dmar = ctx.current;
ut_assertok(acpi_write_dev_tables(&ctx)); ut_assertok(acpi_write_dev_tables(&ctx));
/* /*
@ -162,6 +155,11 @@ static int dm_test_acpi_write_tables(struct unit_test_state *uts)
ut_asserteq(DMAR_INTR_REMAP, dmar[1].flags); ut_asserteq(DMAR_INTR_REMAP, dmar[1].flags);
ut_asserteq(32 - 1, dmar[1].host_address_width); ut_asserteq(32 - 1, dmar[1].host_address_width);
/* Check that the pointers were added correctly */
ut_asserteq(map_to_sysmem(dmar), ctx.rsdt->entry[0]);
ut_asserteq(map_to_sysmem(dmar + 1), ctx.rsdt->entry[1]);
ut_asserteq(0, ctx.rsdt->entry[2]);
return 0; return 0;
} }
DM_TEST(dm_test_acpi_write_tables, DM_TESTF_SCAN_PDATA | DM_TESTF_SCAN_FDT); DM_TEST(dm_test_acpi_write_tables, DM_TESTF_SCAN_PDATA | DM_TESTF_SCAN_FDT);
@ -193,3 +191,49 @@ static int dm_test_acpi_basic(struct unit_test_state *uts)
return 0; return 0;
} }
DM_TEST(dm_test_acpi_basic, DM_TESTF_SCAN_PDATA | DM_TESTF_SCAN_FDT); DM_TEST(dm_test_acpi_basic, DM_TESTF_SCAN_PDATA | DM_TESTF_SCAN_FDT);
/* Test acpi_setup_base_tables */
static int dm_test_acpi_setup_base_tables(struct unit_test_state *uts)
{
struct acpi_rsdp *rsdp;
struct acpi_rsdt *rsdt;
struct acpi_xsdt *xsdt;
struct acpi_ctx ctx;
void *buf, *end;
/*
* Use an unaligned address deliberately, by allocating an aligned
* address and then adding 4 to it
*/
buf = memalign(64, BUF_SIZE);
ut_assertnonnull(buf);
acpi_setup_base_tables(&ctx, buf + 4);
rsdp = buf + 16;
ut_asserteq_ptr(rsdp, ctx.rsdp);
ut_assertok(memcmp(RSDP_SIG, rsdp->signature, sizeof(rsdp->signature)));
ut_asserteq(sizeof(*rsdp), rsdp->length);
ut_assertok(table_compute_checksum(rsdp, 20));
ut_assertok(table_compute_checksum(rsdp, sizeof(*rsdp)));
rsdt = PTR_ALIGN((void *)rsdp + sizeof(*rsdp), 16);
ut_asserteq_ptr(rsdt, ctx.rsdt);
ut_assertok(memcmp("RSDT", rsdt->header.signature, ACPI_NAME_LEN));
ut_asserteq(sizeof(*rsdt), rsdt->header.length);
ut_assertok(table_compute_checksum(rsdt, sizeof(*rsdt)));
xsdt = PTR_ALIGN((void *)rsdt + sizeof(*rsdt), 16);
ut_assertok(memcmp("XSDT", xsdt->header.signature, ACPI_NAME_LEN));
ut_asserteq(sizeof(*xsdt), xsdt->header.length);
ut_assertok(table_compute_checksum(xsdt, sizeof(*xsdt)));
end = PTR_ALIGN((void *)xsdt + sizeof(*xsdt), 64);
ut_asserteq_ptr(end, ctx.current);
ut_asserteq(map_to_sysmem(rsdt), rsdp->rsdt_address);
ut_asserteq(map_to_sysmem(xsdt), rsdp->xsdt_address);
return 0;
}
DM_TEST(dm_test_acpi_setup_base_tables,
DM_TESTF_SCAN_PDATA | DM_TESTF_SCAN_FDT);