blob: 5e769163b72d6b2b9bbcf39b87ee7bd4a7c1bc5f [file] [log] [blame]
Patrick Georgi11f00792020-03-04 15:10:45 +01001/* SPDX-License-Identifier: GPL-2.0-only */
Stefan Reinauer688b3852004-01-28 16:56:14 +00002/*
Martin Roth20bbd812019-08-30 21:09:37 -06003 * coreboot ACPI Table support
Stefan Reinauer777224c2005-01-19 14:06:41 +00004 */
5
Stefan Reinauer14e22772010-04-27 06:56:47 +00006/*
Stefan Reinauer777224c2005-01-19 14:06:41 +00007 * Each system port implementing ACPI has to provide two functions:
Stefan Reinauer14e22772010-04-27 06:56:47 +00008 *
Stefan Reinauer777224c2005-01-19 14:06:41 +00009 * write_acpi_tables()
10 * acpi_dump_apics()
Stefan Reinauer14e22772010-04-27 06:56:47 +000011 *
Stefan Reinauerc0ac7e92009-11-10 22:17:15 +000012 * See Kontron 986LCD-M port for a good example of an ACPI implementation
13 * in coreboot.
Ronald G. Minnich02fa3b22004-10-06 17:33:54 +000014 */
Stefan Reinauer688b3852004-01-28 16:56:14 +000015
Furquan Shaikh76cedd22020-05-02 10:24:23 -070016#include <acpi/acpi.h>
Naresh Solanki6920c6f2023-09-13 12:01:58 +020017#include <acpi/acpi_iort.h>
Furquan Shaikh76cedd22020-05-02 10:24:23 -070018#include <acpi/acpi_ivrs.h>
19#include <acpi/acpigen.h>
Jianjun Wang8565b94a2022-03-02 10:20:26 +080020#include <cbfs.h>
Stefan Reinauerc0ac7e92009-11-10 22:17:15 +000021#include <cbmem.h>
Elyes HAOUASe2d152c2019-06-21 07:06:50 +020022#include <commonlib/helpers.h>
Jianjun Wang8565b94a2022-03-02 10:20:26 +080023#include <console/console.h>
Duncan Laurie11290c42012-10-03 19:07:05 -070024#include <cpu/cpu.h>
Felix Held4a9ed702023-12-05 22:09:14 +010025#include <device/device.h>
Jianjun Wang8565b94a2022-03-02 10:20:26 +080026#include <device/mmio.h>
27#include <device/pci.h>
Arthur Heymans736d4d22023-06-30 15:37:38 +020028#include <drivers/uart/pl011.h>
Jianjun Wang8565b94a2022-03-02 10:20:26 +080029#include <string.h>
Elyes HAOUAScdd2f632021-02-11 19:37:11 +010030#include <types.h>
Elyes HAOUAS26071aa2019-02-15 08:21:33 +010031#include <version.h>
Ronald G. Minnich02fa3b22004-10-06 17:33:54 +000032
Patrick Rudolphcfe08ff2019-09-10 15:40:47 +020033static acpi_rsdp_t *valid_rsdp(acpi_rsdp_t *rsdp);
34
Ronald G. Minnich02fa3b22004-10-06 17:33:54 +000035u8 acpi_checksum(u8 *table, u32 length)
Stefan Reinauer688b3852004-01-28 16:56:14 +000036{
Uwe Hermann622824c2010-11-19 15:14:42 +000037 u8 ret = 0;
Stefan Reinauer688b3852004-01-28 16:56:14 +000038 while (length--) {
39 ret += *table;
40 table++;
41 }
Stefan Reinauera7648c22004-01-29 17:31:34 +000042 return -ret;
Stefan Reinauer688b3852004-01-28 16:56:14 +000043}
44
Stefan Reinauerc0ac7e92009-11-10 22:17:15 +000045/**
Uwe Hermann622824c2010-11-19 15:14:42 +000046 * Add an ACPI table to the RSDT (and XSDT) structure, recalculate length
47 * and checksum.
Stefan Reinauer06feb882004-02-03 16:11:35 +000048 */
Stefan Reinauerb657a3c2009-07-21 21:38:33 +000049void acpi_add_table(acpi_rsdp_t *rsdp, void *table)
Stefan Reinauer688b3852004-01-28 16:56:14 +000050{
Stefan Reinauerc0ac7e92009-11-10 22:17:15 +000051 int i, entries_num;
Stefan Reinauerb657a3c2009-07-21 21:38:33 +000052 acpi_rsdt_t *rsdt;
Arthur Heymansc2830c92023-08-22 12:50:43 +020053 acpi_xsdt_t *xsdt;
Stefan Reinauerb657a3c2009-07-21 21:38:33 +000054
Arthur Heymansd8f2dce2023-06-22 13:42:36 +020055 /* The 32bit RSDT may not be valid if tables live above 4GiB */
Stefan Reinauerdefee172015-06-18 01:11:19 -070056 rsdt = (acpi_rsdt_t *)(uintptr_t)rsdp->rsdt_address;
Arthur Heymansd8f2dce2023-06-22 13:42:36 +020057 xsdt = (acpi_xsdt_t *)(uintptr_t)rsdp->xsdt_address;
Stefan Reinauer14e22772010-04-27 06:56:47 +000058
Uwe Hermann622824c2010-11-19 15:14:42 +000059 /* This should always be MAX_ACPI_TABLES. */
Arthur Heymansd8f2dce2023-06-22 13:42:36 +020060 entries_num = ARRAY_SIZE(xsdt->entry);
Stefan Reinauer14e22772010-04-27 06:56:47 +000061
Stefan Reinauerc0ac7e92009-11-10 22:17:15 +000062 for (i = 0; i < entries_num; i++) {
Arthur Heymansd8f2dce2023-06-22 13:42:36 +020063 if (xsdt->entry[i] == 0)
Stefan Reinauerc0ac7e92009-11-10 22:17:15 +000064 break;
Stefan Reinauer688b3852004-01-28 16:56:14 +000065 }
66
Stefan Reinauerc0ac7e92009-11-10 22:17:15 +000067 if (i >= entries_num) {
Uwe Hermann622824c2010-11-19 15:14:42 +000068 printk(BIOS_ERR, "ACPI: Error: Could not add ACPI table, "
Cristian Măgherușan-Stanciuba482812011-07-02 00:57:07 +030069 "too many tables.\n");
Stefan Reinauerc0ac7e92009-11-10 22:17:15 +000070 return;
71 }
72
Arthur Heymansd8f2dce2023-06-22 13:42:36 +020073 /* Add table to the XSDT. */
74 xsdt->entry[i] = (u64)(uintptr_t)table;
Stefan Reinauerc0ac7e92009-11-10 22:17:15 +000075
Arthur Heymansd8f2dce2023-06-22 13:42:36 +020076 /* Fix XSDT length or the kernel will assume invalid entries. */
77 xsdt->header.length = sizeof(acpi_header_t) + (sizeof(u64) * (i + 1));
Stefan Reinauerc0ac7e92009-11-10 22:17:15 +000078
Uwe Hermann622824c2010-11-19 15:14:42 +000079 /* Re-calculate checksum. */
Arthur Heymansd8f2dce2023-06-22 13:42:36 +020080 xsdt->header.checksum = 0; /* Hope this won't get optimized away */
81 xsdt->header.checksum = acpi_checksum((u8 *)xsdt, xsdt->header.length);
Stefan Reinauerc0ac7e92009-11-10 22:17:15 +000082
Uwe Hermann622824c2010-11-19 15:14:42 +000083 /*
Arthur Heymansd8f2dce2023-06-22 13:42:36 +020084 * And now the same thing for the RSDT. We use the same index as for
Stefan Reinauerc0ac7e92009-11-10 22:17:15 +000085 * now we want the XSDT and RSDT to always be in sync in coreboot.
86 */
Arthur Heymansd8f2dce2023-06-22 13:42:36 +020087 if (rsdt && (uintptr_t)table < UINT32_MAX) {
88 /* Add table to the RSDT. */
89 rsdt->entry[i] = (u32)(uintptr_t)table;
Stefan Reinauerc0ac7e92009-11-10 22:17:15 +000090
Arthur Heymansd8f2dce2023-06-22 13:42:36 +020091 /* Fix RSDT length. */
92 rsdt->header.length = sizeof(acpi_header_t) + (sizeof(u32) * (i + 1));
Stefan Reinauerc0ac7e92009-11-10 22:17:15 +000093
Uwe Hermann622824c2010-11-19 15:14:42 +000094 /* Re-calculate checksum. */
Arthur Heymansd8f2dce2023-06-22 13:42:36 +020095 rsdt->header.checksum = 0;
96 rsdt->header.checksum = acpi_checksum((u8 *)rsdt, rsdt->header.length);
Stefan Reinauerc0ac7e92009-11-10 22:17:15 +000097 }
98
Uwe Hermann622824c2010-11-19 15:14:42 +000099 printk(BIOS_DEBUG, "ACPI: added table %d/%d, length now %d\n",
Arthur Heymansd8f2dce2023-06-22 13:42:36 +0200100 i + 1, entries_num, xsdt->header.length);
Stefan Reinauer688b3852004-01-28 16:56:14 +0000101}
102
Arthur Heymansadb80072023-06-28 09:56:00 +0200103static enum cb_err acpi_fill_header(acpi_header_t *header, const char name[4],
104 enum acpi_tables table, uint32_t size)
105{
106 if (!header)
107 return CB_ERR;
108
109 /* Fill out header fields. */
110 memcpy(header->signature, name, 4);
111 memcpy(header->oem_id, OEM_ID, 6);
112 memcpy(header->oem_table_id, ACPI_TABLE_CREATOR, 8);
113 memcpy(header->asl_compiler_id, ASLC, 4);
114
115 header->asl_compiler_revision = asl_revision;
116 header->revision = get_acpi_table_revision(table);
117 header->length = size;
118
119 return CB_SUCCESS;
120}
121
Naresh Solanki4d0b1842023-08-25 12:58:11 +0200122static int acpi_create_mcfg_mmconfig(acpi_mcfg_mmconfig_t *mmconfig, u64 base,
Cristian Măgherușan-Stanciuba482812011-07-02 00:57:07 +0300123 u16 seg_nr, u8 start, u8 end)
Stefan Reinauer26d431a2009-01-20 19:17:51 +0000124{
Vladimir Serbinenko60fccdc2014-10-05 11:05:16 +0200125 memset(mmconfig, 0, sizeof(*mmconfig));
Rudolf Mareke6409f22007-11-03 12:50:26 +0000126 mmconfig->base_address = base;
Rudolf Mareke6409f22007-11-03 12:50:26 +0000127 mmconfig->pci_segment_group_number = seg_nr;
128 mmconfig->start_bus_number = start;
129 mmconfig->end_bus_number = end;
Uwe Hermann622824c2010-11-19 15:14:42 +0000130
131 return sizeof(acpi_mcfg_mmconfig_t);
Rudolf Mareke6409f22007-11-03 12:50:26 +0000132}
133
Arthur Heymans01af0f82023-06-27 11:58:04 +0200134static void acpi_create_madt(acpi_header_t *header, void *unused)
Stefan Reinauer06feb882004-02-03 16:11:35 +0000135{
Arthur Heymans01af0f82023-06-27 11:58:04 +0200136 acpi_madt_t *madt = (acpi_madt_t *)header;
Uwe Hermann622824c2010-11-19 15:14:42 +0000137 unsigned long current = (unsigned long)madt + sizeof(acpi_madt_t);
Stefan Reinauer14e22772010-04-27 06:56:47 +0000138
Arthur Heymansadb80072023-06-28 09:56:00 +0200139 if (acpi_fill_header(header, "APIC", MADT, sizeof(acpi_madt_t)) != CB_SUCCESS)
John Zhao2ba303e2019-05-28 16:48:14 -0700140 return;
141
Arthur Heymanscd46e5f2023-06-22 21:34:16 +0200142 current = acpi_arch_fill_madt(madt, current);
Kyösti Mälkki10bdee12023-04-11 01:00:17 +0300143
144 if (CONFIG(ACPI_CUSTOM_MADT))
Kyösti Mälkkia5fa5342022-11-18 13:23:52 +0200145 current = acpi_fill_madt(current);
Stefan Reinauer14e22772010-04-27 06:56:47 +0000146
Arthur Heymans01af0f82023-06-27 11:58:04 +0200147 /* (Re)calculate length . */
Uwe Hermann622824c2010-11-19 15:14:42 +0000148 header->length = current - (unsigned long)madt;
Stefan Reinauer06feb882004-02-03 16:11:35 +0000149}
150
Kyösti Mälkkib54388d2021-02-14 15:09:45 +0200151static unsigned long acpi_fill_mcfg(unsigned long current)
152{
153 current += acpi_create_mcfg_mmconfig((acpi_mcfg_mmconfig_t *)current,
Shelley Chen4e9bb332021-10-20 15:43:45 -0700154 CONFIG_ECAM_MMCONF_BASE_ADDRESS, 0, 0,
155 CONFIG_ECAM_MMCONF_BUS_NUMBER - 1);
Kyösti Mälkkib54388d2021-02-14 15:09:45 +0200156 return current;
157}
158
Uwe Hermann622824c2010-11-19 15:14:42 +0000159/* MCFG is defined in the PCI Firmware Specification 3.0. */
Arthur Heymans01af0f82023-06-27 11:58:04 +0200160static void acpi_create_mcfg(acpi_header_t *header, void *unused)
Rudolf Mareke6409f22007-11-03 12:50:26 +0000161{
Arthur Heymans01af0f82023-06-27 11:58:04 +0200162 acpi_mcfg_t *mcfg = (acpi_mcfg_t *)header;
Uwe Hermann622824c2010-11-19 15:14:42 +0000163 unsigned long current = (unsigned long)mcfg + sizeof(acpi_mcfg_t);
Stefan Reinauer14e22772010-04-27 06:56:47 +0000164
Arthur Heymansadb80072023-06-28 09:56:00 +0200165
166 if (acpi_fill_header(header, "MCFG", MCFG, sizeof(acpi_mcfg_t)) != CB_SUCCESS)
John Zhao2ba303e2019-05-28 16:48:14 -0700167 return;
168
Shelley Chen4e9bb332021-10-20 15:43:45 -0700169 if (CONFIG(ECAM_MMCONF_SUPPORT))
Kyösti Mälkkib54388d2021-02-14 15:09:45 +0200170 current = acpi_fill_mcfg(current);
Stefan Reinauer14e22772010-04-27 06:56:47 +0000171
Arthur Heymans01af0f82023-06-27 11:58:04 +0200172 /* (Re)calculate length */
Uwe Hermann622824c2010-11-19 15:14:42 +0000173 header->length = current - (unsigned long)mcfg;
Rudolf Mareke6409f22007-11-03 12:50:26 +0000174}
175
Vladimir Serbinenkof44ac132015-05-20 19:52:01 +0200176static void *get_tcpa_log(u32 *size)
177{
178 const struct cbmem_entry *ce;
179 const u32 tcpa_default_log_len = 0x10000;
180 void *lasa;
Philipp Deppenwiese791ba972018-07-30 01:15:20 +0200181 ce = cbmem_entry_find(CBMEM_ID_TCPA_TCG_LOG);
Vladimir Serbinenkof44ac132015-05-20 19:52:01 +0200182 if (ce) {
183 lasa = cbmem_entry_start(ce);
184 *size = cbmem_entry_size(ce);
185 printk(BIOS_DEBUG, "TCPA log found at %p\n", lasa);
186 return lasa;
187 }
Philipp Deppenwiese791ba972018-07-30 01:15:20 +0200188 lasa = cbmem_add(CBMEM_ID_TCPA_TCG_LOG, tcpa_default_log_len);
Vladimir Serbinenkof44ac132015-05-20 19:52:01 +0200189 if (!lasa) {
190 printk(BIOS_ERR, "TCPA log creation failed\n");
191 return NULL;
192 }
193
194 printk(BIOS_DEBUG, "TCPA log created at %p\n", lasa);
Lee Leahy024b13d2017-03-16 13:41:11 -0700195 memset(lasa, 0, tcpa_default_log_len);
Vladimir Serbinenkof44ac132015-05-20 19:52:01 +0200196
197 *size = tcpa_default_log_len;
198 return lasa;
199}
200
Arthur Heymans01af0f82023-06-27 11:58:04 +0200201static void acpi_create_tcpa(acpi_header_t *header, void *unused)
Vladimir Serbinenkof44ac132015-05-20 19:52:01 +0200202{
Arthur Heymans01af0f82023-06-27 11:58:04 +0200203 if (!CONFIG(TPM1))
204 return;
205
206 acpi_tcpa_t *tcpa = (acpi_tcpa_t *)header;
Vladimir Serbinenkof44ac132015-05-20 19:52:01 +0200207 u32 tcpa_log_len;
208 void *lasa;
209
Vladimir Serbinenkof44ac132015-05-20 19:52:01 +0200210 lasa = get_tcpa_log(&tcpa_log_len);
Lee Leahy9c7c6f72017-03-16 11:24:09 -0700211 if (!lasa)
Vladimir Serbinenkof44ac132015-05-20 19:52:01 +0200212 return;
Vladimir Serbinenkof44ac132015-05-20 19:52:01 +0200213
Arthur Heymansadb80072023-06-28 09:56:00 +0200214 if (acpi_fill_header(header, "TCPA", TCPA, sizeof(acpi_tcpa_t)) != CB_SUCCESS)
John Zhao2ba303e2019-05-28 16:48:14 -0700215 return;
216
Vladimir Serbinenkof44ac132015-05-20 19:52:01 +0200217 tcpa->platform_class = 0;
218 tcpa->laml = tcpa_log_len;
Elyes Haouas3141fbad2022-11-18 15:22:32 +0100219 tcpa->lasa = (uintptr_t)lasa;
Vladimir Serbinenkof44ac132015-05-20 19:52:01 +0200220}
221
Michał Żygowski6e8692e2018-11-22 16:57:50 +0100222static void *get_tpm2_log(u32 *size)
223{
224 const struct cbmem_entry *ce;
225 const u32 tpm2_default_log_len = 0x10000;
226 void *lasa;
227 ce = cbmem_entry_find(CBMEM_ID_TPM2_TCG_LOG);
228 if (ce) {
229 lasa = cbmem_entry_start(ce);
230 *size = cbmem_entry_size(ce);
231 printk(BIOS_DEBUG, "TPM2 log found at %p\n", lasa);
232 return lasa;
233 }
234 lasa = cbmem_add(CBMEM_ID_TPM2_TCG_LOG, tpm2_default_log_len);
235 if (!lasa) {
236 printk(BIOS_ERR, "TPM2 log creation failed\n");
237 return NULL;
238 }
239
240 printk(BIOS_DEBUG, "TPM2 log created at %p\n", lasa);
241 memset(lasa, 0, tpm2_default_log_len);
242
243 *size = tpm2_default_log_len;
244 return lasa;
245}
246
Arthur Heymans01af0f82023-06-27 11:58:04 +0200247static void acpi_create_tpm2(acpi_header_t *header, void *unused)
Philipp Deppenwiese296164e02018-10-18 15:39:34 +0200248{
Arthur Heymans01af0f82023-06-27 11:58:04 +0200249 if (!CONFIG(TPM2))
250 return;
251
252 acpi_tpm2_t *tpm2 = (acpi_tpm2_t *)header;
Michał Żygowski6e8692e2018-11-22 16:57:50 +0100253 u32 tpm2_log_len;
254 void *lasa;
Philipp Deppenwiese296164e02018-10-18 15:39:34 +0200255
Michał Żygowski6e8692e2018-11-22 16:57:50 +0100256 /*
257 * Some payloads like SeaBIOS depend on log area to use TPM2.
258 * Get the memory size and address of TPM2 log area or initialize it.
259 */
260 lasa = get_tpm2_log(&tpm2_log_len);
261 if (!lasa)
262 tpm2_log_len = 0;
263
Arthur Heymansadb80072023-06-28 09:56:00 +0200264 if (acpi_fill_header(header, "TPM2", TPM2, sizeof(acpi_tpm2_t)) != CB_SUCCESS)
John Zhao2ba303e2019-05-28 16:48:14 -0700265 return;
266
Philipp Deppenwiese296164e02018-10-18 15:39:34 +0200267 /* Hard to detect for coreboot. Just set it to 0 */
268 tpm2->platform_class = 0;
Christian Walter26e0d4c2019-07-14 15:47:23 +0200269 if (CONFIG(CRB_TPM)) {
270 /* Must be set to 7 for CRB Support */
271 tpm2->control_area = CONFIG_CRB_TPM_BASE_ADDRESS + 0x40;
272 tpm2->start_method = 7;
273 } else {
274 /* Must be set to 0 for FIFO interface support */
275 tpm2->control_area = 0;
276 tpm2->start_method = 6;
277 }
Philipp Deppenwiese296164e02018-10-18 15:39:34 +0200278 memset(tpm2->msp, 0, sizeof(tpm2->msp));
279
Michał Żygowski6e8692e2018-11-22 16:57:50 +0100280 /* Fill the log area size and start address fields. */
281 tpm2->laml = tpm2_log_len;
Elyes Haouas3141fbad2022-11-18 15:22:32 +0100282 tpm2->lasa = (uintptr_t)lasa;
Philipp Deppenwiese296164e02018-10-18 15:39:34 +0200283}
284
Duncan Laurie37319032016-05-26 12:47:05 -0700285static void acpi_ssdt_write_cbtable(void)
286{
287 const struct cbmem_entry *cbtable;
288 uintptr_t base;
289 uint32_t size;
290
291 cbtable = cbmem_entry_find(CBMEM_ID_CBTABLE);
292 if (!cbtable)
293 return;
294 base = (uintptr_t)cbmem_entry_start(cbtable);
295 size = cbmem_entry_size(cbtable);
296
297 acpigen_write_device("CTBL");
298 acpigen_write_coreboot_hid(COREBOOT_ACPI_ID_CBTABLE);
299 acpigen_write_name_integer("_UID", 0);
Matt DeVillierce10b6f2022-10-15 11:52:54 -0500300 acpigen_write_STA(ACPI_STATUS_DEVICE_ALL_ON);
Duncan Laurie37319032016-05-26 12:47:05 -0700301 acpigen_write_name("_CRS");
302 acpigen_write_resourcetemplate_header();
Arthur Heymans87837df2023-06-29 21:09:52 +0200303 acpigen_resource_consumer_mmio(base, base + size - 1,
304 MEM_RSRC_FLAG_MEM_READ_ONLY
305 | MEM_RSRC_FLAG_MEM_ATTR_CACHE);
Duncan Laurie37319032016-05-26 12:47:05 -0700306 acpigen_write_resourcetemplate_footer();
307 acpigen_pop_len();
308}
309
Arthur Heymans01af0f82023-06-27 11:58:04 +0200310static void acpi_create_ssdt_generator(acpi_header_t *ssdt, void *unused)
Rudolf Marek293b5f52009-02-01 18:35:15 +0000311{
Uwe Hermann622824c2010-11-19 15:14:42 +0000312 unsigned long current = (unsigned long)ssdt + sizeof(acpi_header_t);
313
Arthur Heymansadb80072023-06-28 09:56:00 +0200314 if (acpi_fill_header(ssdt, "SSDT", SSDT, sizeof(acpi_header_t)) != CB_SUCCESS)
315 return;
Rudolf Marek293b5f52009-02-01 18:35:15 +0000316
Elyes Haouas3141fbad2022-11-18 15:22:32 +0100317 acpigen_set_current((char *)current);
Duncan Laurie37319032016-05-26 12:47:05 -0700318
319 /* Write object to declare coreboot tables */
320 acpi_ssdt_write_cbtable();
321
Vladimir Serbinenko2d7bd8a2014-08-30 19:28:05 +0200322 {
Edward O'Callaghan2c9d2cf2014-10-27 23:29:29 +1100323 struct device *dev;
Vladimir Serbinenko2d7bd8a2014-08-30 19:28:05 +0200324 for (dev = all_devices; dev; dev = dev->next)
Karthikeyan Ramasubramaniand1c0f952020-11-02 16:26:52 -0700325 if (dev->enabled && dev->ops && dev->ops->acpi_fill_ssdt)
Nico Huber68680dd2020-03-31 17:34:52 +0200326 dev->ops->acpi_fill_ssdt(dev);
Elyes Haouas3141fbad2022-11-18 15:22:32 +0100327 current = (unsigned long)acpigen_get_current();
Vladimir Serbinenko2d7bd8a2014-08-30 19:28:05 +0200328 }
Rudolf Marek293b5f52009-02-01 18:35:15 +0000329
Uwe Hermann622824c2010-11-19 15:14:42 +0000330 /* (Re)calculate length and checksum. */
Rudolf Marek293b5f52009-02-01 18:35:15 +0000331 ssdt->length = current - (unsigned long)ssdt;
Rudolf Marek293b5f52009-02-01 18:35:15 +0000332}
333
Uwe Hermann622824c2010-11-19 15:14:42 +0000334int acpi_create_srat_mem(acpi_srat_mem_t *mem, u8 node, u32 basek, u32 sizek,
Cristian Măgherușan-Stanciuba482812011-07-02 00:57:07 +0300335 u32 flags)
Stefan Reinauerf622d592005-11-26 16:56:05 +0000336{
Uwe Hermann622824c2010-11-19 15:14:42 +0000337 mem->type = 1; /* Memory affinity structure */
338 mem->length = sizeof(acpi_srat_mem_t);
339 mem->base_address_low = (basek << 10);
340 mem->base_address_high = (basek >> (32 - 10));
341 mem->length_low = (sizek << 10);
342 mem->length_high = (sizek >> (32 - 10));
343 mem->proximity_domain = node;
Stefan Reinauer14e22772010-04-27 06:56:47 +0000344 mem->flags = flags;
Stefan Reinauerf622d592005-11-26 16:56:05 +0000345
Uwe Hermann622824c2010-11-19 15:14:42 +0000346 return mem->length;
Stefan Reinauerf622d592005-11-26 16:56:05 +0000347}
348
Jonathan Zhang3164b642021-04-21 17:51:31 -0700349int acpi_create_srat_gia_pci(acpi_srat_gia_t *gia, u32 proximity_domain,
350 u16 seg, u8 bus, u8 dev, u8 func, u32 flags)
351{
352 gia->type = ACPI_SRAT_STRUCTURE_GIA;
353 gia->length = sizeof(acpi_srat_gia_t);
354 gia->proximity_domain = proximity_domain;
355 gia->dev_handle_type = ACPI_SRAT_GIA_DEV_HANDLE_PCI;
356 /* First two bytes has segment number */
357 memcpy(gia->dev_handle, &seg, 2);
358 gia->dev_handle[2] = bus; /* Byte 2 has bus number */
359 /* Byte 3 has bits 7:3 for dev, bits 2:0 for func */
360 gia->dev_handle[3] = PCI_SLOT(dev) | PCI_FUNC(func);
361 gia->flags = flags;
362
363 return gia->length;
364}
365
Uwe Hermann622824c2010-11-19 15:14:42 +0000366/* http://www.microsoft.com/whdc/system/sysinternals/sratdwn.mspx */
Vladimir Serbinenko5e597572014-10-11 23:45:40 +0200367void acpi_create_srat(acpi_srat_t *srat,
368 unsigned long (*acpi_fill_srat)(unsigned long current))
Stefan Reinauerf622d592005-11-26 16:56:05 +0000369{
Uwe Hermann622824c2010-11-19 15:14:42 +0000370 acpi_header_t *header = &(srat->header);
371 unsigned long current = (unsigned long)srat + sizeof(acpi_srat_t);
Stefan Reinauerf622d592005-11-26 16:56:05 +0000372
Uwe Hermann622824c2010-11-19 15:14:42 +0000373 memset((void *)srat, 0, sizeof(acpi_srat_t));
Stefan Reinauerf622d592005-11-26 16:56:05 +0000374
Arthur Heymansadb80072023-06-28 09:56:00 +0200375 if (acpi_fill_header(header, "SRAT", SRAT, sizeof(acpi_srat_t)) != CB_SUCCESS)
John Zhao2ba303e2019-05-28 16:48:14 -0700376 return;
377
Uwe Hermann622824c2010-11-19 15:14:42 +0000378 srat->resv = 1; /* Spec: Reserved to 1 for backwards compatibility. */
Stefan Reinauerf622d592005-11-26 16:56:05 +0000379
Uwe Hermann622824c2010-11-19 15:14:42 +0000380 current = acpi_fill_srat(current);
Stefan Reinauerf622d592005-11-26 16:56:05 +0000381
Uwe Hermann622824c2010-11-19 15:14:42 +0000382 /* (Re)calculate length and checksum. */
383 header->length = current - (unsigned long)srat;
384 header->checksum = acpi_checksum((void *)srat, header->length);
Stefan Reinauerf622d592005-11-26 16:56:05 +0000385}
386
Jonathan Zhang3dcafa82022-05-11 13:11:20 -0700387int acpi_create_cedt_chbs(acpi_cedt_chbs_t *chbs, u32 uid, u32 cxl_ver, u64 base)
388{
389 memset((void *)chbs, 0, sizeof(acpi_cedt_chbs_t));
390
391 chbs->type = ACPI_CEDT_STRUCTURE_CHBS;
392 chbs->length = sizeof(acpi_cedt_chbs_t);
393 chbs->uid = uid;
394 chbs->cxl_ver = cxl_ver;
395 chbs->base = base;
396
397 /*
398 * CXL spec 2.0 section 9.14.1.2 "CXL CHBS"
399 * CXL 1.1 spec compliant host bridge: 8KB
400 * CXL 2.0 spec compliant host bridge: 64KB
401 */
402 if (cxl_ver == ACPI_CEDT_CHBS_CXL_VER_1_1)
403 chbs->len = 8 * KiB;
404 else if (cxl_ver == ACPI_CEDT_CHBS_CXL_VER_2_0)
405 chbs->len = 64 * KiB;
406 else
407 printk(BIOS_ERR, "ACPI(%s:%s): Incorrect CXL version:%d\n", __FILE__, __func__,
408 cxl_ver);
409
410 return chbs->length;
411}
412
413int acpi_create_cedt_cfmws(acpi_cedt_cfmws_t *cfmws, u64 base_hpa, u64 window_size, u8 eniw,
414 u32 hbig, u16 restriction, u16 qtg_id, const u32 *interleave_target)
415{
416 memset((void *)cfmws, 0, sizeof(acpi_cedt_cfmws_t));
417
418 cfmws->type = ACPI_CEDT_STRUCTURE_CFMWS;
419
420 u8 niw = 0;
421 if (eniw >= 8)
422 printk(BIOS_ERR, "ACPI(%s:%s): Incorrect eniw::%d\n", __FILE__, __func__, eniw);
423 else
424 /* NIW = 2 ** ENIW */
425 niw = 0x1 << eniw;
426 /* 36 + 4 * NIW */
427 cfmws->length = sizeof(acpi_cedt_cfmws_t) + 4 * niw;
428
429 cfmws->base_hpa = base_hpa;
430 cfmws->window_size = window_size;
431 cfmws->eniw = eniw;
432
433 // 0: Standard Modulo Arithmetic. Other values reserved.
434 cfmws->interleave_arithmetic = 0;
435
436 cfmws->hbig = hbig;
437 cfmws->restriction = restriction;
438 cfmws->qtg_id = qtg_id;
439 memcpy(&cfmws->interleave_target, interleave_target, 4 * niw);
440
441 return cfmws->length;
442}
443
444void acpi_create_cedt(acpi_cedt_t *cedt, unsigned long (*acpi_fill_cedt)(unsigned long current))
445{
446 acpi_header_t *header = &(cedt->header);
447 unsigned long current = (unsigned long)cedt + sizeof(acpi_cedt_t);
448
449 memset((void *)cedt, 0, sizeof(acpi_cedt_t));
450
Arthur Heymansadb80072023-06-28 09:56:00 +0200451 if (acpi_fill_header(header, "CEDT", CEDT, sizeof(acpi_cedt_t)) != CB_SUCCESS)
Jonathan Zhang3dcafa82022-05-11 13:11:20 -0700452 return;
453
Jonathan Zhang3dcafa82022-05-11 13:11:20 -0700454 current = acpi_fill_cedt(current);
455
456 /* (Re)calculate length and checksum. */
457 header->length = current - (unsigned long)cedt;
458 header->checksum = acpi_checksum((void *)cedt, header->length);
459}
460
Jonathan Zhang2a4e1f42021-04-01 11:43:37 -0700461int acpi_create_hmat_mpda(acpi_hmat_mpda_t *mpda, u32 initiator, u32 memory)
462{
463 memset((void *)mpda, 0, sizeof(acpi_hmat_mpda_t));
464
465 mpda->type = 0; /* Memory Proximity Domain Attributes structure */
466 mpda->length = sizeof(acpi_hmat_mpda_t);
467 /*
468 * Proximity Domain for Attached Initiator field is valid.
469 * Bit 1 and bit 2 are reserved since HMAT revision 2.
470 */
471 mpda->flags = (1 << 0);
472 mpda->proximity_domain_initiator = initiator;
473 mpda->proximity_domain_memory = memory;
474
475 return mpda->length;
476}
477
478void acpi_create_hmat(acpi_hmat_t *hmat,
479 unsigned long (*acpi_fill_hmat)(unsigned long current))
480{
481 acpi_header_t *header = &(hmat->header);
482 unsigned long current = (unsigned long)hmat + sizeof(acpi_hmat_t);
483
484 memset((void *)hmat, 0, sizeof(acpi_hmat_t));
485
Arthur Heymansadb80072023-06-28 09:56:00 +0200486 if (acpi_fill_header(header, "HMAT", HMAT, sizeof(acpi_hmat_t)) != CB_SUCCESS)
Jonathan Zhang2a4e1f42021-04-01 11:43:37 -0700487 return;
488
Jonathan Zhang2a4e1f42021-04-01 11:43:37 -0700489 current = acpi_fill_hmat(current);
490
491 /* (Re)calculate length and checksum. */
492 header->length = current - (unsigned long)hmat;
493 header->checksum = acpi_checksum((void *)hmat, header->length);
494}
495
Uwe Hermann622824c2010-11-19 15:14:42 +0000496/* http://h21007.www2.hp.com/portal/download/files/unprot/Itanium/slit.pdf */
Vladimir Serbinenko5e597572014-10-11 23:45:40 +0200497void acpi_create_slit(acpi_slit_t *slit,
498 unsigned long (*acpi_fill_slit)(unsigned long current))
Yinghai Lud4b278c2006-10-04 20:46:15 +0000499{
Uwe Hermann622824c2010-11-19 15:14:42 +0000500 acpi_header_t *header = &(slit->header);
501 unsigned long current = (unsigned long)slit + sizeof(acpi_slit_t);
Yinghai Lud4b278c2006-10-04 20:46:15 +0000502
Uwe Hermann622824c2010-11-19 15:14:42 +0000503 memset((void *)slit, 0, sizeof(acpi_slit_t));
Yinghai Lud4b278c2006-10-04 20:46:15 +0000504
Arthur Heymansadb80072023-06-28 09:56:00 +0200505 if (acpi_fill_header(header, "SLIT", SLIT, sizeof(acpi_slit_t)) != CB_SUCCESS)
John Zhao2ba303e2019-05-28 16:48:14 -0700506 return;
507
Uwe Hermann622824c2010-11-19 15:14:42 +0000508 current = acpi_fill_slit(current);
Yinghai Lud4b278c2006-10-04 20:46:15 +0000509
Uwe Hermann622824c2010-11-19 15:14:42 +0000510 /* (Re)calculate length and checksum. */
511 header->length = current - (unsigned long)slit;
512 header->checksum = acpi_checksum((void *)slit, header->length);
Yinghai Lud4b278c2006-10-04 20:46:15 +0000513}
514
Rocky Phaguraeff07132021-01-10 15:42:50 -0800515/*
516 * This method adds the ACPI error injection capability. It fills the default information.
517 * HW dependent code (caller) can modify the defaults upon return. If no changes are necessary
518 * and the defaults are acceptable then caller can simply add the table (acpi_add_table).
519 * INPUTS:
520 * einj - ptr to the starting location of EINJ table
521 * actions - number of actions to trigger an error (HW dependent)
522 * addr - address of trigger action table. This should be ACPI reserved memory and it will be
523 * shared between OS and FW.
524 */
525void acpi_create_einj(acpi_einj_t *einj, uintptr_t addr, u8 actions)
526{
527 int i;
528 acpi_header_t *header = &(einj->header);
529 acpi_injection_header_t *inj_header = &(einj->inj_header);
530 acpi_einj_smi_t *einj_smi = (acpi_einj_smi_t *)addr;
531 acpi_einj_trigger_table_t *tat;
532 if (!header)
533 return;
534
535 printk(BIOS_DEBUG, "%s einj_smi = %p\n", __func__, einj_smi);
536 memset(einj_smi, 0, sizeof(acpi_einj_smi_t));
Jonathan Zhangd5d9b282022-11-07 17:30:14 -0800537 tat = (acpi_einj_trigger_table_t *)((uint8_t *)einj_smi + sizeof(acpi_einj_smi_t));
Rocky Phaguraeff07132021-01-10 15:42:50 -0800538 tat->header_size = 16;
539 tat->revision = 0;
540 tat->table_size = sizeof(acpi_einj_trigger_table_t) +
541 sizeof(acpi_einj_action_table_t) * actions - 1;
542 tat->entry_count = actions;
543 printk(BIOS_DEBUG, "%s trigger_action_table = %p\n", __func__, tat);
544
545 for (i = 0; i < actions; i++) {
546 tat->trigger_action[i].action = TRIGGER_ERROR;
547 tat->trigger_action[i].instruction = NO_OP;
548 tat->trigger_action[i].flags = FLAG_IGNORE;
549 tat->trigger_action[i].reg.space_id = ACPI_ADDRESS_SPACE_MEMORY;
550 tat->trigger_action[i].reg.bit_width = 64;
551 tat->trigger_action[i].reg.bit_offset = 0;
552 tat->trigger_action[i].reg.access_size = ACPI_ACCESS_SIZE_QWORD_ACCESS;
553 tat->trigger_action[i].reg.addr = 0;
554 tat->trigger_action[i].value = 0;
555 tat->trigger_action[i].mask = 0xFFFFFFFF;
556 }
557
558 acpi_einj_action_table_t default_actions[ACTION_COUNT] = {
559 [0] = {
560 .action = BEGIN_INJECT_OP,
561 .instruction = WRITE_REGISTER_VALUE,
562 .flags = FLAG_PRESERVE,
563 .reg = EINJ_REG_MEMORY((u64)(uintptr_t)&einj_smi->op_state),
564 .value = 0,
565 .mask = 0xFFFFFFFF
566 },
567 [1] = {
568 .action = GET_TRIGGER_ACTION_TABLE,
569 .instruction = READ_REGISTER,
570 .flags = FLAG_IGNORE,
571 .reg = EINJ_REG_MEMORY((u64)(uintptr_t)&einj_smi->trigger_action_table),
572 .value = 0,
573 .mask = 0xFFFFFFFFFFFFFFFF
574 },
575 [2] = {
576 .action = SET_ERROR_TYPE,
577 .instruction = WRITE_REGISTER,
578 .flags = FLAG_PRESERVE,
579 .reg = EINJ_REG_MEMORY((u64)(uintptr_t)&einj_smi->err_inject[0]),
580 .value = 0,
581 .mask = 0xFFFFFFFF
582 },
583 [3] = {
584 .action = GET_ERROR_TYPE,
585 .instruction = READ_REGISTER,
586 .flags = FLAG_IGNORE,
587 .reg = EINJ_REG_MEMORY((u64)(uintptr_t)&einj_smi->err_inj_cap),
588 .value = 0,
589 .mask = 0xFFFFFFFF
590 },
591 [4] = {
592 .action = END_INJECT_OP,
593 .instruction = WRITE_REGISTER_VALUE,
594 .flags = FLAG_PRESERVE,
595 .reg = EINJ_REG_MEMORY((u64)(uintptr_t)&einj_smi->op_state),
596 .value = 0,
597 .mask = 0xFFFFFFFF
598
599 },
600 [5] = {
601 .action = EXECUTE_INJECT_OP,
602 .instruction = WRITE_REGISTER_VALUE,
603 .flags = FLAG_PRESERVE,
604 .reg = EINJ_REG_IO(),
605 .value = 0x9a,
606 .mask = 0xFFFF,
607 },
608 [6] = {
609 .action = CHECK_BUSY_STATUS,
610 .instruction = READ_REGISTER_VALUE,
611 .flags = FLAG_IGNORE,
612 .reg = EINJ_REG_MEMORY((u64)(uintptr_t)&einj_smi->op_status),
613 .value = 1,
614 .mask = 1,
615 },
616 [7] = {
617 .action = GET_CMD_STATUS,
618 .instruction = READ_REGISTER,
619 .flags = FLAG_PRESERVE,
620 .reg = EINJ_REG_MEMORY((u64)(uintptr_t)&einj_smi->cmd_sts),
621 .value = 0,
622 .mask = 0x1fe,
623 },
624 [8] = {
625 .action = SET_ERROR_TYPE_WITH_ADDRESS,
626 .instruction = WRITE_REGISTER,
627 .flags = FLAG_PRESERVE,
628 .reg = EINJ_REG_MEMORY((u64)(uintptr_t)&einj_smi->setaddrtable),
629 .value = 1,
630 .mask = 0xffffffff
631 }
632 };
633
634 einj_smi->err_inj_cap = ACPI_EINJ_DEFAULT_CAP;
Elyes Haouas3141fbad2022-11-18 15:22:32 +0100635 einj_smi->trigger_action_table = (u64)(uintptr_t)tat;
Rocky Phaguraeff07132021-01-10 15:42:50 -0800636
637 for (i = 0; i < ACTION_COUNT; i++)
638 printk(BIOS_DEBUG, "default_actions[%d].reg.addr is %llx\n", i,
639 default_actions[i].reg.addr);
640
Rocky Phagurab46a9e52021-05-21 13:34:03 -0700641 memset((void *)einj, 0, sizeof(*einj));
Rocky Phaguraeff07132021-01-10 15:42:50 -0800642
Arthur Heymansadb80072023-06-28 09:56:00 +0200643 if (acpi_fill_header(header, "EINJ", EINJ, sizeof(acpi_einj_t)) != CB_SUCCESS)
644 return;
Rocky Phaguraeff07132021-01-10 15:42:50 -0800645
Rocky Phaguraeff07132021-01-10 15:42:50 -0800646 inj_header->einj_header_size = sizeof(acpi_injection_header_t);
647 inj_header->entry_count = ACTION_COUNT;
648
649 printk(BIOS_DEBUG, "%s einj->action_table = %p\n",
650 __func__, einj->action_table);
651 memcpy((void *)einj->action_table, (void *)default_actions, sizeof(einj->action_table));
Rocky Phagurab46a9e52021-05-21 13:34:03 -0700652 header->checksum = acpi_checksum((void *)einj, sizeof(*einj));
Rocky Phaguraeff07132021-01-10 15:42:50 -0800653}
654
Furquan Shaikh0f007d82020-04-24 06:41:18 -0700655void acpi_create_vfct(const struct device *device,
Himanshu Sahdev7f1da072019-10-21 15:27:19 +0530656 acpi_vfct_t *vfct,
Furquan Shaikh0f007d82020-04-24 06:41:18 -0700657 unsigned long (*acpi_fill_vfct)(const struct device *device,
Himanshu Sahdev7f1da072019-10-21 15:27:19 +0530658 acpi_vfct_t *vfct_struct, unsigned long current))
Patrick Rudolpha5c2ac62016-03-31 20:04:23 +0200659{
660 acpi_header_t *header = &(vfct->header);
Himanshu Sahdev7f1da072019-10-21 15:27:19 +0530661 unsigned long current = (unsigned long)vfct + sizeof(acpi_vfct_t);
Patrick Rudolpha5c2ac62016-03-31 20:04:23 +0200662
Himanshu Sahdev7f1da072019-10-21 15:27:19 +0530663 memset((void *)vfct, 0, sizeof(acpi_vfct_t));
Patrick Rudolpha5c2ac62016-03-31 20:04:23 +0200664
Arthur Heymansadb80072023-06-28 09:56:00 +0200665 if (acpi_fill_header(header, "VFCT", VFCT, sizeof(acpi_vfct_t)) != CB_SUCCESS)
John Zhao2ba303e2019-05-28 16:48:14 -0700666 return;
667
Patrick Rudolpha5c2ac62016-03-31 20:04:23 +0200668 current = acpi_fill_vfct(device, vfct, current);
669
Kyösti Mälkkifb493792019-06-30 06:29:52 +0300670 /* If no BIOS image, return with header->length == 0. */
671 if (!vfct->VBIOSImageOffset)
672 return;
673
Patrick Rudolpha5c2ac62016-03-31 20:04:23 +0200674 /* (Re)calculate length and checksum. */
675 header->length = current - (unsigned long)vfct;
676 header->checksum = acpi_checksum((void *)vfct, header->length);
677}
678
Furquan Shaikh0f007d82020-04-24 06:41:18 -0700679void acpi_create_ipmi(const struct device *device,
Patrick Rudolph9d98e5a2019-06-14 19:00:04 +0200680 struct acpi_spmi *spmi,
681 const u16 ipmi_revision,
682 const acpi_addr_t *addr,
683 const enum acpi_ipmi_interface_type type,
684 const s8 gpe_interrupt,
685 const u32 apic_interrupt,
686 const u32 uid)
687{
688 acpi_header_t *header = &(spmi->header);
689 memset((void *)spmi, 0, sizeof(struct acpi_spmi));
690
Arthur Heymansadb80072023-06-28 09:56:00 +0200691 if (acpi_fill_header(header, "SPMI", SPMI, sizeof(struct acpi_spmi)) != CB_SUCCESS)
692 return;
Patrick Rudolph9d98e5a2019-06-14 19:00:04 +0200693
694 spmi->reserved = 1;
695
696 if (device->path.type == DEVICE_PATH_PCI) {
697 spmi->pci_device_flag = ACPI_IPMI_PCI_DEVICE_FLAG;
698 spmi->pci_bus = device->bus->secondary;
699 spmi->pci_device = device->path.pci.devfn >> 3;
700 spmi->pci_function = device->path.pci.devfn & 0x7;
701 } else if (type != IPMI_INTERFACE_SSIF) {
702 memcpy(spmi->uid, &uid, sizeof(spmi->uid));
703 }
704
705 spmi->base_address = *addr;
706 spmi->specification_revision = ipmi_revision;
707
708 spmi->interface_type = type;
709
710 if (gpe_interrupt >= 0 && gpe_interrupt < 32) {
711 spmi->gpe = gpe_interrupt;
712 spmi->interrupt_type |= ACPI_IPMI_INT_TYPE_SCI;
713 }
714 if (apic_interrupt > 0) {
715 spmi->global_system_interrupt = apic_interrupt;
716 spmi->interrupt_type |= ACPI_IPMI_INT_TYPE_APIC;
717 }
718
719 /* Calculate checksum. */
720 header->checksum = acpi_checksum((void *)spmi, header->length);
721}
722
Timothy Pearsonff8ccf02015-08-11 17:48:32 -0500723void acpi_create_ivrs(acpi_ivrs_t *ivrs,
Lee Leahy6f80ccc2017-03-16 15:18:22 -0700724 unsigned long (*acpi_fill_ivrs)(acpi_ivrs_t *ivrs_struct,
725 unsigned long current))
Timothy Pearsonff8ccf02015-08-11 17:48:32 -0500726{
727 acpi_header_t *header = &(ivrs->header);
728 unsigned long current = (unsigned long)ivrs + sizeof(acpi_ivrs_t);
729
730 memset((void *)ivrs, 0, sizeof(acpi_ivrs_t));
731
Arthur Heymansadb80072023-06-28 09:56:00 +0200732 if (acpi_fill_header(header, "IVRS", IVRS, sizeof(acpi_ivrs_t)) != CB_SUCCESS)
John Zhao2ba303e2019-05-28 16:48:14 -0700733 return;
734
Timothy Pearsonff8ccf02015-08-11 17:48:32 -0500735 current = acpi_fill_ivrs(ivrs, current);
736
737 /* (Re)calculate length and checksum. */
738 header->length = current - (unsigned long)ivrs;
739 header->checksum = acpi_checksum((void *)ivrs, header->length);
740}
741
Jason Glenesk61624b22020-11-02 20:06:23 -0800742void acpi_create_crat(struct acpi_crat_header *crat,
743 unsigned long (*acpi_fill_crat)(struct acpi_crat_header *crat_struct,
744 unsigned long current))
745{
746 acpi_header_t *header = &(crat->header);
747 unsigned long current = (unsigned long)crat + sizeof(struct acpi_crat_header);
748
749 memset((void *)crat, 0, sizeof(struct acpi_crat_header));
750
Arthur Heymansadb80072023-06-28 09:56:00 +0200751 if (acpi_fill_header(header, "CRAT", CRAT, sizeof(struct acpi_crat_header)) != CB_SUCCESS)
Jason Glenesk61624b22020-11-02 20:06:23 -0800752 return;
753
Jason Glenesk61624b22020-11-02 20:06:23 -0800754 current = acpi_fill_crat(crat, current);
755
756 /* (Re)calculate length and checksum. */
757 header->length = current - (unsigned long)crat;
758 header->checksum = acpi_checksum((void *)crat, header->length);
759}
760
Arthur Heymans9368cf92023-04-25 16:07:49 +0200761static void acpi_create_dbg2(acpi_dbg2_header_t *dbg2,
Duncan Lauriee4a36c72017-11-11 19:33:25 -0800762 int port_type, int port_subtype,
763 acpi_addr_t *address, uint32_t address_size,
764 const char *device_path)
765{
766 uintptr_t current;
767 acpi_dbg2_device_t *device;
768 uint32_t *dbg2_addr_size;
769 acpi_header_t *header;
770 size_t path_len;
771 const char *path;
772 char *namespace;
773
774 /* Fill out header fields. */
775 current = (uintptr_t)dbg2;
776 memset(dbg2, 0, sizeof(acpi_dbg2_header_t));
777 header = &(dbg2->header);
John Zhao2ba303e2019-05-28 16:48:14 -0700778
Arthur Heymansadb80072023-06-28 09:56:00 +0200779 if (acpi_fill_header(header, "DBG2", DBG2, sizeof(acpi_dbg2_header_t)) != CB_SUCCESS)
John Zhao2ba303e2019-05-28 16:48:14 -0700780 return;
781
Duncan Lauriee4a36c72017-11-11 19:33:25 -0800782 /* One debug device defined */
783 dbg2->devices_offset = sizeof(acpi_dbg2_header_t);
784 dbg2->devices_count = 1;
785 current += sizeof(acpi_dbg2_header_t);
786
787 /* Device comes after the header */
788 device = (acpi_dbg2_device_t *)current;
789 memset(device, 0, sizeof(acpi_dbg2_device_t));
790 current += sizeof(acpi_dbg2_device_t);
791
792 device->revision = 0;
793 device->address_count = 1;
794 device->port_type = port_type;
795 device->port_subtype = port_subtype;
796
797 /* Base Address comes after device structure */
798 memcpy((void *)current, address, sizeof(acpi_addr_t));
799 device->base_address_offset = current - (uintptr_t)device;
800 current += sizeof(acpi_addr_t);
801
802 /* Address Size comes after address structure */
803 dbg2_addr_size = (uint32_t *)current;
804 device->address_size_offset = current - (uintptr_t)device;
805 *dbg2_addr_size = address_size;
806 current += sizeof(uint32_t);
807
808 /* Namespace string comes last, use '.' if not provided */
809 path = device_path ? : ".";
810 /* Namespace string length includes NULL terminator */
811 path_len = strlen(path) + 1;
812 namespace = (char *)current;
813 device->namespace_string_length = path_len;
814 device->namespace_string_offset = current - (uintptr_t)device;
815 strncpy(namespace, path, path_len);
816 current += path_len;
817
818 /* Update structure lengths and checksum */
819 device->length = current - (uintptr_t)device;
820 header->length = current - (uintptr_t)dbg2;
821 header->checksum = acpi_checksum((uint8_t *)dbg2, header->length);
822}
823
Arthur Heymans736d4d22023-06-30 15:37:38 +0200824static unsigned long acpi_write_dbg2_uart(acpi_rsdp_t *rsdp, unsigned long current,
825 int space_id, uint64_t base, uint32_t size,
826 int access_size, const char *name)
Duncan Lauriee4a36c72017-11-11 19:33:25 -0800827{
828 acpi_dbg2_header_t *dbg2 = (acpi_dbg2_header_t *)current;
Duncan Lauriee4a36c72017-11-11 19:33:25 -0800829 acpi_addr_t address;
830
Arthur Heymans736d4d22023-06-30 15:37:38 +0200831 memset(&address, 0, sizeof(address));
832
833 address.space_id = space_id;
834 address.addrl = (uint32_t)base;
835 address.addrh = (uint32_t)((base >> 32) & 0xffffffff);
836 address.access_size = access_size;
837
838 int subtype;
839 /* 16550-compatible with parameters defined in Generic Address Structure */
840 if (CONFIG(DRIVERS_UART_8250IO) || CONFIG(DRIVERS_UART_8250MEM))
841 subtype = ACPI_DBG2_PORT_SERIAL_16550;
842 else if (CONFIG(DRIVERS_UART_PL011))
843 subtype = ACPI_DBG2_PORT_SERIAL_ARM_PL011;
844 else
845 return current;
846
847 acpi_create_dbg2(dbg2,
848 ACPI_DBG2_PORT_SERIAL,
849 subtype,
850 &address, size,
851 name);
852
853 if (dbg2->header.length) {
854 current += dbg2->header.length;
855 current = acpi_align_current(current);
856 acpi_add_table(rsdp, dbg2);
857 }
858
859 return current;
860}
861
862unsigned long acpi_write_dbg2_pci_uart(acpi_rsdp_t *rsdp, unsigned long current,
863 const struct device *dev, uint8_t access_size)
864{
865 struct resource *res;
866
Duncan Lauriee4a36c72017-11-11 19:33:25 -0800867 if (!dev) {
Wim Vervoorn6cd52432020-02-03 14:41:46 +0100868 printk(BIOS_DEBUG, "%s: Device not found\n", __func__);
Duncan Lauriee4a36c72017-11-11 19:33:25 -0800869 return current;
870 }
Mario Scheithauerf1eb0ea2017-11-21 13:52:53 +0100871 if (!dev->enabled) {
872 printk(BIOS_INFO, "%s: Device not enabled\n", __func__);
873 return current;
874 }
Angel Pons32d09be2021-11-03 13:27:45 +0100875 res = probe_resource(dev, PCI_BASE_ADDRESS_0);
Duncan Lauriee4a36c72017-11-11 19:33:25 -0800876 if (!res) {
877 printk(BIOS_ERR, "%s: Unable to find resource for %s\n",
878 __func__, dev_path(dev));
879 return current;
880 }
881
Arthur Heymans736d4d22023-06-30 15:37:38 +0200882 int space_id;
Duncan Lauriee4a36c72017-11-11 19:33:25 -0800883 if (res->flags & IORESOURCE_IO)
Arthur Heymans736d4d22023-06-30 15:37:38 +0200884 space_id = ACPI_ADDRESS_SPACE_IO;
Duncan Lauriee4a36c72017-11-11 19:33:25 -0800885 else if (res->flags & IORESOURCE_MEM)
Arthur Heymans736d4d22023-06-30 15:37:38 +0200886 space_id = ACPI_ADDRESS_SPACE_MEMORY;
Duncan Lauriee4a36c72017-11-11 19:33:25 -0800887 else {
888 printk(BIOS_ERR, "%s: Unknown address space type\n", __func__);
889 return current;
890 }
891
Arthur Heymans736d4d22023-06-30 15:37:38 +0200892 return acpi_write_dbg2_uart(rsdp, current, space_id, res->base, res->size, access_size, acpi_device_path(dev));
893}
Duncan Lauriee4a36c72017-11-11 19:33:25 -0800894
Arthur Heymans736d4d22023-06-30 15:37:38 +0200895unsigned long acpi_pl011_write_dbg2_uart(acpi_rsdp_t *rsdp, unsigned long current,
896 uint64_t base, const char *name)
897{
898 return acpi_write_dbg2_uart(rsdp, current, ACPI_ADDRESS_SPACE_MEMORY, base,
899 sizeof(struct pl011_uart), ACPI_ACCESS_SIZE_DWORD_ACCESS,
900 name);
Duncan Lauriee4a36c72017-11-11 19:33:25 -0800901}
902
Zheng Bao3ea3fbe2023-11-20 14:17:25 +0800903unsigned long acpi_16550_mmio32_write_dbg2_uart(acpi_rsdp_t *rsdp, unsigned long current,
904 uint64_t base, const char *name)
905{
906 return acpi_write_dbg2_uart(rsdp, current, ACPI_ADDRESS_SPACE_MEMORY, base,
907 0x100, ACPI_ACCESS_SIZE_DWORD_ACCESS,
908 name);
909}
910
Arthur Heymans01af0f82023-06-27 11:58:04 +0200911static void acpi_create_facs(void *header)
Ronald G. Minnich02fa3b22004-10-06 17:33:54 +0000912{
Arthur Heymans01af0f82023-06-27 11:58:04 +0200913 acpi_facs_t *facs = header;
Ronald G. Minnich02fa3b22004-10-06 17:33:54 +0000914
Stefan Reinauercdfe3762009-07-21 22:15:43 +0000915 memcpy(facs->signature, "FACS", 4);
Ronald G. Minnich02fa3b22004-10-06 17:33:54 +0000916 facs->length = sizeof(acpi_facs_t);
917 facs->hardware_signature = 0;
918 facs->firmware_waking_vector = 0;
919 facs->global_lock = 0;
920 facs->flags = 0;
921 facs->x_firmware_waking_vector_l = 0;
922 facs->x_firmware_waking_vector_h = 0;
Marc Jones93a51762018-08-22 18:57:24 -0600923 facs->version = get_acpi_table_revision(FACS);
Ronald G. Minnich02fa3b22004-10-06 17:33:54 +0000924}
Stefan Reinauer777224c2005-01-19 14:06:41 +0000925
Vladimir Serbinenko351fefc2014-10-26 20:42:08 +0100926static void acpi_write_rsdt(acpi_rsdt_t *rsdt, char *oem_id, char *oem_table_id)
Stefan Reinauer14e22772010-04-27 06:56:47 +0000927{
Uwe Hermann622824c2010-11-19 15:14:42 +0000928 acpi_header_t *header = &(rsdt->header);
Stefan Reinauer14e22772010-04-27 06:56:47 +0000929
Arthur Heymansadb80072023-06-28 09:56:00 +0200930 if (acpi_fill_header(header, "RSDT", RSDT, sizeof(acpi_rsdt_t)) != CB_SUCCESS)
John Zhao2ba303e2019-05-28 16:48:14 -0700931 return;
932
Uwe Hermann622824c2010-11-19 15:14:42 +0000933 /* Entries are filled in later, we come with an empty set. */
Stefan Reinauer688b3852004-01-28 16:56:14 +0000934
Uwe Hermann622824c2010-11-19 15:14:42 +0000935 /* Fix checksum. */
Stefan Reinauerb657a3c2009-07-21 21:38:33 +0000936 header->checksum = acpi_checksum((void *)rsdt, sizeof(acpi_rsdt_t));
Stefan Reinauer688b3852004-01-28 16:56:14 +0000937}
938
Vladimir Serbinenko351fefc2014-10-26 20:42:08 +0100939static void acpi_write_xsdt(acpi_xsdt_t *xsdt, char *oem_id, char *oem_table_id)
Stefan Reinauer14e22772010-04-27 06:56:47 +0000940{
Uwe Hermann622824c2010-11-19 15:14:42 +0000941 acpi_header_t *header = &(xsdt->header);
Stefan Reinauer14e22772010-04-27 06:56:47 +0000942
Arthur Heymansadb80072023-06-28 09:56:00 +0200943 if (acpi_fill_header(header, "XSDT", XSDT, sizeof(acpi_xsdt_t)) != CB_SUCCESS)
John Zhao2ba303e2019-05-28 16:48:14 -0700944 return;
945
Uwe Hermann622824c2010-11-19 15:14:42 +0000946 /* Entries are filled in later, we come with an empty set. */
Stefan Reinauerb657a3c2009-07-21 21:38:33 +0000947
Uwe Hermann622824c2010-11-19 15:14:42 +0000948 /* Fix checksum. */
Stefan Reinauerb657a3c2009-07-21 21:38:33 +0000949 header->checksum = acpi_checksum((void *)xsdt, sizeof(acpi_xsdt_t));
950}
951
Vladimir Serbinenko351fefc2014-10-26 20:42:08 +0100952static void acpi_write_rsdp(acpi_rsdp_t *rsdp, acpi_rsdt_t *rsdt,
953 acpi_xsdt_t *xsdt, char *oem_id)
Stefan Reinauer688b3852004-01-28 16:56:14 +0000954{
Stefan Reinauerd18faac2009-11-05 18:06:43 +0000955 memset(rsdp, 0, sizeof(acpi_rsdp_t));
Uwe Hermann622824c2010-11-19 15:14:42 +0000956
Stefan Reinauer688b3852004-01-28 16:56:14 +0000957 memcpy(rsdp->signature, RSDP_SIG, 8);
Vladimir Serbinenko351fefc2014-10-26 20:42:08 +0100958 memcpy(rsdp->oem_id, oem_id, 6);
Uwe Hermann622824c2010-11-19 15:14:42 +0000959
960 rsdp->length = sizeof(acpi_rsdp_t);
Stefan Reinauerdefee172015-06-18 01:11:19 -0700961 rsdp->rsdt_address = (uintptr_t)rsdt;
Uwe Hermann622824c2010-11-19 15:14:42 +0000962
963 /*
964 * Revision: ACPI 1.0: 0, ACPI 2.0/3.0/4.0: 2.
965 *
966 * Some OSes expect an XSDT to be present for RSD PTR revisions >= 2.
967 * If we don't have an ACPI XSDT, force ACPI 1.0 (and thus RSD PTR
968 * revision 0).
Stefan Reinauerb657a3c2009-07-21 21:38:33 +0000969 */
970 if (xsdt == NULL) {
Uwe Hermann622824c2010-11-19 15:14:42 +0000971 rsdp->revision = 0;
Stefan Reinauerb657a3c2009-07-21 21:38:33 +0000972 } else {
Stefan Reinauerdefee172015-06-18 01:11:19 -0700973 rsdp->xsdt_address = (u64)(uintptr_t)xsdt;
Marc Jones93a51762018-08-22 18:57:24 -0600974 rsdp->revision = get_acpi_table_revision(RSDP);
Stefan Reinauerb657a3c2009-07-21 21:38:33 +0000975 }
Uwe Hermann622824c2010-11-19 15:14:42 +0000976
977 /* Calculate checksums. */
978 rsdp->checksum = acpi_checksum((void *)rsdp, 20);
979 rsdp->ext_checksum = acpi_checksum((void *)rsdp, sizeof(acpi_rsdp_t));
Stefan Reinauer688b3852004-01-28 16:56:14 +0000980}
981
Lee Leahy6f80ccc2017-03-16 15:18:22 -0700982unsigned long acpi_create_hest_error_source(acpi_hest_t *hest,
983 acpi_hest_esd_t *esd, u16 type, void *data, u16 data_len)
zbaocaf494c82012-04-13 13:57:14 +0800984{
985 acpi_header_t *header = &(hest->header);
986 acpi_hest_hen_t *hen;
987 void *pos;
988 u16 len;
989
990 pos = esd;
991 memset(pos, 0, sizeof(acpi_hest_esd_t));
992 len = 0;
993 esd->type = type; /* MCE */
994 esd->source_id = hest->error_source_count;
995 esd->flags = 0; /* FIRMWARE_FIRST */
996 esd->enabled = 1;
997 esd->prealloc_erecords = 1;
998 esd->max_section_per_record = 0x1;
999
1000 len += sizeof(acpi_hest_esd_t);
1001 pos = esd + 1;
1002
1003 switch (type) {
1004 case 0: /* MCE */
1005 break;
1006 case 1: /* CMC */
Elyes Haouas3141fbad2022-11-18 15:22:32 +01001007 hen = (acpi_hest_hen_t *)(pos);
zbaocaf494c82012-04-13 13:57:14 +08001008 memset(pos, 0, sizeof(acpi_hest_hen_t));
1009 hen->type = 3; /* SCI? */
1010 hen->length = sizeof(acpi_hest_hen_t);
Lee Leahy6f80ccc2017-03-16 15:18:22 -07001011 hen->conf_we = 0; /* Configuration Write Enable. */
zbaocaf494c82012-04-13 13:57:14 +08001012 hen->poll_interval = 0;
1013 hen->vector = 0;
1014 hen->sw2poll_threshold_val = 0;
1015 hen->sw2poll_threshold_win = 0;
1016 hen->error_threshold_val = 0;
1017 hen->error_threshold_win = 0;
1018 len += sizeof(acpi_hest_hen_t);
1019 pos = hen + 1;
1020 break;
1021 case 2: /* NMI */
1022 case 6: /* AER Root Port */
1023 case 7: /* AER Endpoint */
1024 case 8: /* AER Bridge */
1025 case 9: /* Generic Hardware Error Source. */
1026 /* TODO: */
1027 break;
1028 default:
1029 printk(BIOS_DEBUG, "Invalid type of Error Source.");
1030 break;
1031 }
Lee Leahy024b13d2017-03-16 13:41:11 -07001032 hest->error_source_count++;
zbaocaf494c82012-04-13 13:57:14 +08001033
1034 memcpy(pos, data, data_len);
1035 len += data_len;
John Zhao2ba303e2019-05-28 16:48:14 -07001036 if (header)
1037 header->length += len;
zbaocaf494c82012-04-13 13:57:14 +08001038
1039 return len;
1040}
1041
1042/* ACPI 4.0 */
Vladimir Serbinenko807127f2014-11-09 13:36:18 +01001043void acpi_write_hest(acpi_hest_t *hest,
1044 unsigned long (*acpi_fill_hest)(acpi_hest_t *hest))
zbaocaf494c82012-04-13 13:57:14 +08001045{
1046 acpi_header_t *header = &(hest->header);
1047
1048 memset(hest, 0, sizeof(acpi_hest_t));
1049
Arthur Heymansadb80072023-06-28 09:56:00 +02001050 if (acpi_fill_header(header, "HEST", HEST, sizeof(acpi_hest_t)) != CB_SUCCESS)
John Zhao2ba303e2019-05-28 16:48:14 -07001051 return;
1052
zbaocaf494c82012-04-13 13:57:14 +08001053 acpi_fill_hest(hest);
1054
1055 /* Calculate checksums. */
1056 header->checksum = acpi_checksum((void *)hest, header->length);
1057}
1058
Marshall Dawson1d8d3692018-09-04 13:45:26 -06001059/* ACPI 3.0b */
Arthur Heymans01af0f82023-06-27 11:58:04 +02001060static void acpi_create_bert(acpi_header_t *header, void *unused)
Marshall Dawson1d8d3692018-09-04 13:45:26 -06001061{
Arthur Heymans01af0f82023-06-27 11:58:04 +02001062 if (!CONFIG(ACPI_BERT))
1063 return;
Marshall Dawson1d8d3692018-09-04 13:45:26 -06001064
Arthur Heymans01af0f82023-06-27 11:58:04 +02001065 acpi_bert_t *bert = (acpi_bert_t *)header;
Marshall Dawson1d8d3692018-09-04 13:45:26 -06001066
Arthur Heymans01af0f82023-06-27 11:58:04 +02001067 void *region;
1068 size_t size;
1069 if (acpi_soc_get_bert_region(&region, &size) != CB_SUCCESS)
1070 return;
1071
Arthur Heymansadb80072023-06-28 09:56:00 +02001072 if (acpi_fill_header(header, "BERT", BERT, sizeof(acpi_bert_t)) != CB_SUCCESS)
1073 return;
Marshall Dawson1d8d3692018-09-04 13:45:26 -06001074
Arthur Heymans01af0f82023-06-27 11:58:04 +02001075 bert->error_region = (uintptr_t)region;
1076 bert->region_length = (size_t)size;
Marshall Dawson1d8d3692018-09-04 13:45:26 -06001077}
1078
Angel Pons79572e42020-07-13 00:17:43 +02001079__weak void arch_fill_fadt(acpi_fadt_t *fadt) { }
Kyösti Mälkkif9aac922020-05-30 16:16:28 +03001080__weak void soc_fill_fadt(acpi_fadt_t *fadt) { }
Kyösti Mälkki02fd15d2020-06-02 03:34:43 +03001081__weak void mainboard_fill_fadt(acpi_fadt_t *fadt) { }
Kyösti Mälkkif9aac922020-05-30 16:16:28 +03001082
Arthur Heymans01af0f82023-06-27 11:58:04 +02001083static acpi_header_t *dsdt;
1084static void acpi_create_fadt(acpi_header_t *header, void *arg1)
Vladimir Serbinenkoc21e0732014-10-16 12:48:19 +02001085{
Arthur Heymans01af0f82023-06-27 11:58:04 +02001086 acpi_fadt_t *fadt = (acpi_fadt_t *)header;
1087 acpi_facs_t *facs = (acpi_facs_t *)(*(acpi_facs_t **)arg1);
John Zhao2ba303e2019-05-28 16:48:14 -07001088
Arthur Heymansadb80072023-06-28 09:56:00 +02001089 if (acpi_fill_header(header, "FACP", FADT, sizeof(acpi_fadt_t)) != CB_SUCCESS)
John Zhao2ba303e2019-05-28 16:48:14 -07001090 return;
1091
Elyes Haouas532e0432022-02-21 18:13:58 +01001092 fadt->FADT_MinorVersion = get_acpi_fadt_minor_version();
Arthur Heymans8473e8f2023-06-29 20:26:39 +02001093 if ((uintptr_t)facs <= UINT32_MAX)
1094 fadt->firmware_ctrl = (uintptr_t)facs;
1095 else
1096 fadt->x_firmware_ctl_h = (uint32_t)((uint64_t)(uintptr_t)facs >> 32);
1097 fadt->x_firmware_ctl_l = (uint32_t)(uintptr_t)facs;
Kyösti Mälkkid4acee82020-06-03 07:20:55 +03001098
Arthur Heymans8473e8f2023-06-29 20:26:39 +02001099 if ((uintptr_t)dsdt <= UINT32_MAX)
1100 fadt->dsdt = (uintptr_t)dsdt;
1101 else
1102 fadt->x_dsdt_h = (uint32_t)((uint64_t)(uintptr_t)dsdt >> 32);
1103 fadt->x_dsdt_l = (uint32_t)(uintptr_t)dsdt;
Vladimir Serbinenkoc21e0732014-10-16 12:48:19 +02001104
Kyösti Mälkkid4acee82020-06-03 07:20:55 +03001105 /* should be 0 ACPI 3.0 */
1106 fadt->reserved = 0;
1107
Kyösti Mälkki67c48a32023-04-14 10:20:03 +03001108 /* P_LVLx latencies are not used as CPU _CST will override them. */
1109 fadt->p_lvl2_lat = ACPI_FADT_C2_NOT_SUPPORTED;
1110 fadt->p_lvl3_lat = ACPI_FADT_C3_NOT_SUPPORTED;
1111
Kyösti Mälkki9ff97972023-04-14 15:37:27 +03001112 /* Use CPU _PTC instead to provide P_CNT details. */
1113 fadt->duty_offset = 0;
1114 fadt->duty_width = 0;
1115
Kyösti Mälkkie0d38682020-06-07 12:01:58 +03001116 fadt->preferred_pm_profile = acpi_get_preferred_pm_profile();
Vladimir Serbinenkoc21e0732014-10-16 12:48:19 +02001117
Angel Pons79572e42020-07-13 00:17:43 +02001118 arch_fill_fadt(fadt);
1119
Vladimir Serbinenkoab83ef02014-10-25 15:18:25 +02001120 acpi_fill_fadt(fadt);
Vladimir Serbinenkoc21e0732014-10-16 12:48:19 +02001121
Kyösti Mälkkif9aac922020-05-30 16:16:28 +03001122 soc_fill_fadt(fadt);
Kyösti Mälkki02fd15d2020-06-02 03:34:43 +03001123 mainboard_fill_fadt(fadt);
Vladimir Serbinenkoc21e0732014-10-16 12:48:19 +02001124}
Vladimir Serbinenkoc21e0732014-10-16 12:48:19 +02001125
Arthur Heymans01af0f82023-06-27 11:58:04 +02001126static void acpi_create_lpit(acpi_header_t *header, void *unused)
Michael Niewöhnerf0a44ae2021-01-01 21:04:09 +01001127{
Arthur Heymans01af0f82023-06-27 11:58:04 +02001128 if (!CONFIG(ACPI_LPIT))
1129 return;
Michael Niewöhnerf0a44ae2021-01-01 21:04:09 +01001130
Arthur Heymans01af0f82023-06-27 11:58:04 +02001131 acpi_lpit_t *lpit = (acpi_lpit_t *)header;
1132 unsigned long current = (unsigned long)lpit + sizeof(acpi_lpit_t);
Michael Niewöhnerf0a44ae2021-01-01 21:04:09 +01001133
Arthur Heymansadb80072023-06-28 09:56:00 +02001134 if (acpi_fill_header(header, "LPIT", LPIT, sizeof(acpi_lpit_t)) != CB_SUCCESS)
Michael Niewöhnerf0a44ae2021-01-01 21:04:09 +01001135 return;
1136
Michael Niewöhnerf0a44ae2021-01-01 21:04:09 +01001137 current = acpi_fill_lpit(current);
1138
Arthur Heymans01af0f82023-06-27 11:58:04 +02001139 /* (Re)calculate length. */
Michael Niewöhnerf0a44ae2021-01-01 21:04:09 +01001140 header->length = current - (unsigned long)lpit;
Michael Niewöhnerf0a44ae2021-01-01 21:04:09 +01001141}
1142
Arthur Heymans2e3cb632023-06-30 15:01:08 +02001143static void acpi_create_gtdt(acpi_header_t *header, void *unused)
1144{
1145 if (!CONFIG(ACPI_GTDT))
1146 return;
1147
1148 acpi_gtdt_t *gtdt = (acpi_gtdt_t *)header;
1149 unsigned long current = (unsigned long)gtdt + sizeof(acpi_gtdt_t);
1150
1151 if (acpi_fill_header(header, "GTDT", GTDT, sizeof(acpi_gtdt_t)) != CB_SUCCESS)
1152 return;
1153
1154 /* Fill out header fields. */
1155 gtdt->platform_timer_offset = sizeof(acpi_gtdt_t);
1156
1157 acpi_soc_fill_gtdt(gtdt);
1158 current = acpi_soc_gtdt_add_timers(&gtdt->platform_timer_count, current);
1159
1160 /* (Re)calculate length. */
1161 header->length = current - (unsigned long)gtdt;
1162}
1163
1164unsigned long acpi_gtdt_add_timer_block(unsigned long current, const uint64_t address,
1165 struct acpi_gtdt_timer_entry *timers, size_t number)
1166{
1167 struct acpi_gtdt_timer_block *block = (struct acpi_gtdt_timer_block *)current;
1168 memset(block, 0, sizeof(struct acpi_gtdt_timer_block));
1169
1170 assert(number < 8 && number != 0);
1171 const size_t entries_size = number * sizeof(struct acpi_gtdt_timer_entry);
1172
1173 block->header.type = ACPI_GTDT_TYPE_TIMER_BLOCK;
1174 block->header.length = sizeof(struct acpi_gtdt_timer_block)
1175 + entries_size;
1176 block->block_address = address;
1177 block->timer_count = number;
1178 block->timer_offset = sizeof(struct acpi_gtdt_timer_block);
1179 current += sizeof(struct acpi_gtdt_timer_block);
1180 memcpy((void *)current, timers, entries_size);
1181 current += entries_size;
1182 return current;
1183}
1184
1185unsigned long acpi_gtdt_add_watchdog(unsigned long current, uint64_t refresh_frame,
1186 uint64_t control_frame, uint32_t gsiv, uint32_t flags)
1187{
1188 struct acpi_gtdt_watchdog *wd = (struct acpi_gtdt_watchdog *)current;
1189 memset(wd, 0, sizeof(struct acpi_gtdt_watchdog));
1190
1191 wd->header.type = ACPI_GTDT_TYPE_WATCHDOG;
1192 wd->header.length = sizeof(struct acpi_gtdt_watchdog);
1193 wd->refresh_frame_address = refresh_frame;
1194 wd->control_frame_address = control_frame;
1195 wd->timer_interrupt = gsiv;
1196 wd->timer_flags = flags;
1197
1198 return current + sizeof(struct acpi_gtdt_watchdog);
1199}
1200
Naresh Solanki6920c6f2023-09-13 12:01:58 +02001201static void acpi_create_iort(acpi_header_t *header, void *unused)
1202{
1203 if (!CONFIG(ACPI_IORT))
1204 return;
1205
1206 acpi_iort_t *iort = (acpi_iort_t *)header;
1207 unsigned long current = (unsigned long)iort + sizeof(acpi_iort_t);
1208
1209 if (acpi_fill_header(header, "IORT", IORT, sizeof(acpi_iort_t)) != CB_SUCCESS)
1210 return;
1211
1212 iort->node_count = 0;
1213 iort->node_offset = current - (unsigned long)iort;
1214
1215 current = acpi_soc_fill_iort(iort, current);
1216
1217 /* (Re)calculate length */
1218 header->length = current - (unsigned long)iort;
1219}
1220
Marek Maslanka017003c2023-12-07 13:21:35 +00001221static void acpi_create_wdat(acpi_header_t *header, void *unused)
1222{
1223 if (!CONFIG(ACPI_WDAT_WDT))
1224 return;
1225
1226 acpi_wdat_t *wdat = (acpi_wdat_t *)header;
1227 unsigned long current = (unsigned long)wdat + sizeof(acpi_wdat_t);
1228
1229 memset((void *)wdat, 0, sizeof(acpi_wdat_t));
1230
1231 if (acpi_fill_header(header, "WDAT", WDAT, sizeof(acpi_wdat_t)) != CB_SUCCESS)
1232 return;
1233
1234 current = acpi_soc_fill_wdat(wdat, current);
1235
1236 /* (Re)calculate length. */
1237 header->length = current - (unsigned long)wdat;
1238}
1239
Michael Niewöhnerf0a44ae2021-01-01 21:04:09 +01001240unsigned long acpi_create_lpi_desc_ncst(acpi_lpi_desc_ncst_t *lpi_desc, uint16_t uid)
1241{
1242 memset(lpi_desc, 0, sizeof(acpi_lpi_desc_ncst_t));
1243 lpi_desc->header.length = sizeof(acpi_lpi_desc_ncst_t);
1244 lpi_desc->header.type = ACPI_LPI_DESC_TYPE_NATIVE_CSTATE;
1245 lpi_desc->header.uid = uid;
1246
1247 return lpi_desc->header.length;
1248}
1249
David Milosevicd9822742023-09-22 14:34:28 +02001250static void acpi_create_pptt(acpi_header_t *header, void *unused)
1251{
1252 if (!CONFIG(ACPI_PPTT))
1253 return;
1254
1255 if (acpi_fill_header(header, "PPTT", PPTT, sizeof(acpi_pptt_t)) != CB_SUCCESS)
1256 return;
1257
1258 acpi_pptt_t *pptt = (acpi_pptt_t *)header;
1259 acpi_create_pptt_body(pptt);
1260}
1261
Arthur Heymans90464072023-06-07 12:53:50 +02001262static uint8_t acpi_spcr_type(void)
1263{
1264 /* 16550-compatible with parameters defined in Generic Address Structure */
1265 if (CONFIG(DRIVERS_UART_8250IO) || CONFIG(DRIVERS_UART_8250MEM))
1266 return 0x12;
1267 if (CONFIG(DRIVERS_UART_PL011))
1268 return 0x3;
1269
1270 printk(BIOS_ERR, "%s: unknown serial type\n", __func__);
1271 return 0xff;
1272}
1273
Arthur Heymans01af0f82023-06-27 11:58:04 +02001274static void acpi_create_spcr(acpi_header_t *header, void *unused)
Arthur Heymans90464072023-06-07 12:53:50 +02001275{
Arthur Heymans01af0f82023-06-27 11:58:04 +02001276 acpi_spcr_t *spcr = (acpi_spcr_t *)header;
Arthur Heymans90464072023-06-07 12:53:50 +02001277 struct lb_serial serial;
1278
Arthur Heymans90464072023-06-07 12:53:50 +02001279 if (!CONFIG(CONSOLE_SERIAL))
1280 return;
1281
1282 if (fill_lb_serial(&serial) != CB_SUCCESS)
1283 return;
1284
Arthur Heymansadb80072023-06-28 09:56:00 +02001285 if (acpi_fill_header(header, "SPCR", SPCR, sizeof(acpi_spcr_t)) != CB_SUCCESS)
1286 return;
Arthur Heymans90464072023-06-07 12:53:50 +02001287
1288 spcr->interface_type = acpi_spcr_type();
1289 assert(serial.type == LB_SERIAL_TYPE_IO_MAPPED
1290 || serial.type == LB_SERIAL_TYPE_MEMORY_MAPPED);
1291 spcr->base_address.space_id = serial.type == LB_SERIAL_TYPE_IO_MAPPED ?
1292 ACPI_ADDRESS_SPACE_IO : ACPI_ADDRESS_SPACE_MEMORY;
1293 spcr->base_address.bit_width = serial.regwidth * 8;
1294 spcr->base_address.bit_offset = 0;
1295 switch (serial.regwidth) {
1296 case 1:
1297 spcr->base_address.access_size = ACPI_ACCESS_SIZE_BYTE_ACCESS;
1298 break;
1299 case 2:
1300 spcr->base_address.access_size = ACPI_ACCESS_SIZE_WORD_ACCESS;
1301 break;
1302 case 4:
1303 spcr->base_address.access_size = ACPI_ACCESS_SIZE_DWORD_ACCESS;
1304 break;
1305 default:
1306 printk(BIOS_ERR, "%s, Invalid serial regwidth\n", __func__);
1307 }
1308
1309 spcr->base_address.addrl = serial.baseaddr;
1310 spcr->base_address.addrh = 0;
1311 spcr->interrupt_type = 0;
1312 spcr->irq = 0;
1313 spcr->configured_baudrate = 0; /* Have the OS use whatever is currently set */
1314 spcr->parity = 0;
1315 spcr->stop_bits = 1;
1316 spcr->flow_control = 0;
1317 spcr->terminal_type = 2; /* 2 = VT-UTF8 */
1318 spcr->language = 0;
1319 spcr->pci_did = 0xffff;
1320 spcr->pci_vid = 0xffff;
Nico Huberfeb27dc2023-06-28 20:09:30 +02001321
1322 header->checksum = acpi_checksum((void *)spcr, header->length);
Arthur Heymans90464072023-06-07 12:53:50 +02001323}
1324
Aaron Durbin64031672018-04-21 14:45:32 -06001325unsigned long __weak fw_cfg_acpi_tables(unsigned long start)
Vladimir Serbinenko41877d82014-09-01 22:18:01 +02001326{
1327 return 0;
1328}
1329
Raul E Rangel6b446b92021-11-19 11:38:35 -07001330void preload_acpi_dsdt(void)
1331{
1332 const char *file = CONFIG_CBFS_PREFIX "/dsdt.aml";
1333
1334 if (!CONFIG(CBFS_PRELOAD))
1335 return;
1336
1337 printk(BIOS_DEBUG, "Preloading %s\n", file);
1338 cbfs_preload(file);
1339}
1340
Arthur Heymans01af0f82023-06-27 11:58:04 +02001341static void acpi_create_dsdt(acpi_header_t *header, void *dsdt_file_arg)
1342{
1343 dsdt = header;
1344 acpi_header_t *dsdt_file = *(acpi_header_t **)dsdt_file_arg;
1345 unsigned long current = (unsigned long)header;
1346
1347 dsdt = (acpi_header_t *)current;
1348 memcpy(dsdt, dsdt_file, sizeof(acpi_header_t));
1349 if (dsdt->length >= sizeof(acpi_header_t)) {
1350 current += sizeof(acpi_header_t);
1351
1352 acpigen_set_current((char *)current);
1353
1354 if (CONFIG(ACPI_SOC_NVS))
1355 acpi_fill_gnvs();
1356 if (CONFIG(CHROMEOS_NVS))
1357 acpi_fill_cnvs();
1358
1359 for (const struct device *dev = all_devices; dev; dev = dev->next)
1360 if (dev->ops && dev->ops->acpi_inject_dsdt)
1361 dev->ops->acpi_inject_dsdt(dev);
1362 current = (unsigned long)acpigen_get_current();
1363 memcpy((char *)current,
1364 (char *)dsdt_file + sizeof(acpi_header_t),
1365 dsdt->length - sizeof(acpi_header_t));
1366 current += dsdt->length - sizeof(acpi_header_t);
1367
1368 /* (Re)calculate length. */
1369 dsdt->length = current - (unsigned long)dsdt;
1370 }
1371}
1372
1373static void acpi_create_slic(acpi_header_t *header, void *slic_file_arg)
1374{
1375 acpi_header_t *slic_file = *(acpi_header_t **)slic_file_arg;
1376 acpi_header_t *slic = header;
1377 if (slic_file)
1378 memcpy(slic, slic_file, slic_file->length);
1379}
1380
Arthur Heymans2e7e2d92022-03-03 22:28:27 +01001381static uintptr_t coreboot_rsdp;
1382
1383uintptr_t get_coreboot_rsdp(void)
1384{
1385 return coreboot_rsdp;
1386}
1387
Arthur Heymans0ad766c2023-06-07 10:45:59 +02001388static void acpixtract_compatible_hexdump(const void *memory, size_t length)
1389{
1390 size_t i, j;
1391 uint8_t *line;
1392 size_t num_bytes;
1393
1394 for (i = 0; i < length; i += 16) {
1395 num_bytes = MIN(length - i, 16);
1396 line = ((uint8_t *)memory) + i;
1397
1398 printk(BIOS_SPEW, " %04zX:", i);
1399 for (j = 0; j < num_bytes; j++)
1400 printk(BIOS_SPEW, " %02x", line[j]);
1401 for (; j < 16; j++)
1402 printk(BIOS_SPEW, " ");
1403 printk(BIOS_SPEW, " ");
1404 for (j = 0; j < num_bytes; j++)
1405 printk(BIOS_SPEW, "%c",
1406 isprint(line[j]) ? line[j] : '.');
1407 printk(BIOS_SPEW, "\n");
1408 }
1409}
1410
1411static void acpidump_print(void *table_ptr)
1412{
Felix Held67b3c8f2023-08-03 01:08:14 +02001413 if (table_ptr == NULL)
1414 return;
Arthur Heymans0ad766c2023-06-07 10:45:59 +02001415 const acpi_header_t *header = (acpi_header_t *)table_ptr;
1416 const size_t table_size = header->length;
1417 printk(BIOS_SPEW, "%.4s @ 0x0000000000000000\n", header->signature);
1418 acpixtract_compatible_hexdump(table_ptr, table_size);
1419 printk(BIOS_SPEW, "\n");
1420}
1421
Arthur Heymans7ebebf72023-06-17 14:08:46 +02001422unsigned long write_acpi_tables(const unsigned long start)
Vladimir Serbinenko2d7bd8a2014-08-30 19:28:05 +02001423{
1424 unsigned long current;
1425 acpi_rsdp_t *rsdp;
Arthur Heymans0ad766c2023-06-07 10:45:59 +02001426 acpi_rsdt_t *rsdt = NULL;
1427 acpi_xsdt_t *xsdt = NULL;
Arthur Heymans0ad766c2023-06-07 10:45:59 +02001428 acpi_facs_t *facs = NULL;
Arthur Heymans01af0f82023-06-27 11:58:04 +02001429 acpi_header_t *slic_file;
Arthur Heymans0ad766c2023-06-07 10:45:59 +02001430 acpi_header_t *ssdt = NULL;
Arthur Heymans01af0f82023-06-27 11:58:04 +02001431 acpi_header_t *dsdt_file;
Edward O'Callaghan2c9d2cf2014-10-27 23:29:29 +11001432 struct device *dev;
Vladimir Serbinenko41877d82014-09-01 22:18:01 +02001433 unsigned long fw;
Vladimir Serbinenko36f8d272015-05-31 12:31:59 +02001434 size_t slic_size, dsdt_size;
Vladimir Serbinenko351fefc2014-10-26 20:42:08 +01001435 char oem_id[6], oem_table_id[8];
Vladimir Serbinenko2d7bd8a2014-08-30 19:28:05 +02001436
Arthur Heymans01af0f82023-06-27 11:58:04 +02001437 const struct acpi_table_generator {
1438 void (*create_table)(acpi_header_t *table, void *arg);
1439 void *args;
1440 size_t min_size;
1441 } tables[] = {
1442 { acpi_create_dsdt, &dsdt_file, sizeof(acpi_header_t) },
1443 { acpi_create_fadt, &facs, sizeof(acpi_fadt_t) },
1444 { acpi_create_slic, &slic_file, sizeof(acpi_header_t) },
1445 { acpi_create_ssdt_generator, NULL, sizeof(acpi_header_t) },
1446 { acpi_create_mcfg, NULL, sizeof(acpi_mcfg_t) },
1447 { acpi_create_tcpa, NULL, sizeof(acpi_tcpa_t) },
1448 { acpi_create_tpm2, NULL, sizeof(acpi_tpm2_t) },
1449 { acpi_create_lpit, NULL, sizeof(acpi_lpit_t) },
1450 { acpi_create_madt, NULL, sizeof(acpi_header_t) },
1451 { acpi_create_bert, NULL, sizeof(acpi_bert_t) },
1452 { acpi_create_spcr, NULL, sizeof(acpi_spcr_t) },
Arthur Heymans2e3cb632023-06-30 15:01:08 +02001453 { acpi_create_gtdt, NULL, sizeof(acpi_gtdt_t) },
David Milosevicd9822742023-09-22 14:34:28 +02001454 { acpi_create_pptt, NULL, sizeof(acpi_pptt_t) },
Naresh Solanki6920c6f2023-09-13 12:01:58 +02001455 { acpi_create_iort, NULL, sizeof(acpi_iort_t) },
Marek Maslanka017003c2023-12-07 13:21:35 +00001456 { acpi_create_wdat, NULL, sizeof(acpi_wdat_t) },
Arthur Heymans01af0f82023-06-27 11:58:04 +02001457 };
1458
Vladimir Serbinenko2d7bd8a2014-08-30 19:28:05 +02001459 current = start;
1460
1461 /* Align ACPI tables to 16byte */
Aaron Durbin07a1b282015-12-10 17:07:38 -06001462 current = acpi_align_current(current);
Vladimir Serbinenko2d7bd8a2014-08-30 19:28:05 +02001463
Patrick Rudolphcfe08ff2019-09-10 15:40:47 +02001464 /* Special case for qemu */
Vladimir Serbinenko41877d82014-09-01 22:18:01 +02001465 fw = fw_cfg_acpi_tables(current);
Patrick Rudolphcfe08ff2019-09-10 15:40:47 +02001466 if (fw) {
1467 rsdp = NULL;
1468 /* Find RSDP. */
1469 for (void *p = (void *)current; p < (void *)fw; p += 16) {
1470 if (valid_rsdp((acpi_rsdp_t *)p)) {
1471 rsdp = p;
Bin Mengf3027b82023-05-09 15:21:49 +08001472 coreboot_rsdp = (uintptr_t)rsdp;
Patrick Rudolphcfe08ff2019-09-10 15:40:47 +02001473 break;
1474 }
1475 }
1476 if (!rsdp)
1477 return fw;
1478
Arthur Heymansc2830c92023-08-22 12:50:43 +02001479 current = fw;
1480 current = acpi_align_current(current);
1481 if (rsdp->xsdt_address == 0) {
1482 xsdt = (acpi_xsdt_t *)current;
1483 current += sizeof(acpi_xsdt_t);
1484 current = acpi_align_current(current);
1485
1486 /*
1487 * Qemu only creates an RSDT.
1488 * Add an XSDT based on the existing RSDT entries.
1489 */
1490 acpi_rsdt_t *existing_rsdt = (acpi_rsdt_t *)(uintptr_t)rsdp->rsdt_address;
1491 acpi_write_rsdp(rsdp, existing_rsdt, xsdt, oem_id);
1492 acpi_write_xsdt(xsdt, oem_id, oem_table_id);
1493 /*
1494 * Copy existing entries to the new XSDT. This will override existing
1495 * RSDT entries with the same value.
1496 */
1497 for (int i = 0; existing_rsdt->entry[i]; i++)
1498 acpi_add_table(rsdp, (void *)(uintptr_t)existing_rsdt->entry[i]);
1499
1500 }
1501
Patrick Rudolphcfe08ff2019-09-10 15:40:47 +02001502 /* Add BOOT0000 for Linux google firmware driver */
1503 printk(BIOS_DEBUG, "ACPI: * SSDT\n");
Arthur Heymansc2830c92023-08-22 12:50:43 +02001504 ssdt = (acpi_header_t *)current;
1505 current += sizeof(acpi_header_t);
Patrick Rudolphcfe08ff2019-09-10 15:40:47 +02001506
1507 memset((void *)ssdt, 0, sizeof(acpi_header_t));
1508
1509 memcpy(&ssdt->signature, "SSDT", 4);
1510 ssdt->revision = get_acpi_table_revision(SSDT);
1511 memcpy(&ssdt->oem_id, OEM_ID, 6);
1512 memcpy(&ssdt->oem_table_id, oem_table_id, 8);
1513 ssdt->oem_revision = 42;
1514 memcpy(&ssdt->asl_compiler_id, ASLC, 4);
1515 ssdt->asl_compiler_revision = asl_revision;
1516 ssdt->length = sizeof(acpi_header_t);
1517
Elyes Haouas3141fbad2022-11-18 15:22:32 +01001518 acpigen_set_current((char *)current);
Patrick Rudolphcfe08ff2019-09-10 15:40:47 +02001519
1520 /* Write object to declare coreboot tables */
1521 acpi_ssdt_write_cbtable();
1522
1523 /* (Re)calculate length and checksum. */
1524 ssdt->length = current - (unsigned long)ssdt;
1525 ssdt->checksum = acpi_checksum((void *)ssdt, ssdt->length);
1526
Arthur Heymans01af0f82023-06-27 11:58:04 +02001527 acpi_create_ssdt_generator(ssdt, NULL);
Patrick Rudolphcfe08ff2019-09-10 15:40:47 +02001528
1529 acpi_add_table(rsdp, ssdt);
1530
Vladimir Serbinenko41877d82014-09-01 22:18:01 +02001531 return fw;
Patrick Rudolphcfe08ff2019-09-10 15:40:47 +02001532 }
Vladimir Serbinenko41877d82014-09-01 22:18:01 +02001533
Julius Werner834b3ec2020-03-04 16:52:08 -08001534 dsdt_file = cbfs_map(CONFIG_CBFS_PREFIX "/dsdt.aml", &dsdt_size);
Vladimir Serbinenko36f8d272015-05-31 12:31:59 +02001535 if (!dsdt_file) {
1536 printk(BIOS_ERR, "No DSDT file, skipping ACPI tables\n");
Arthur Heymans0600aa62023-06-17 14:13:54 +02001537 return start;
Vladimir Serbinenko36f8d272015-05-31 12:31:59 +02001538 }
1539
1540 if (dsdt_file->length > dsdt_size
Elyes HAOUAS7d87e762016-10-03 22:11:07 +02001541 || dsdt_file->length < sizeof(acpi_header_t)
Vladimir Serbinenko36f8d272015-05-31 12:31:59 +02001542 || memcmp(dsdt_file->signature, "DSDT", 4) != 0) {
1543 printk(BIOS_ERR, "Invalid DSDT file, skipping ACPI tables\n");
Grzegorz Bernacki042ac352023-04-21 13:19:58 +00001544 cbfs_unmap(dsdt_file);
Arthur Heymans0600aa62023-06-17 14:13:54 +02001545 return start;
Vladimir Serbinenko36f8d272015-05-31 12:31:59 +02001546 }
1547
Julius Werner834b3ec2020-03-04 16:52:08 -08001548 slic_file = cbfs_map(CONFIG_CBFS_PREFIX "/slic", &slic_size);
Vladimir Serbinenko2cb29782015-05-31 11:32:09 +02001549 if (slic_file
1550 && (slic_file->length > slic_size
Elyes HAOUAS7d87e762016-10-03 22:11:07 +02001551 || slic_file->length < sizeof(acpi_header_t)
Benjamin Doron2b2dc0c2020-09-12 02:55:57 +00001552 || (memcmp(slic_file->signature, "SLIC", 4) != 0
1553 && memcmp(slic_file->signature, "MSDM", 4) != 0))) {
Grzegorz Bernacki042ac352023-04-21 13:19:58 +00001554 cbfs_unmap(slic_file);
Vladimir Serbinenko351fefc2014-10-26 20:42:08 +01001555 slic_file = 0;
1556 }
1557
1558 if (slic_file) {
1559 memcpy(oem_id, slic_file->oem_id, 6);
1560 memcpy(oem_table_id, slic_file->oem_table_id, 8);
1561 } else {
1562 memcpy(oem_id, OEM_ID, 6);
1563 memcpy(oem_table_id, ACPI_TABLE_CREATOR, 8);
1564 }
1565
Vladimir Serbinenko2d7bd8a2014-08-30 19:28:05 +02001566 printk(BIOS_INFO, "ACPI: Writing ACPI tables at %lx.\n", start);
1567
Arthur Heymansd8f2dce2023-06-22 13:42:36 +02001568 /* We need at least an RSDP, RSDT for ACPI 1.0 compat, otherwise XSDT */
Elyes Haouas3141fbad2022-11-18 15:22:32 +01001569 rsdp = (acpi_rsdp_t *)current;
Arthur Heymans2e7e2d92022-03-03 22:28:27 +01001570 coreboot_rsdp = (uintptr_t)rsdp;
Vladimir Serbinenko2d7bd8a2014-08-30 19:28:05 +02001571 current += sizeof(acpi_rsdp_t);
Aaron Durbin07a1b282015-12-10 17:07:38 -06001572 current = acpi_align_current(current);
Arthur Heymansd8f2dce2023-06-22 13:42:36 +02001573 if (current + sizeof(acpi_rsdt_t) - 1 <= UINT32_MAX) {
1574 rsdt = (acpi_rsdt_t *)current;
1575 current += sizeof(acpi_rsdt_t);
1576 current = acpi_align_current(current);
1577 } else {
1578 printk(BIOS_INFO, "Not adding RSDT because tables reside above 4G.");
1579 }
1580
Elyes Haouas3141fbad2022-11-18 15:22:32 +01001581 xsdt = (acpi_xsdt_t *)current;
Vladimir Serbinenko2d7bd8a2014-08-30 19:28:05 +02001582 current += sizeof(acpi_xsdt_t);
Aaron Durbin07a1b282015-12-10 17:07:38 -06001583 current = acpi_align_current(current);
Vladimir Serbinenko2d7bd8a2014-08-30 19:28:05 +02001584
1585 /* clear all table memory */
Elyes Haouas3141fbad2022-11-18 15:22:32 +01001586 memset((void *)start, 0, current - start);
Vladimir Serbinenko2d7bd8a2014-08-30 19:28:05 +02001587
Vladimir Serbinenko351fefc2014-10-26 20:42:08 +01001588 acpi_write_rsdp(rsdp, rsdt, xsdt, oem_id);
1589 acpi_write_rsdt(rsdt, oem_id, oem_table_id);
1590 acpi_write_xsdt(xsdt, oem_id, oem_table_id);
Vladimir Serbinenko2d7bd8a2014-08-30 19:28:05 +02001591
Arthur Heymans6af72612023-06-29 20:25:32 +02001592 if (ENV_X86) {
1593 printk(BIOS_DEBUG, "ACPI: * FACS\n");
1594 current = ALIGN_UP(current, 64);
1595 facs = (acpi_facs_t *)current;
1596 current += sizeof(acpi_facs_t);
1597 current = acpi_align_current(current);
1598 acpi_create_facs(facs);
1599 }
Vladimir Serbinenko2d7bd8a2014-08-30 19:28:05 +02001600
Arthur Heymans01af0f82023-06-27 11:58:04 +02001601 for (size_t i = 0; i < ARRAY_SIZE(tables); i++) {
1602 acpi_header_t *header = (acpi_header_t *)current;
1603 memset(header, 0, tables[i].min_size);
1604 tables[i].create_table(header, tables[i].args);
1605 if (header->length < tables[i].min_size)
1606 continue;
1607 header->checksum = 0;
1608 header->checksum = acpi_checksum((void *)header, header->length);
1609 current += header->length;
Aaron Durbin07a1b282015-12-10 17:07:38 -06001610 current = acpi_align_current(current);
Kyösti Mälkki0bcdd402023-07-06 14:47:07 +03001611
1612 if (tables[i].create_table == acpi_create_dsdt)
1613 continue;
1614
Arthur Heymans01af0f82023-06-27 11:58:04 +02001615 printk(BIOS_DEBUG, "ACPI: * %.4s\n", header->signature);
1616 acpi_add_table(rsdp, header);
Vladimir Serbinenko351fefc2014-10-26 20:42:08 +01001617 }
Vladimir Serbinenko2d7bd8a2014-08-30 19:28:05 +02001618
Grzegorz Bernacki042ac352023-04-21 13:19:58 +00001619 /*
1620 * cbfs_unmap() uses mem_pool_free() which works correctly only
1621 * if freeing is done in reverse order than memory allocation.
1622 * This is why unmapping of dsdt_file must be done after
1623 * unmapping slic file.
1624 */
Arthur Heymans01af0f82023-06-27 11:58:04 +02001625 cbfs_unmap(slic_file);
Grzegorz Bernacki042ac352023-04-21 13:19:58 +00001626 cbfs_unmap(dsdt_file);
1627
Vladimir Serbinenko2d7bd8a2014-08-30 19:28:05 +02001628 printk(BIOS_DEBUG, "current = %lx\n", current);
1629
1630 for (dev = all_devices; dev; dev = dev->next) {
1631 if (dev->ops && dev->ops->write_acpi_tables) {
Lee Leahy6f80ccc2017-03-16 15:18:22 -07001632 current = dev->ops->write_acpi_tables(dev, current,
1633 rsdp);
Aaron Durbin07a1b282015-12-10 17:07:38 -06001634 current = acpi_align_current(current);
Vladimir Serbinenko2d7bd8a2014-08-30 19:28:05 +02001635 }
1636 }
1637
1638 printk(BIOS_INFO, "ACPI: done.\n");
Arthur Heymans0ad766c2023-06-07 10:45:59 +02001639
1640 if (CONFIG(DEBUG_ACPICA_COMPATIBLE)) {
1641 printk(BIOS_DEBUG, "Printing ACPI tables in ACPICA compatible format\n");
Arthur Heymans1cdeaea2023-07-06 16:24:50 +02001642 if (facs)
1643 acpidump_print(facs);
1644 acpidump_print(dsdt);
Arthur Heymans3e523b42023-06-15 17:04:16 +02001645 for (size_t i = 0; xsdt->entry[i] != 0; i++) {
1646 acpidump_print((void *)(uintptr_t)xsdt->entry[i]);
Arthur Heymans0ad766c2023-06-07 10:45:59 +02001647 }
1648 printk(BIOS_DEBUG, "Done printing ACPI tables in ACPICA compatible format\n");
1649 }
1650
Vladimir Serbinenko2d7bd8a2014-08-30 19:28:05 +02001651 return current;
1652}
Vladimir Serbinenko2d7bd8a2014-08-30 19:28:05 +02001653
Rudolf Marek33cafe52009-04-13 18:07:02 +00001654static acpi_rsdp_t *valid_rsdp(acpi_rsdp_t *rsdp)
1655{
1656 if (strncmp((char *)rsdp, RSDP_SIG, sizeof(RSDP_SIG) - 1) != 0)
1657 return NULL;
1658
Stefan Reinauerc02b4fc2010-03-22 11:42:32 +00001659 printk(BIOS_DEBUG, "Looking on %p for valid checksum\n", rsdp);
Rudolf Marek33cafe52009-04-13 18:07:02 +00001660
1661 if (acpi_checksum((void *)rsdp, 20) != 0)
1662 return NULL;
Stefan Reinauerc02b4fc2010-03-22 11:42:32 +00001663 printk(BIOS_DEBUG, "Checksum 1 passed\n");
Rudolf Marek33cafe52009-04-13 18:07:02 +00001664
1665 if ((rsdp->revision > 1) && (acpi_checksum((void *)rsdp,
1666 rsdp->length) != 0))
1667 return NULL;
Stefan Reinauerc02b4fc2010-03-22 11:42:32 +00001668 printk(BIOS_DEBUG, "Checksum 2 passed all OK\n");
Rudolf Marek33cafe52009-04-13 18:07:02 +00001669
1670 return rsdp;
1671}
1672
Rudolf Marek33cafe52009-04-13 18:07:02 +00001673void *acpi_find_wakeup_vector(void)
1674{
1675 char *p, *end;
Arthur Heymansd8f2dce2023-06-22 13:42:36 +02001676 acpi_xsdt_t *xsdt;
Rudolf Marek33cafe52009-04-13 18:07:02 +00001677 acpi_facs_t *facs;
Martin Rothc5f49262012-12-14 19:17:55 -07001678 acpi_fadt_t *fadt = NULL;
Kyösti Mälkki072d436b2016-06-17 08:44:40 +03001679 acpi_rsdp_t *rsdp = NULL;
Uwe Hermann622824c2010-11-19 15:14:42 +00001680 void *wake_vec;
Rudolf Marek33cafe52009-04-13 18:07:02 +00001681 int i;
1682
Kyösti Mälkkib8c7ea02020-11-17 16:41:38 +02001683 if (!acpi_is_wakeup_s3())
Rudolf Marek33cafe52009-04-13 18:07:02 +00001684 return NULL;
1685
Uwe Hermann622824c2010-11-19 15:14:42 +00001686 printk(BIOS_DEBUG, "Trying to find the wakeup vector...\n");
Rudolf Marek33cafe52009-04-13 18:07:02 +00001687
Uwe Hermann622824c2010-11-19 15:14:42 +00001688 /* Find RSDP. */
1689 for (p = (char *)0xe0000; p < (char *)0xfffff; p += 16) {
Lee Leahy0b5678f2017-03-16 16:01:40 -07001690 rsdp = valid_rsdp((acpi_rsdp_t *)p);
1691 if (rsdp)
Rudolf Marek33cafe52009-04-13 18:07:02 +00001692 break;
1693 }
1694
Angel Pons98a68ad2018-11-04 12:25:25 +01001695 if (rsdp == NULL) {
1696 printk(BIOS_ALERT,
1697 "No RSDP found, wake up from S3 not possible.\n");
Rudolf Marek33cafe52009-04-13 18:07:02 +00001698 return NULL;
Angel Pons98a68ad2018-11-04 12:25:25 +01001699 }
Rudolf Marek33cafe52009-04-13 18:07:02 +00001700
Stefan Reinauerc02b4fc2010-03-22 11:42:32 +00001701 printk(BIOS_DEBUG, "RSDP found at %p\n", rsdp);
Arthur Heymansd8f2dce2023-06-22 13:42:36 +02001702 xsdt = (acpi_xsdt_t *)(uintptr_t)rsdp->xsdt_address;
Stefan Reinauer14e22772010-04-27 06:56:47 +00001703
Arthur Heymansd8f2dce2023-06-22 13:42:36 +02001704 end = (char *)xsdt + xsdt->header.length;
1705 printk(BIOS_DEBUG, "XSDT found at %p ends at %p\n", xsdt, end);
Rudolf Marek33cafe52009-04-13 18:07:02 +00001706
Arthur Heymansd8f2dce2023-06-22 13:42:36 +02001707 for (i = 0; ((char *)&xsdt->entry[i]) < end; i++) {
1708 fadt = (acpi_fadt_t *)(uintptr_t)xsdt->entry[i];
Stefan Reinauercdfe3762009-07-21 22:15:43 +00001709 if (strncmp((char *)fadt, "FACP", 4) == 0)
Rudolf Marek33cafe52009-04-13 18:07:02 +00001710 break;
1711 fadt = NULL;
1712 }
1713
Angel Pons98a68ad2018-11-04 12:25:25 +01001714 if (fadt == NULL) {
1715 printk(BIOS_ALERT,
1716 "No FADT found, wake up from S3 not possible.\n");
Rudolf Marek33cafe52009-04-13 18:07:02 +00001717 return NULL;
Angel Pons98a68ad2018-11-04 12:25:25 +01001718 }
Rudolf Marek33cafe52009-04-13 18:07:02 +00001719
Stefan Reinauerc02b4fc2010-03-22 11:42:32 +00001720 printk(BIOS_DEBUG, "FADT found at %p\n", fadt);
Arthur Heymansa07b09a2023-07-05 12:53:10 +02001721 facs = (acpi_facs_t *)(uintptr_t)((uint64_t)fadt->x_firmware_ctl_l
1722 | (uint64_t)fadt->x_firmware_ctl_h << 32);
Rudolf Marek33cafe52009-04-13 18:07:02 +00001723
Stefan Reinauer7e9771c2009-04-22 08:17:38 +00001724 if (facs == NULL) {
Angel Pons98a68ad2018-11-04 12:25:25 +01001725 printk(BIOS_ALERT,
1726 "No FACS found, wake up from S3 not possible.\n");
Rudolf Marek33cafe52009-04-13 18:07:02 +00001727 return NULL;
Stefan Reinauer7e9771c2009-04-22 08:17:38 +00001728 }
Rudolf Marek33cafe52009-04-13 18:07:02 +00001729
Stefan Reinauerc02b4fc2010-03-22 11:42:32 +00001730 printk(BIOS_DEBUG, "FACS found at %p\n", facs);
Stefan Reinauer71a30182015-07-30 16:28:13 -07001731 wake_vec = (void *)(uintptr_t)facs->firmware_waking_vector;
Stefan Reinauerc02b4fc2010-03-22 11:42:32 +00001732 printk(BIOS_DEBUG, "OS waking vector is %p\n", wake_vec);
Uwe Hermann622824c2010-11-19 15:14:42 +00001733
Rudolf Marek33cafe52009-04-13 18:07:02 +00001734 return wake_vec;
1735}
1736
Aaron Durbin64031672018-04-21 14:45:32 -06001737__weak int acpi_get_gpe(int gpe)
Duncan Laurie1f6e6812016-09-19 12:04:19 -07001738{
1739 return -1; /* implemented by SOC */
1740}
Marc Jones93a51762018-08-22 18:57:24 -06001741
Elyes Haouas8b950f42022-02-16 12:08:16 +01001742u8 get_acpi_fadt_minor_version(void)
1743{
1744 return ACPI_FADT_MINOR_VERSION_0;
1745}
1746
Marc Jones93a51762018-08-22 18:57:24 -06001747int get_acpi_table_revision(enum acpi_tables table)
1748{
1749 switch (table) {
1750 case FADT:
Elyes Haouas8b950f42022-02-16 12:08:16 +01001751 return ACPI_FADT_REV_ACPI_6;
Elyes HAOUASf288b392018-11-11 15:22:30 +01001752 case MADT: /* ACPI 3.0: 2, ACPI 4.0/5.0: 3, ACPI 6.2b/6.3: 5 */
Patrick Rudolph56a3ef22020-03-24 17:29:49 +01001753 return 3;
Marc Jones93a51762018-08-22 18:57:24 -06001754 case MCFG:
1755 return 1;
1756 case TCPA:
1757 return 2;
Philipp Deppenwiese296164e02018-10-18 15:39:34 +02001758 case TPM2:
1759 return 4;
Martin Roth0949e732021-10-01 14:28:22 -06001760 case SSDT: /* ACPI 3.0 up to 6.3: 2 */
Marc Jones93a51762018-08-22 18:57:24 -06001761 return 2;
Jonathan Zhanga3311b92022-12-01 17:13:41 -08001762 case SRAT: /* ACPI 2.0: 1, ACPI 3.0: 2, ACPI 4.0 up to 6.4: 3 */
1763 return 3;
Jonathan Zhang2a4e1f42021-04-01 11:43:37 -07001764 case HMAT: /* ACPI 6.4: 2 */
1765 return 2;
Marc Jones93a51762018-08-22 18:57:24 -06001766 case DMAR:
1767 return 1;
Martin Roth0949e732021-10-01 14:28:22 -06001768 case SLIT: /* ACPI 2.0 up to 6.3: 1 */
Marc Jones93a51762018-08-22 18:57:24 -06001769 return 1;
Patrick Rudolph9d98e5a2019-06-14 19:00:04 +02001770 case SPMI: /* IMPI 2.0 */
1771 return 5;
Marc Jones93a51762018-08-22 18:57:24 -06001772 case HPET: /* Currently 1. Table added in ACPI 2.0. */
1773 return 1;
Elyes HAOUASf288b392018-11-11 15:22:30 +01001774 case VFCT: /* ACPI 2.0/3.0/4.0: 1 */
Marc Jones93a51762018-08-22 18:57:24 -06001775 return 1;
1776 case IVRS:
Jason Glenesk1916f892020-07-24 02:51:30 -07001777 return IVRS_FORMAT_MIXED;
Marc Jones93a51762018-08-22 18:57:24 -06001778 case DBG2:
1779 return 0;
Martin Roth0949e732021-10-01 14:28:22 -06001780 case FACS: /* ACPI 2.0/3.0: 1, ACPI 4.0 up to 6.3: 2 */
Marc Jones93a51762018-08-22 18:57:24 -06001781 return 1;
Martin Roth0949e732021-10-01 14:28:22 -06001782 case RSDT: /* ACPI 1.0 up to 6.3: 1 */
Marc Jones93a51762018-08-22 18:57:24 -06001783 return 1;
Martin Roth0949e732021-10-01 14:28:22 -06001784 case XSDT: /* ACPI 2.0 up to 6.3: 1 */
Marc Jones93a51762018-08-22 18:57:24 -06001785 return 1;
Martin Roth0949e732021-10-01 14:28:22 -06001786 case RSDP: /* ACPI 2.0 up to 6.3: 2 */
Marc Jones93a51762018-08-22 18:57:24 -06001787 return 2;
Rocky Phaguraeff07132021-01-10 15:42:50 -08001788 case EINJ:
1789 return 1;
Marc Jones93a51762018-08-22 18:57:24 -06001790 case HEST:
1791 return 1;
1792 case NHLT:
1793 return 5;
Marshall Dawson44705c62018-09-04 13:47:15 -06001794 case BERT:
1795 return 1;
Jonathan Zhanga3311b92022-12-01 17:13:41 -08001796 case CEDT: /* CXL 3.0 section 9.17.1 */
1797 return 1;
Jason Glenesk61624b22020-11-02 20:06:23 -08001798 case CRAT:
1799 return 1;
Michael Niewöhnerf0a44ae2021-01-01 21:04:09 +01001800 case LPIT: /* ACPI 5.1 up to 6.3: 0 */
1801 return 0;
Arthur Heymans90464072023-06-07 12:53:50 +02001802 case SPCR:
1803 return 4;
Arthur Heymans2e3cb632023-06-30 15:01:08 +02001804 case GTDT:
1805 return 3;
David Milosevicd9822742023-09-22 14:34:28 +02001806 case PPTT: /* ACPI 6.4 */
1807 return 3;
Naresh Solanki6920c6f2023-09-13 12:01:58 +02001808 case IORT: /* IO Remapping Table E.e */
1809 return 6;
Marek Maslanka017003c2023-12-07 13:21:35 +00001810 case WDAT:
1811 return 1;
Marc Jones93a51762018-08-22 18:57:24 -06001812 default:
1813 return -1;
1814 }
1815 return -1;
1816}