1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
|
// SPDX-License-Identifier: GPL-2.0+
/*
* Handles writing the declared ACPI tables
*
* Copyright 2021 Google LLC
*/
#define LOG_CATEGORY LOGC_ACPI
#include <common.h>
#include <log.h>
#include <malloc.h>
#include <mapmem.h>
#include <acpi/acpi_table.h>
#include <asm/global_data.h>
#include <dm/acpi.h>
DECLARE_GLOBAL_DATA_PTR;
int acpi_write_one(struct acpi_ctx *ctx, const struct acpi_writer *entry)
{
int ret;
log_debug("%s: writing table '%s'\n", entry->name,
entry->table);
ctx->tab_start = ctx->current;
ret = entry->h_write(ctx, entry);
if (ret == -ENOENT) {
log_debug("%s: Omitted due to being empty\n",
entry->name);
ret = 0;
ctx->current = ctx->tab_start; /* drop the table */
return ret;
}
if (ret)
return log_msg_ret("write", ret);
if (entry->flags & ACPIWF_ALIGN64)
acpi_align64(ctx);
else
acpi_align(ctx);
/* Add the item to the internal list */
ret = acpi_add_other_item(ctx, entry, ctx->tab_start);
if (ret)
return log_msg_ret("add", ret);
return 0;
}
#ifndef CONFIG_QEMU
static int acpi_write_all(struct acpi_ctx *ctx)
{
const struct acpi_writer *writer =
ll_entry_start(struct acpi_writer, acpi_writer);
const int n_ents = ll_entry_count(struct acpi_writer, acpi_writer);
const struct acpi_writer *entry;
int ret;
for (entry = writer; entry != writer + n_ents; entry++) {
ret = acpi_write_one(ctx, entry);
if (ret && ret != -ENOENT)
return log_msg_ret("one", ret);
}
return 0;
}
/*
* QEMU's version of write_acpi_tables is defined in drivers/misc/qfw.c
*/
ulong write_acpi_tables(ulong start_addr)
{
struct acpi_ctx *ctx;
ulong addr;
int ret;
ctx = malloc(sizeof(*ctx));
if (!ctx)
return log_msg_ret("mem", -ENOMEM);
log_debug("ACPI: Writing ACPI tables at %lx\n", start_addr);
acpi_reset_items();
acpi_setup_ctx(ctx, start_addr);
ret = acpi_write_all(ctx);
if (ret) {
log_err("Failed to write ACPI tables (err=%d)\n", ret);
return log_msg_ret("write", -ENOMEM);
}
addr = map_to_sysmem(ctx->current);
log_debug("ACPI current = %lx\n", addr);
return addr;
}
int write_dev_tables(struct acpi_ctx *ctx, const struct acpi_writer *entry)
{
int ret;
ret = acpi_write_dev_tables(ctx);
if (ret)
return log_msg_ret("write", ret);
return 0;
}
ACPI_WRITER(8dev, NULL, write_dev_tables, 0);
ulong acpi_get_rsdp_addr(void)
{
if (!gd->acpi_ctx)
return 0;
return map_to_sysmem(gd->acpi_ctx->rsdp);
}
#endif /* QEMU */
void acpi_setup_ctx(struct acpi_ctx *ctx, ulong start)
{
gd->acpi_ctx = ctx;
memset(ctx, '\0', sizeof(*ctx));
/* Align ACPI tables to 16-byte boundary */
start = ALIGN(start, 16);
ctx->base = map_sysmem(start, 0);
ctx->current = ctx->base;
gd_set_acpi_start(start);
}
|
