2018-05-07 06:58:06 +09:00
|
|
|
// SPDX-License-Identifier: GPL-2.0+
|
x86: Generate a valid ACPI table
Implement write_acpi_table() to create a minimal working ACPI table.
This includes writing FACS, XSDT, RSDP, FADT, MCFG, MADT, DSDT & SSDT
ACPI table entries.
Use a Kconfig option GENERATE_ACPI_TABLE to tell U-Boot whether we need
actually write the APCI table just like we did for PIRQ routing, MP table
and SFI tables. With ACPI table existence, linux kernel gets control of
power management, thermal management, configuration management and
monitoring in hardware.
Signed-off-by: Saket Sinha <saket.sinha89@gmail.com>
Reviewed-by: Bin Meng <bmeng.cn@gmail.com>
Tidied up whitespace and aligned some tabs:
Signed-off-by: Simon Glass <sjg@chromium.org>
2015-08-22 15:50:55 +09:00
|
|
|
/*
|
|
|
|
* Based on acpi.c from coreboot
|
|
|
|
*
|
|
|
|
* Copyright (C) 2015, Saket Sinha <saket.sinha89@gmail.com>
|
2016-05-07 23:46:25 +09:00
|
|
|
* Copyright (C) 2016, Bin Meng <bmeng.cn@gmail.com>
|
x86: Generate a valid ACPI table
Implement write_acpi_table() to create a minimal working ACPI table.
This includes writing FACS, XSDT, RSDP, FADT, MCFG, MADT, DSDT & SSDT
ACPI table entries.
Use a Kconfig option GENERATE_ACPI_TABLE to tell U-Boot whether we need
actually write the APCI table just like we did for PIRQ routing, MP table
and SFI tables. With ACPI table existence, linux kernel gets control of
power management, thermal management, configuration management and
monitoring in hardware.
Signed-off-by: Saket Sinha <saket.sinha89@gmail.com>
Reviewed-by: Bin Meng <bmeng.cn@gmail.com>
Tidied up whitespace and aligned some tabs:
Signed-off-by: Simon Glass <sjg@chromium.org>
2015-08-22 15:50:55 +09:00
|
|
|
*/
|
|
|
|
|
2020-09-23 03:45:34 +09:00
|
|
|
#define LOG_CATEGORY LOGC_ACPI
|
|
|
|
|
x86: Generate a valid ACPI table
Implement write_acpi_table() to create a minimal working ACPI table.
This includes writing FACS, XSDT, RSDP, FADT, MCFG, MADT, DSDT & SSDT
ACPI table entries.
Use a Kconfig option GENERATE_ACPI_TABLE to tell U-Boot whether we need
actually write the APCI table just like we did for PIRQ routing, MP table
and SFI tables. With ACPI table existence, linux kernel gets control of
power management, thermal management, configuration management and
monitoring in hardware.
Signed-off-by: Saket Sinha <saket.sinha89@gmail.com>
Reviewed-by: Bin Meng <bmeng.cn@gmail.com>
Tidied up whitespace and aligned some tabs:
Signed-off-by: Simon Glass <sjg@chromium.org>
2015-08-22 15:50:55 +09:00
|
|
|
#include <common.h>
|
2020-09-23 03:45:32 +09:00
|
|
|
#include <bloblist.h>
|
x86: Generate a valid ACPI table
Implement write_acpi_table() to create a minimal working ACPI table.
This includes writing FACS, XSDT, RSDP, FADT, MCFG, MADT, DSDT & SSDT
ACPI table entries.
Use a Kconfig option GENERATE_ACPI_TABLE to tell U-Boot whether we need
actually write the APCI table just like we did for PIRQ routing, MP table
and SFI tables. With ACPI table existence, linux kernel gets control of
power management, thermal management, configuration management and
monitoring in hardware.
Signed-off-by: Saket Sinha <saket.sinha89@gmail.com>
Reviewed-by: Bin Meng <bmeng.cn@gmail.com>
Tidied up whitespace and aligned some tabs:
Signed-off-by: Simon Glass <sjg@chromium.org>
2015-08-22 15:50:55 +09:00
|
|
|
#include <cpu.h>
|
|
|
|
#include <dm.h>
|
2020-05-11 02:40:05 +09:00
|
|
|
#include <log.h>
|
x86: Generate a valid ACPI table
Implement write_acpi_table() to create a minimal working ACPI table.
This includes writing FACS, XSDT, RSDP, FADT, MCFG, MADT, DSDT & SSDT
ACPI table entries.
Use a Kconfig option GENERATE_ACPI_TABLE to tell U-Boot whether we need
actually write the APCI table just like we did for PIRQ routing, MP table
and SFI tables. With ACPI table existence, linux kernel gets control of
power management, thermal management, configuration management and
monitoring in hardware.
Signed-off-by: Saket Sinha <saket.sinha89@gmail.com>
Reviewed-by: Bin Meng <bmeng.cn@gmail.com>
Tidied up whitespace and aligned some tabs:
Signed-off-by: Simon Glass <sjg@chromium.org>
2015-08-22 15:50:55 +09:00
|
|
|
#include <dm/uclass-internal.h>
|
2020-04-27 00:19:47 +09:00
|
|
|
#include <mapmem.h>
|
2018-11-21 06:52:38 +09:00
|
|
|
#include <serial.h>
|
2017-07-22 04:32:02 +09:00
|
|
|
#include <version.h>
|
2020-07-08 04:12:07 +09:00
|
|
|
#include <acpi/acpigen.h>
|
2020-09-23 03:45:10 +09:00
|
|
|
#include <acpi/acpi_device.h>
|
2020-04-09 07:57:36 +09:00
|
|
|
#include <acpi/acpi_table.h>
|
2016-06-17 18:13:16 +09:00
|
|
|
#include <asm/acpi/global_nvs.h>
|
2017-07-22 04:32:04 +09:00
|
|
|
#include <asm/ioapic.h>
|
x86: Generate a valid ACPI table
Implement write_acpi_table() to create a minimal working ACPI table.
This includes writing FACS, XSDT, RSDP, FADT, MCFG, MADT, DSDT & SSDT
ACPI table entries.
Use a Kconfig option GENERATE_ACPI_TABLE to tell U-Boot whether we need
actually write the APCI table just like we did for PIRQ routing, MP table
and SFI tables. With ACPI table existence, linux kernel gets control of
power management, thermal management, configuration management and
monitoring in hardware.
Signed-off-by: Saket Sinha <saket.sinha89@gmail.com>
Reviewed-by: Bin Meng <bmeng.cn@gmail.com>
Tidied up whitespace and aligned some tabs:
Signed-off-by: Simon Glass <sjg@chromium.org>
2015-08-22 15:50:55 +09:00
|
|
|
#include <asm/lapic.h>
|
2017-07-22 04:32:04 +09:00
|
|
|
#include <asm/mpspec.h>
|
x86: Generate a valid ACPI table
Implement write_acpi_table() to create a minimal working ACPI table.
This includes writing FACS, XSDT, RSDP, FADT, MCFG, MADT, DSDT & SSDT
ACPI table entries.
Use a Kconfig option GENERATE_ACPI_TABLE to tell U-Boot whether we need
actually write the APCI table just like we did for PIRQ routing, MP table
and SFI tables. With ACPI table existence, linux kernel gets control of
power management, thermal management, configuration management and
monitoring in hardware.
Signed-off-by: Saket Sinha <saket.sinha89@gmail.com>
Reviewed-by: Bin Meng <bmeng.cn@gmail.com>
Tidied up whitespace and aligned some tabs:
Signed-off-by: Simon Glass <sjg@chromium.org>
2015-08-22 15:50:55 +09:00
|
|
|
#include <asm/tables.h>
|
2016-06-17 18:13:16 +09:00
|
|
|
#include <asm/arch/global_nvs.h>
|
2020-04-27 00:19:47 +09:00
|
|
|
#include <dm/acpi.h>
|
2020-07-08 12:32:05 +09:00
|
|
|
#include <linux/err.h>
|
x86: Generate a valid ACPI table
Implement write_acpi_table() to create a minimal working ACPI table.
This includes writing FACS, XSDT, RSDP, FADT, MCFG, MADT, DSDT & SSDT
ACPI table entries.
Use a Kconfig option GENERATE_ACPI_TABLE to tell U-Boot whether we need
actually write the APCI table just like we did for PIRQ routing, MP table
and SFI tables. With ACPI table existence, linux kernel gets control of
power management, thermal management, configuration management and
monitoring in hardware.
Signed-off-by: Saket Sinha <saket.sinha89@gmail.com>
Reviewed-by: Bin Meng <bmeng.cn@gmail.com>
Tidied up whitespace and aligned some tabs:
Signed-off-by: Simon Glass <sjg@chromium.org>
2015-08-22 15:50:55 +09:00
|
|
|
|
|
|
|
/*
|
2016-05-07 23:46:24 +09:00
|
|
|
* IASL compiles the dsdt entries and writes the hex values
|
|
|
|
* to a C array AmlCode[] (see dsdt.c).
|
x86: Generate a valid ACPI table
Implement write_acpi_table() to create a minimal working ACPI table.
This includes writing FACS, XSDT, RSDP, FADT, MCFG, MADT, DSDT & SSDT
ACPI table entries.
Use a Kconfig option GENERATE_ACPI_TABLE to tell U-Boot whether we need
actually write the APCI table just like we did for PIRQ routing, MP table
and SFI tables. With ACPI table existence, linux kernel gets control of
power management, thermal management, configuration management and
monitoring in hardware.
Signed-off-by: Saket Sinha <saket.sinha89@gmail.com>
Reviewed-by: Bin Meng <bmeng.cn@gmail.com>
Tidied up whitespace and aligned some tabs:
Signed-off-by: Simon Glass <sjg@chromium.org>
2015-08-22 15:50:55 +09:00
|
|
|
*/
|
|
|
|
extern const unsigned char AmlCode[];
|
|
|
|
|
2018-01-11 02:40:15 +09:00
|
|
|
/* ACPI RSDP address to be used in boot parameters */
|
2018-01-30 22:01:16 +09:00
|
|
|
static ulong acpi_rsdp_addr;
|
2018-01-11 02:40:15 +09:00
|
|
|
|
2016-05-07 23:46:25 +09:00
|
|
|
static void acpi_create_facs(struct acpi_facs *facs)
|
|
|
|
{
|
|
|
|
memset((void *)facs, 0, sizeof(struct acpi_facs));
|
|
|
|
|
|
|
|
memcpy(facs->signature, "FACS", 4);
|
|
|
|
facs->length = sizeof(struct acpi_facs);
|
|
|
|
facs->hardware_signature = 0;
|
|
|
|
facs->firmware_waking_vector = 0;
|
|
|
|
facs->global_lock = 0;
|
|
|
|
facs->flags = 0;
|
|
|
|
facs->x_firmware_waking_vector_l = 0;
|
|
|
|
facs->x_firmware_waking_vector_h = 0;
|
|
|
|
facs->version = 1;
|
|
|
|
}
|
|
|
|
|
x86: Generate a valid ACPI table
Implement write_acpi_table() to create a minimal working ACPI table.
This includes writing FACS, XSDT, RSDP, FADT, MCFG, MADT, DSDT & SSDT
ACPI table entries.
Use a Kconfig option GENERATE_ACPI_TABLE to tell U-Boot whether we need
actually write the APCI table just like we did for PIRQ routing, MP table
and SFI tables. With ACPI table existence, linux kernel gets control of
power management, thermal management, configuration management and
monitoring in hardware.
Signed-off-by: Saket Sinha <saket.sinha89@gmail.com>
Reviewed-by: Bin Meng <bmeng.cn@gmail.com>
Tidied up whitespace and aligned some tabs:
Signed-off-by: Simon Glass <sjg@chromium.org>
2015-08-22 15:50:55 +09:00
|
|
|
static int acpi_create_madt_lapic(struct acpi_madt_lapic *lapic,
|
2016-05-07 23:46:25 +09:00
|
|
|
u8 cpu, u8 apic)
|
x86: Generate a valid ACPI table
Implement write_acpi_table() to create a minimal working ACPI table.
This includes writing FACS, XSDT, RSDP, FADT, MCFG, MADT, DSDT & SSDT
ACPI table entries.
Use a Kconfig option GENERATE_ACPI_TABLE to tell U-Boot whether we need
actually write the APCI table just like we did for PIRQ routing, MP table
and SFI tables. With ACPI table existence, linux kernel gets control of
power management, thermal management, configuration management and
monitoring in hardware.
Signed-off-by: Saket Sinha <saket.sinha89@gmail.com>
Reviewed-by: Bin Meng <bmeng.cn@gmail.com>
Tidied up whitespace and aligned some tabs:
Signed-off-by: Simon Glass <sjg@chromium.org>
2015-08-22 15:50:55 +09:00
|
|
|
{
|
2016-05-07 23:46:25 +09:00
|
|
|
lapic->type = ACPI_APIC_LAPIC;
|
x86: Generate a valid ACPI table
Implement write_acpi_table() to create a minimal working ACPI table.
This includes writing FACS, XSDT, RSDP, FADT, MCFG, MADT, DSDT & SSDT
ACPI table entries.
Use a Kconfig option GENERATE_ACPI_TABLE to tell U-Boot whether we need
actually write the APCI table just like we did for PIRQ routing, MP table
and SFI tables. With ACPI table existence, linux kernel gets control of
power management, thermal management, configuration management and
monitoring in hardware.
Signed-off-by: Saket Sinha <saket.sinha89@gmail.com>
Reviewed-by: Bin Meng <bmeng.cn@gmail.com>
Tidied up whitespace and aligned some tabs:
Signed-off-by: Simon Glass <sjg@chromium.org>
2015-08-22 15:50:55 +09:00
|
|
|
lapic->length = sizeof(struct acpi_madt_lapic);
|
2016-05-07 23:46:25 +09:00
|
|
|
lapic->flags = LOCAL_APIC_FLAG_ENABLED;
|
x86: Generate a valid ACPI table
Implement write_acpi_table() to create a minimal working ACPI table.
This includes writing FACS, XSDT, RSDP, FADT, MCFG, MADT, DSDT & SSDT
ACPI table entries.
Use a Kconfig option GENERATE_ACPI_TABLE to tell U-Boot whether we need
actually write the APCI table just like we did for PIRQ routing, MP table
and SFI tables. With ACPI table existence, linux kernel gets control of
power management, thermal management, configuration management and
monitoring in hardware.
Signed-off-by: Saket Sinha <saket.sinha89@gmail.com>
Reviewed-by: Bin Meng <bmeng.cn@gmail.com>
Tidied up whitespace and aligned some tabs:
Signed-off-by: Simon Glass <sjg@chromium.org>
2015-08-22 15:50:55 +09:00
|
|
|
lapic->processor_id = cpu;
|
|
|
|
lapic->apic_id = apic;
|
|
|
|
|
|
|
|
return lapic->length;
|
|
|
|
}
|
|
|
|
|
2016-05-07 23:46:30 +09:00
|
|
|
int acpi_create_madt_lapics(u32 current)
|
x86: Generate a valid ACPI table
Implement write_acpi_table() to create a minimal working ACPI table.
This includes writing FACS, XSDT, RSDP, FADT, MCFG, MADT, DSDT & SSDT
ACPI table entries.
Use a Kconfig option GENERATE_ACPI_TABLE to tell U-Boot whether we need
actually write the APCI table just like we did for PIRQ routing, MP table
and SFI tables. With ACPI table existence, linux kernel gets control of
power management, thermal management, configuration management and
monitoring in hardware.
Signed-off-by: Saket Sinha <saket.sinha89@gmail.com>
Reviewed-by: Bin Meng <bmeng.cn@gmail.com>
Tidied up whitespace and aligned some tabs:
Signed-off-by: Simon Glass <sjg@chromium.org>
2015-08-22 15:50:55 +09:00
|
|
|
{
|
|
|
|
struct udevice *dev;
|
2016-06-08 03:40:18 +09:00
|
|
|
int total_length = 0;
|
2020-09-23 03:45:31 +09:00
|
|
|
int cpu_num = 0;
|
x86: Generate a valid ACPI table
Implement write_acpi_table() to create a minimal working ACPI table.
This includes writing FACS, XSDT, RSDP, FADT, MCFG, MADT, DSDT & SSDT
ACPI table entries.
Use a Kconfig option GENERATE_ACPI_TABLE to tell U-Boot whether we need
actually write the APCI table just like we did for PIRQ routing, MP table
and SFI tables. With ACPI table existence, linux kernel gets control of
power management, thermal management, configuration management and
monitoring in hardware.
Signed-off-by: Saket Sinha <saket.sinha89@gmail.com>
Reviewed-by: Bin Meng <bmeng.cn@gmail.com>
Tidied up whitespace and aligned some tabs:
Signed-off-by: Simon Glass <sjg@chromium.org>
2015-08-22 15:50:55 +09:00
|
|
|
|
|
|
|
for (uclass_find_first_device(UCLASS_CPU, &dev);
|
|
|
|
dev;
|
|
|
|
uclass_find_next_device(&dev)) {
|
|
|
|
struct cpu_platdata *plat = dev_get_parent_platdata(dev);
|
2020-09-23 03:45:31 +09:00
|
|
|
int length;
|
|
|
|
|
|
|
|
length = acpi_create_madt_lapic(
|
|
|
|
(struct acpi_madt_lapic *)current, cpu_num++,
|
|
|
|
plat->cpu_id);
|
2016-05-07 23:46:30 +09:00
|
|
|
current += length;
|
2016-06-08 03:40:18 +09:00
|
|
|
total_length += length;
|
2016-05-07 23:46:25 +09:00
|
|
|
}
|
|
|
|
|
2016-06-08 03:40:18 +09:00
|
|
|
return total_length;
|
x86: Generate a valid ACPI table
Implement write_acpi_table() to create a minimal working ACPI table.
This includes writing FACS, XSDT, RSDP, FADT, MCFG, MADT, DSDT & SSDT
ACPI table entries.
Use a Kconfig option GENERATE_ACPI_TABLE to tell U-Boot whether we need
actually write the APCI table just like we did for PIRQ routing, MP table
and SFI tables. With ACPI table existence, linux kernel gets control of
power management, thermal management, configuration management and
monitoring in hardware.
Signed-off-by: Saket Sinha <saket.sinha89@gmail.com>
Reviewed-by: Bin Meng <bmeng.cn@gmail.com>
Tidied up whitespace and aligned some tabs:
Signed-off-by: Simon Glass <sjg@chromium.org>
2015-08-22 15:50:55 +09:00
|
|
|
}
|
|
|
|
|
2016-05-07 23:46:25 +09:00
|
|
|
int acpi_create_madt_ioapic(struct acpi_madt_ioapic *ioapic, u8 id,
|
|
|
|
u32 addr, u32 gsi_base)
|
x86: Generate a valid ACPI table
Implement write_acpi_table() to create a minimal working ACPI table.
This includes writing FACS, XSDT, RSDP, FADT, MCFG, MADT, DSDT & SSDT
ACPI table entries.
Use a Kconfig option GENERATE_ACPI_TABLE to tell U-Boot whether we need
actually write the APCI table just like we did for PIRQ routing, MP table
and SFI tables. With ACPI table existence, linux kernel gets control of
power management, thermal management, configuration management and
monitoring in hardware.
Signed-off-by: Saket Sinha <saket.sinha89@gmail.com>
Reviewed-by: Bin Meng <bmeng.cn@gmail.com>
Tidied up whitespace and aligned some tabs:
Signed-off-by: Simon Glass <sjg@chromium.org>
2015-08-22 15:50:55 +09:00
|
|
|
{
|
2016-05-07 23:46:21 +09:00
|
|
|
ioapic->type = ACPI_APIC_IOAPIC;
|
x86: Generate a valid ACPI table
Implement write_acpi_table() to create a minimal working ACPI table.
This includes writing FACS, XSDT, RSDP, FADT, MCFG, MADT, DSDT & SSDT
ACPI table entries.
Use a Kconfig option GENERATE_ACPI_TABLE to tell U-Boot whether we need
actually write the APCI table just like we did for PIRQ routing, MP table
and SFI tables. With ACPI table existence, linux kernel gets control of
power management, thermal management, configuration management and
monitoring in hardware.
Signed-off-by: Saket Sinha <saket.sinha89@gmail.com>
Reviewed-by: Bin Meng <bmeng.cn@gmail.com>
Tidied up whitespace and aligned some tabs:
Signed-off-by: Simon Glass <sjg@chromium.org>
2015-08-22 15:50:55 +09:00
|
|
|
ioapic->length = sizeof(struct acpi_madt_ioapic);
|
|
|
|
ioapic->reserved = 0x00;
|
|
|
|
ioapic->gsi_base = gsi_base;
|
|
|
|
ioapic->ioapic_id = id;
|
|
|
|
ioapic->ioapic_addr = addr;
|
|
|
|
|
|
|
|
return ioapic->length;
|
|
|
|
}
|
|
|
|
|
|
|
|
int acpi_create_madt_irqoverride(struct acpi_madt_irqoverride *irqoverride,
|
2016-05-07 23:46:25 +09:00
|
|
|
u8 bus, u8 source, u32 gsirq, u16 flags)
|
x86: Generate a valid ACPI table
Implement write_acpi_table() to create a minimal working ACPI table.
This includes writing FACS, XSDT, RSDP, FADT, MCFG, MADT, DSDT & SSDT
ACPI table entries.
Use a Kconfig option GENERATE_ACPI_TABLE to tell U-Boot whether we need
actually write the APCI table just like we did for PIRQ routing, MP table
and SFI tables. With ACPI table existence, linux kernel gets control of
power management, thermal management, configuration management and
monitoring in hardware.
Signed-off-by: Saket Sinha <saket.sinha89@gmail.com>
Reviewed-by: Bin Meng <bmeng.cn@gmail.com>
Tidied up whitespace and aligned some tabs:
Signed-off-by: Simon Glass <sjg@chromium.org>
2015-08-22 15:50:55 +09:00
|
|
|
{
|
2016-05-07 23:46:21 +09:00
|
|
|
irqoverride->type = ACPI_APIC_IRQ_SRC_OVERRIDE;
|
x86: Generate a valid ACPI table
Implement write_acpi_table() to create a minimal working ACPI table.
This includes writing FACS, XSDT, RSDP, FADT, MCFG, MADT, DSDT & SSDT
ACPI table entries.
Use a Kconfig option GENERATE_ACPI_TABLE to tell U-Boot whether we need
actually write the APCI table just like we did for PIRQ routing, MP table
and SFI tables. With ACPI table existence, linux kernel gets control of
power management, thermal management, configuration management and
monitoring in hardware.
Signed-off-by: Saket Sinha <saket.sinha89@gmail.com>
Reviewed-by: Bin Meng <bmeng.cn@gmail.com>
Tidied up whitespace and aligned some tabs:
Signed-off-by: Simon Glass <sjg@chromium.org>
2015-08-22 15:50:55 +09:00
|
|
|
irqoverride->length = sizeof(struct acpi_madt_irqoverride);
|
|
|
|
irqoverride->bus = bus;
|
|
|
|
irqoverride->source = source;
|
|
|
|
irqoverride->gsirq = gsirq;
|
|
|
|
irqoverride->flags = flags;
|
|
|
|
|
|
|
|
return irqoverride->length;
|
|
|
|
}
|
|
|
|
|
|
|
|
int acpi_create_madt_lapic_nmi(struct acpi_madt_lapic_nmi *lapic_nmi,
|
2016-05-07 23:46:25 +09:00
|
|
|
u8 cpu, u16 flags, u8 lint)
|
x86: Generate a valid ACPI table
Implement write_acpi_table() to create a minimal working ACPI table.
This includes writing FACS, XSDT, RSDP, FADT, MCFG, MADT, DSDT & SSDT
ACPI table entries.
Use a Kconfig option GENERATE_ACPI_TABLE to tell U-Boot whether we need
actually write the APCI table just like we did for PIRQ routing, MP table
and SFI tables. With ACPI table existence, linux kernel gets control of
power management, thermal management, configuration management and
monitoring in hardware.
Signed-off-by: Saket Sinha <saket.sinha89@gmail.com>
Reviewed-by: Bin Meng <bmeng.cn@gmail.com>
Tidied up whitespace and aligned some tabs:
Signed-off-by: Simon Glass <sjg@chromium.org>
2015-08-22 15:50:55 +09:00
|
|
|
{
|
2016-05-07 23:46:21 +09:00
|
|
|
lapic_nmi->type = ACPI_APIC_LAPIC_NMI;
|
x86: Generate a valid ACPI table
Implement write_acpi_table() to create a minimal working ACPI table.
This includes writing FACS, XSDT, RSDP, FADT, MCFG, MADT, DSDT & SSDT
ACPI table entries.
Use a Kconfig option GENERATE_ACPI_TABLE to tell U-Boot whether we need
actually write the APCI table just like we did for PIRQ routing, MP table
and SFI tables. With ACPI table existence, linux kernel gets control of
power management, thermal management, configuration management and
monitoring in hardware.
Signed-off-by: Saket Sinha <saket.sinha89@gmail.com>
Reviewed-by: Bin Meng <bmeng.cn@gmail.com>
Tidied up whitespace and aligned some tabs:
Signed-off-by: Simon Glass <sjg@chromium.org>
2015-08-22 15:50:55 +09:00
|
|
|
lapic_nmi->length = sizeof(struct acpi_madt_lapic_nmi);
|
|
|
|
lapic_nmi->flags = flags;
|
|
|
|
lapic_nmi->processor_id = cpu;
|
|
|
|
lapic_nmi->lint = lint;
|
|
|
|
|
|
|
|
return lapic_nmi->length;
|
|
|
|
}
|
|
|
|
|
2017-07-22 04:32:04 +09:00
|
|
|
static int acpi_create_madt_irq_overrides(u32 current)
|
|
|
|
{
|
|
|
|
struct acpi_madt_irqoverride *irqovr;
|
|
|
|
u16 sci_flags = MP_IRQ_TRIGGER_LEVEL | MP_IRQ_POLARITY_HIGH;
|
|
|
|
int length = 0;
|
|
|
|
|
|
|
|
irqovr = (void *)current;
|
|
|
|
length += acpi_create_madt_irqoverride(irqovr, 0, 0, 2, 0);
|
|
|
|
|
|
|
|
irqovr = (void *)(current + length);
|
|
|
|
length += acpi_create_madt_irqoverride(irqovr, 0, 9, 9, sci_flags);
|
|
|
|
|
|
|
|
return length;
|
|
|
|
}
|
|
|
|
|
|
|
|
__weak u32 acpi_fill_madt(u32 current)
|
|
|
|
{
|
|
|
|
current += acpi_create_madt_lapics(current);
|
|
|
|
|
|
|
|
current += acpi_create_madt_ioapic((struct acpi_madt_ioapic *)current,
|
|
|
|
io_apic_read(IO_APIC_ID) >> 24, IO_APIC_ADDR, 0);
|
|
|
|
|
|
|
|
current += acpi_create_madt_irq_overrides(current);
|
|
|
|
|
|
|
|
return current;
|
|
|
|
}
|
|
|
|
|
x86: Generate a valid ACPI table
Implement write_acpi_table() to create a minimal working ACPI table.
This includes writing FACS, XSDT, RSDP, FADT, MCFG, MADT, DSDT & SSDT
ACPI table entries.
Use a Kconfig option GENERATE_ACPI_TABLE to tell U-Boot whether we need
actually write the APCI table just like we did for PIRQ routing, MP table
and SFI tables. With ACPI table existence, linux kernel gets control of
power management, thermal management, configuration management and
monitoring in hardware.
Signed-off-by: Saket Sinha <saket.sinha89@gmail.com>
Reviewed-by: Bin Meng <bmeng.cn@gmail.com>
Tidied up whitespace and aligned some tabs:
Signed-off-by: Simon Glass <sjg@chromium.org>
2015-08-22 15:50:55 +09:00
|
|
|
static void acpi_create_madt(struct acpi_madt *madt)
|
|
|
|
{
|
2016-05-07 23:46:21 +09:00
|
|
|
struct acpi_table_header *header = &(madt->header);
|
2016-05-07 23:46:26 +09:00
|
|
|
u32 current = (u32)madt + sizeof(struct acpi_madt);
|
x86: Generate a valid ACPI table
Implement write_acpi_table() to create a minimal working ACPI table.
This includes writing FACS, XSDT, RSDP, FADT, MCFG, MADT, DSDT & SSDT
ACPI table entries.
Use a Kconfig option GENERATE_ACPI_TABLE to tell U-Boot whether we need
actually write the APCI table just like we did for PIRQ routing, MP table
and SFI tables. With ACPI table existence, linux kernel gets control of
power management, thermal management, configuration management and
monitoring in hardware.
Signed-off-by: Saket Sinha <saket.sinha89@gmail.com>
Reviewed-by: Bin Meng <bmeng.cn@gmail.com>
Tidied up whitespace and aligned some tabs:
Signed-off-by: Simon Glass <sjg@chromium.org>
2015-08-22 15:50:55 +09:00
|
|
|
|
|
|
|
memset((void *)madt, 0, sizeof(struct acpi_madt));
|
|
|
|
|
|
|
|
/* Fill out header fields */
|
2016-05-07 23:46:24 +09:00
|
|
|
acpi_fill_header(header, "APIC");
|
x86: Generate a valid ACPI table
Implement write_acpi_table() to create a minimal working ACPI table.
This includes writing FACS, XSDT, RSDP, FADT, MCFG, MADT, DSDT & SSDT
ACPI table entries.
Use a Kconfig option GENERATE_ACPI_TABLE to tell U-Boot whether we need
actually write the APCI table just like we did for PIRQ routing, MP table
and SFI tables. With ACPI table existence, linux kernel gets control of
power management, thermal management, configuration management and
monitoring in hardware.
Signed-off-by: Saket Sinha <saket.sinha89@gmail.com>
Reviewed-by: Bin Meng <bmeng.cn@gmail.com>
Tidied up whitespace and aligned some tabs:
Signed-off-by: Simon Glass <sjg@chromium.org>
2015-08-22 15:50:55 +09:00
|
|
|
header->length = sizeof(struct acpi_madt);
|
2020-07-17 12:22:37 +09:00
|
|
|
header->revision = ACPI_MADT_REV_ACPI_3_0;
|
x86: Generate a valid ACPI table
Implement write_acpi_table() to create a minimal working ACPI table.
This includes writing FACS, XSDT, RSDP, FADT, MCFG, MADT, DSDT & SSDT
ACPI table entries.
Use a Kconfig option GENERATE_ACPI_TABLE to tell U-Boot whether we need
actually write the APCI table just like we did for PIRQ routing, MP table
and SFI tables. With ACPI table existence, linux kernel gets control of
power management, thermal management, configuration management and
monitoring in hardware.
Signed-off-by: Saket Sinha <saket.sinha89@gmail.com>
Reviewed-by: Bin Meng <bmeng.cn@gmail.com>
Tidied up whitespace and aligned some tabs:
Signed-off-by: Simon Glass <sjg@chromium.org>
2015-08-22 15:50:55 +09:00
|
|
|
|
|
|
|
madt->lapic_addr = LAPIC_DEFAULT_BASE;
|
2016-05-07 23:46:21 +09:00
|
|
|
madt->flags = ACPI_MADT_PCAT_COMPAT;
|
x86: Generate a valid ACPI table
Implement write_acpi_table() to create a minimal working ACPI table.
This includes writing FACS, XSDT, RSDP, FADT, MCFG, MADT, DSDT & SSDT
ACPI table entries.
Use a Kconfig option GENERATE_ACPI_TABLE to tell U-Boot whether we need
actually write the APCI table just like we did for PIRQ routing, MP table
and SFI tables. With ACPI table existence, linux kernel gets control of
power management, thermal management, configuration management and
monitoring in hardware.
Signed-off-by: Saket Sinha <saket.sinha89@gmail.com>
Reviewed-by: Bin Meng <bmeng.cn@gmail.com>
Tidied up whitespace and aligned some tabs:
Signed-off-by: Simon Glass <sjg@chromium.org>
2015-08-22 15:50:55 +09:00
|
|
|
|
|
|
|
current = acpi_fill_madt(current);
|
|
|
|
|
|
|
|
/* (Re)calculate length and checksum */
|
2016-05-07 23:46:26 +09:00
|
|
|
header->length = current - (u32)madt;
|
x86: Generate a valid ACPI table
Implement write_acpi_table() to create a minimal working ACPI table.
This includes writing FACS, XSDT, RSDP, FADT, MCFG, MADT, DSDT & SSDT
ACPI table entries.
Use a Kconfig option GENERATE_ACPI_TABLE to tell U-Boot whether we need
actually write the APCI table just like we did for PIRQ routing, MP table
and SFI tables. With ACPI table existence, linux kernel gets control of
power management, thermal management, configuration management and
monitoring in hardware.
Signed-off-by: Saket Sinha <saket.sinha89@gmail.com>
Reviewed-by: Bin Meng <bmeng.cn@gmail.com>
Tidied up whitespace and aligned some tabs:
Signed-off-by: Simon Glass <sjg@chromium.org>
2015-08-22 15:50:55 +09:00
|
|
|
|
|
|
|
header->checksum = table_compute_checksum((void *)madt, header->length);
|
|
|
|
}
|
|
|
|
|
2017-07-22 04:32:05 +09:00
|
|
|
int acpi_create_mcfg_mmconfig(struct acpi_mcfg_mmconfig *mmconfig, u32 base,
|
|
|
|
u16 seg_nr, u8 start, u8 end)
|
x86: Generate a valid ACPI table
Implement write_acpi_table() to create a minimal working ACPI table.
This includes writing FACS, XSDT, RSDP, FADT, MCFG, MADT, DSDT & SSDT
ACPI table entries.
Use a Kconfig option GENERATE_ACPI_TABLE to tell U-Boot whether we need
actually write the APCI table just like we did for PIRQ routing, MP table
and SFI tables. With ACPI table existence, linux kernel gets control of
power management, thermal management, configuration management and
monitoring in hardware.
Signed-off-by: Saket Sinha <saket.sinha89@gmail.com>
Reviewed-by: Bin Meng <bmeng.cn@gmail.com>
Tidied up whitespace and aligned some tabs:
Signed-off-by: Simon Glass <sjg@chromium.org>
2015-08-22 15:50:55 +09:00
|
|
|
{
|
|
|
|
memset(mmconfig, 0, sizeof(*mmconfig));
|
2016-05-07 23:46:21 +09:00
|
|
|
mmconfig->base_address_l = base;
|
|
|
|
mmconfig->base_address_h = 0;
|
x86: Generate a valid ACPI table
Implement write_acpi_table() to create a minimal working ACPI table.
This includes writing FACS, XSDT, RSDP, FADT, MCFG, MADT, DSDT & SSDT
ACPI table entries.
Use a Kconfig option GENERATE_ACPI_TABLE to tell U-Boot whether we need
actually write the APCI table just like we did for PIRQ routing, MP table
and SFI tables. With ACPI table existence, linux kernel gets control of
power management, thermal management, configuration management and
monitoring in hardware.
Signed-off-by: Saket Sinha <saket.sinha89@gmail.com>
Reviewed-by: Bin Meng <bmeng.cn@gmail.com>
Tidied up whitespace and aligned some tabs:
Signed-off-by: Simon Glass <sjg@chromium.org>
2015-08-22 15:50:55 +09:00
|
|
|
mmconfig->pci_segment_group_number = seg_nr;
|
|
|
|
mmconfig->start_bus_number = start;
|
|
|
|
mmconfig->end_bus_number = end;
|
|
|
|
|
|
|
|
return sizeof(struct acpi_mcfg_mmconfig);
|
|
|
|
}
|
|
|
|
|
2017-07-22 04:32:05 +09:00
|
|
|
__weak u32 acpi_fill_mcfg(u32 current)
|
x86: Generate a valid ACPI table
Implement write_acpi_table() to create a minimal working ACPI table.
This includes writing FACS, XSDT, RSDP, FADT, MCFG, MADT, DSDT & SSDT
ACPI table entries.
Use a Kconfig option GENERATE_ACPI_TABLE to tell U-Boot whether we need
actually write the APCI table just like we did for PIRQ routing, MP table
and SFI tables. With ACPI table existence, linux kernel gets control of
power management, thermal management, configuration management and
monitoring in hardware.
Signed-off-by: Saket Sinha <saket.sinha89@gmail.com>
Reviewed-by: Bin Meng <bmeng.cn@gmail.com>
Tidied up whitespace and aligned some tabs:
Signed-off-by: Simon Glass <sjg@chromium.org>
2015-08-22 15:50:55 +09:00
|
|
|
{
|
|
|
|
current += acpi_create_mcfg_mmconfig
|
|
|
|
((struct acpi_mcfg_mmconfig *)current,
|
2016-05-07 23:46:25 +09:00
|
|
|
CONFIG_PCIE_ECAM_BASE, 0x0, 0x0, 255);
|
x86: Generate a valid ACPI table
Implement write_acpi_table() to create a minimal working ACPI table.
This includes writing FACS, XSDT, RSDP, FADT, MCFG, MADT, DSDT & SSDT
ACPI table entries.
Use a Kconfig option GENERATE_ACPI_TABLE to tell U-Boot whether we need
actually write the APCI table just like we did for PIRQ routing, MP table
and SFI tables. With ACPI table existence, linux kernel gets control of
power management, thermal management, configuration management and
monitoring in hardware.
Signed-off-by: Saket Sinha <saket.sinha89@gmail.com>
Reviewed-by: Bin Meng <bmeng.cn@gmail.com>
Tidied up whitespace and aligned some tabs:
Signed-off-by: Simon Glass <sjg@chromium.org>
2015-08-22 15:50:55 +09:00
|
|
|
|
|
|
|
return current;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* MCFG is defined in the PCI Firmware Specification 3.0 */
|
|
|
|
static void acpi_create_mcfg(struct acpi_mcfg *mcfg)
|
|
|
|
{
|
2016-05-07 23:46:21 +09:00
|
|
|
struct acpi_table_header *header = &(mcfg->header);
|
2016-05-07 23:46:26 +09:00
|
|
|
u32 current = (u32)mcfg + sizeof(struct acpi_mcfg);
|
x86: Generate a valid ACPI table
Implement write_acpi_table() to create a minimal working ACPI table.
This includes writing FACS, XSDT, RSDP, FADT, MCFG, MADT, DSDT & SSDT
ACPI table entries.
Use a Kconfig option GENERATE_ACPI_TABLE to tell U-Boot whether we need
actually write the APCI table just like we did for PIRQ routing, MP table
and SFI tables. With ACPI table existence, linux kernel gets control of
power management, thermal management, configuration management and
monitoring in hardware.
Signed-off-by: Saket Sinha <saket.sinha89@gmail.com>
Reviewed-by: Bin Meng <bmeng.cn@gmail.com>
Tidied up whitespace and aligned some tabs:
Signed-off-by: Simon Glass <sjg@chromium.org>
2015-08-22 15:50:55 +09:00
|
|
|
|
|
|
|
memset((void *)mcfg, 0, sizeof(struct acpi_mcfg));
|
|
|
|
|
|
|
|
/* Fill out header fields */
|
2016-05-07 23:46:24 +09:00
|
|
|
acpi_fill_header(header, "MCFG");
|
x86: Generate a valid ACPI table
Implement write_acpi_table() to create a minimal working ACPI table.
This includes writing FACS, XSDT, RSDP, FADT, MCFG, MADT, DSDT & SSDT
ACPI table entries.
Use a Kconfig option GENERATE_ACPI_TABLE to tell U-Boot whether we need
actually write the APCI table just like we did for PIRQ routing, MP table
and SFI tables. With ACPI table existence, linux kernel gets control of
power management, thermal management, configuration management and
monitoring in hardware.
Signed-off-by: Saket Sinha <saket.sinha89@gmail.com>
Reviewed-by: Bin Meng <bmeng.cn@gmail.com>
Tidied up whitespace and aligned some tabs:
Signed-off-by: Simon Glass <sjg@chromium.org>
2015-08-22 15:50:55 +09:00
|
|
|
header->length = sizeof(struct acpi_mcfg);
|
2016-05-07 23:46:28 +09:00
|
|
|
header->revision = 1;
|
x86: Generate a valid ACPI table
Implement write_acpi_table() to create a minimal working ACPI table.
This includes writing FACS, XSDT, RSDP, FADT, MCFG, MADT, DSDT & SSDT
ACPI table entries.
Use a Kconfig option GENERATE_ACPI_TABLE to tell U-Boot whether we need
actually write the APCI table just like we did for PIRQ routing, MP table
and SFI tables. With ACPI table existence, linux kernel gets control of
power management, thermal management, configuration management and
monitoring in hardware.
Signed-off-by: Saket Sinha <saket.sinha89@gmail.com>
Reviewed-by: Bin Meng <bmeng.cn@gmail.com>
Tidied up whitespace and aligned some tabs:
Signed-off-by: Simon Glass <sjg@chromium.org>
2015-08-22 15:50:55 +09:00
|
|
|
|
|
|
|
current = acpi_fill_mcfg(current);
|
|
|
|
|
|
|
|
/* (Re)calculate length and checksum */
|
2016-05-07 23:46:26 +09:00
|
|
|
header->length = current - (u32)mcfg;
|
x86: Generate a valid ACPI table
Implement write_acpi_table() to create a minimal working ACPI table.
This includes writing FACS, XSDT, RSDP, FADT, MCFG, MADT, DSDT & SSDT
ACPI table entries.
Use a Kconfig option GENERATE_ACPI_TABLE to tell U-Boot whether we need
actually write the APCI table just like we did for PIRQ routing, MP table
and SFI tables. With ACPI table existence, linux kernel gets control of
power management, thermal management, configuration management and
monitoring in hardware.
Signed-off-by: Saket Sinha <saket.sinha89@gmail.com>
Reviewed-by: Bin Meng <bmeng.cn@gmail.com>
Tidied up whitespace and aligned some tabs:
Signed-off-by: Simon Glass <sjg@chromium.org>
2015-08-22 15:50:55 +09:00
|
|
|
header->checksum = table_compute_checksum((void *)mcfg, header->length);
|
|
|
|
}
|
|
|
|
|
2020-09-23 03:45:33 +09:00
|
|
|
/**
|
|
|
|
* acpi_create_tcpa() - Create a TCPA table
|
|
|
|
*
|
|
|
|
* @tcpa: Pointer to place to put table
|
|
|
|
*
|
|
|
|
* Trusted Computing Platform Alliance Capabilities Table
|
|
|
|
* TCPA PC Specific Implementation SpecificationTCPA is defined in the PCI
|
|
|
|
* Firmware Specification 3.0
|
|
|
|
*/
|
|
|
|
static int acpi_create_tcpa(struct acpi_tcpa *tcpa)
|
|
|
|
{
|
|
|
|
struct acpi_table_header *header = &tcpa->header;
|
|
|
|
u32 current = (u32)tcpa + sizeof(struct acpi_tcpa);
|
|
|
|
int size = 0x10000; /* Use this as the default size */
|
|
|
|
void *log;
|
|
|
|
int ret;
|
|
|
|
|
|
|
|
if (!CONFIG_IS_ENABLED(BLOBLIST))
|
|
|
|
return -ENXIO;
|
|
|
|
memset(tcpa, '\0', sizeof(struct acpi_tcpa));
|
|
|
|
|
|
|
|
/* Fill out header fields */
|
|
|
|
acpi_fill_header(header, "TCPA");
|
|
|
|
header->length = sizeof(struct acpi_tcpa);
|
|
|
|
header->revision = 1;
|
|
|
|
|
|
|
|
ret = bloblist_ensure_size_ret(BLOBLISTT_TCPA_LOG, &size, &log);
|
|
|
|
if (ret)
|
|
|
|
return log_msg_ret("blob", ret);
|
|
|
|
|
|
|
|
tcpa->platform_class = 0;
|
|
|
|
tcpa->laml = size;
|
|
|
|
tcpa->lasa = (ulong)log;
|
|
|
|
|
|
|
|
/* (Re)calculate length and checksum */
|
|
|
|
header->length = current - (u32)tcpa;
|
|
|
|
header->checksum = table_compute_checksum((void *)tcpa, header->length);
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2020-09-23 03:45:32 +09:00
|
|
|
static int get_tpm2_log(void **ptrp, int *sizep)
|
|
|
|
{
|
|
|
|
const int tpm2_default_log_len = 0x10000;
|
|
|
|
int size;
|
|
|
|
int ret;
|
|
|
|
|
|
|
|
*sizep = 0;
|
|
|
|
size = tpm2_default_log_len;
|
|
|
|
ret = bloblist_ensure_size_ret(BLOBLISTT_TPM2_TCG_LOG, &size, ptrp);
|
|
|
|
if (ret)
|
|
|
|
return log_msg_ret("blob", ret);
|
|
|
|
*sizep = size;
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
static int acpi_create_tpm2(struct acpi_tpm2 *tpm2)
|
|
|
|
{
|
|
|
|
struct acpi_table_header *header = &tpm2->header;
|
|
|
|
int tpm2_log_len;
|
|
|
|
void *lasa;
|
|
|
|
int ret;
|
|
|
|
|
|
|
|
memset((void *)tpm2, 0, sizeof(struct acpi_tpm2));
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Some payloads like SeaBIOS depend on log area to use TPM2.
|
|
|
|
* Get the memory size and address of TPM2 log area or initialize it.
|
|
|
|
*/
|
|
|
|
ret = get_tpm2_log(&lasa, &tpm2_log_len);
|
|
|
|
if (ret)
|
|
|
|
return ret;
|
|
|
|
|
|
|
|
/* Fill out header fields. */
|
|
|
|
acpi_fill_header(header, "TPM2");
|
|
|
|
memcpy(header->aslc_id, ASLC_ID, 4);
|
|
|
|
|
|
|
|
header->length = sizeof(struct acpi_tpm2);
|
|
|
|
header->revision = acpi_get_table_revision(ACPITAB_TPM2);
|
|
|
|
|
|
|
|
/* Hard to detect for coreboot. Just set it to 0 */
|
|
|
|
tpm2->platform_class = 0;
|
|
|
|
|
|
|
|
/* Must be set to 0 for FIFO-interface support */
|
|
|
|
tpm2->control_area = 0;
|
|
|
|
tpm2->start_method = 6;
|
|
|
|
memset(tpm2->msp, 0, sizeof(tpm2->msp));
|
|
|
|
|
|
|
|
/* Fill the log area size and start address fields. */
|
|
|
|
tpm2->laml = tpm2_log_len;
|
|
|
|
tpm2->lasa = (uintptr_t)lasa;
|
|
|
|
|
|
|
|
/* Calculate checksum. */
|
|
|
|
header->checksum = table_compute_checksum((void *)tpm2, header->length);
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2019-07-15 01:23:57 +09:00
|
|
|
__weak u32 acpi_fill_csrt(u32 current)
|
|
|
|
{
|
2020-07-08 12:32:24 +09:00
|
|
|
return 0;
|
2019-07-15 01:23:57 +09:00
|
|
|
}
|
|
|
|
|
2020-07-08 12:32:24 +09:00
|
|
|
static int acpi_create_csrt(struct acpi_csrt *csrt)
|
2019-07-15 01:23:57 +09:00
|
|
|
{
|
|
|
|
struct acpi_table_header *header = &(csrt->header);
|
|
|
|
u32 current = (u32)csrt + sizeof(struct acpi_csrt);
|
2020-07-08 12:32:24 +09:00
|
|
|
uint ptr;
|
2019-07-15 01:23:57 +09:00
|
|
|
|
|
|
|
memset((void *)csrt, 0, sizeof(struct acpi_csrt));
|
|
|
|
|
|
|
|
/* Fill out header fields */
|
|
|
|
acpi_fill_header(header, "CSRT");
|
|
|
|
header->length = sizeof(struct acpi_csrt);
|
|
|
|
header->revision = 0;
|
|
|
|
|
2020-07-08 12:32:24 +09:00
|
|
|
ptr = acpi_fill_csrt(current);
|
|
|
|
if (!ptr)
|
|
|
|
return -ENOENT;
|
|
|
|
current = ptr;
|
2019-07-15 01:23:57 +09:00
|
|
|
|
|
|
|
/* (Re)calculate length and checksum */
|
|
|
|
header->length = current - (u32)csrt;
|
|
|
|
header->checksum = table_compute_checksum((void *)csrt, header->length);
|
2020-07-08 12:32:24 +09:00
|
|
|
|
|
|
|
return 0;
|
2019-07-15 01:23:57 +09:00
|
|
|
}
|
|
|
|
|
2018-11-21 06:52:38 +09:00
|
|
|
static void acpi_create_spcr(struct acpi_spcr *spcr)
|
|
|
|
{
|
|
|
|
struct acpi_table_header *header = &(spcr->header);
|
|
|
|
struct serial_device_info serial_info = {0};
|
|
|
|
ulong serial_address, serial_offset;
|
2018-12-29 06:23:08 +09:00
|
|
|
struct udevice *dev;
|
2018-11-21 06:52:38 +09:00
|
|
|
uint serial_config;
|
|
|
|
uint serial_width;
|
|
|
|
int access_size;
|
|
|
|
int space_id;
|
2019-03-01 00:19:54 +09:00
|
|
|
int ret = -ENODEV;
|
2018-11-21 06:52:38 +09:00
|
|
|
|
2020-09-16 23:57:53 +09:00
|
|
|
memset((void *)spcr, 0, sizeof(struct acpi_spcr));
|
|
|
|
|
2018-11-21 06:52:38 +09:00
|
|
|
/* Fill out header fields */
|
|
|
|
acpi_fill_header(header, "SPCR");
|
|
|
|
header->length = sizeof(struct acpi_spcr);
|
|
|
|
header->revision = 2;
|
|
|
|
|
2018-12-29 06:23:10 +09:00
|
|
|
/* Read the device once, here. It is reused below */
|
2019-03-01 00:19:54 +09:00
|
|
|
dev = gd->cur_serial_dev;
|
|
|
|
if (dev)
|
2018-12-29 06:23:10 +09:00
|
|
|
ret = serial_getinfo(dev, &serial_info);
|
2018-11-21 06:52:38 +09:00
|
|
|
if (ret)
|
|
|
|
serial_info.type = SERIAL_CHIP_UNKNOWN;
|
|
|
|
|
|
|
|
/* Encode chip type */
|
|
|
|
switch (serial_info.type) {
|
|
|
|
case SERIAL_CHIP_16550_COMPATIBLE:
|
|
|
|
spcr->interface_type = ACPI_DBG2_16550_COMPATIBLE;
|
|
|
|
break;
|
|
|
|
case SERIAL_CHIP_UNKNOWN:
|
|
|
|
default:
|
|
|
|
spcr->interface_type = ACPI_DBG2_UNKNOWN;
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* Encode address space */
|
|
|
|
switch (serial_info.addr_space) {
|
|
|
|
case SERIAL_ADDRESS_SPACE_MEMORY:
|
|
|
|
space_id = ACPI_ADDRESS_SPACE_MEMORY;
|
|
|
|
break;
|
|
|
|
case SERIAL_ADDRESS_SPACE_IO:
|
|
|
|
default:
|
|
|
|
space_id = ACPI_ADDRESS_SPACE_IO;
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
|
|
|
|
serial_width = serial_info.reg_width * 8;
|
|
|
|
serial_offset = serial_info.reg_offset << serial_info.reg_shift;
|
|
|
|
serial_address = serial_info.addr + serial_offset;
|
|
|
|
|
|
|
|
/* Encode register access size */
|
|
|
|
switch (serial_info.reg_shift) {
|
|
|
|
case 0:
|
|
|
|
access_size = ACPI_ACCESS_SIZE_BYTE_ACCESS;
|
|
|
|
break;
|
|
|
|
case 1:
|
|
|
|
access_size = ACPI_ACCESS_SIZE_WORD_ACCESS;
|
|
|
|
break;
|
|
|
|
case 2:
|
|
|
|
access_size = ACPI_ACCESS_SIZE_DWORD_ACCESS;
|
|
|
|
break;
|
|
|
|
case 3:
|
|
|
|
access_size = ACPI_ACCESS_SIZE_QWORD_ACCESS;
|
|
|
|
break;
|
|
|
|
default:
|
|
|
|
access_size = ACPI_ACCESS_SIZE_UNDEFINED;
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
|
|
|
|
debug("UART type %u @ %lx\n", spcr->interface_type, serial_address);
|
|
|
|
|
|
|
|
/* Fill GAS */
|
|
|
|
spcr->serial_port.space_id = space_id;
|
|
|
|
spcr->serial_port.bit_width = serial_width;
|
|
|
|
spcr->serial_port.bit_offset = 0;
|
|
|
|
spcr->serial_port.access_size = access_size;
|
|
|
|
spcr->serial_port.addrl = lower_32_bits(serial_address);
|
|
|
|
spcr->serial_port.addrh = upper_32_bits(serial_address);
|
|
|
|
|
|
|
|
/* Encode baud rate */
|
|
|
|
switch (serial_info.baudrate) {
|
|
|
|
case 9600:
|
|
|
|
spcr->baud_rate = 3;
|
|
|
|
break;
|
|
|
|
case 19200:
|
|
|
|
spcr->baud_rate = 4;
|
|
|
|
break;
|
|
|
|
case 57600:
|
|
|
|
spcr->baud_rate = 6;
|
|
|
|
break;
|
|
|
|
case 115200:
|
|
|
|
spcr->baud_rate = 7;
|
|
|
|
break;
|
|
|
|
default:
|
|
|
|
spcr->baud_rate = 0;
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
|
2018-12-29 06:23:10 +09:00
|
|
|
serial_config = SERIAL_DEFAULT_CONFIG;
|
|
|
|
if (dev)
|
2018-12-29 06:23:08 +09:00
|
|
|
ret = serial_getconfig(dev, &serial_config);
|
2018-11-21 06:52:38 +09:00
|
|
|
|
|
|
|
spcr->parity = SERIAL_GET_PARITY(serial_config);
|
|
|
|
spcr->stop_bits = SERIAL_GET_STOP(serial_config);
|
|
|
|
|
|
|
|
/* No PCI devices for now */
|
|
|
|
spcr->pci_device_id = 0xffff;
|
|
|
|
spcr->pci_vendor_id = 0xffff;
|
|
|
|
|
2020-02-28 00:21:56 +09:00
|
|
|
/*
|
|
|
|
* SPCR has no clue if the UART base clock speed is different
|
|
|
|
* to the default one. However, the SPCR 1.04 defines baud rate
|
|
|
|
* 0 as a preconfigured state of UART and OS is supposed not
|
|
|
|
* to touch the configuration of the serial device.
|
|
|
|
*/
|
|
|
|
if (serial_info.clock != SERIAL_DEFAULT_CLOCK)
|
|
|
|
spcr->baud_rate = 0;
|
|
|
|
|
2018-11-21 06:52:38 +09:00
|
|
|
/* Fix checksum */
|
|
|
|
header->checksum = table_compute_checksum((void *)spcr, header->length);
|
|
|
|
}
|
|
|
|
|
2020-11-05 01:57:31 +09:00
|
|
|
static int acpi_create_ssdt(struct acpi_ctx *ctx,
|
|
|
|
struct acpi_table_header *ssdt,
|
|
|
|
const char *oem_table_id)
|
2020-07-08 04:12:07 +09:00
|
|
|
{
|
|
|
|
memset((void *)ssdt, '\0', sizeof(struct acpi_table_header));
|
|
|
|
|
|
|
|
acpi_fill_header(ssdt, "SSDT");
|
|
|
|
ssdt->revision = acpi_get_table_revision(ACPITAB_SSDT);
|
|
|
|
ssdt->aslc_revision = 1;
|
|
|
|
ssdt->length = sizeof(struct acpi_table_header);
|
|
|
|
|
|
|
|
acpi_inc(ctx, sizeof(struct acpi_table_header));
|
|
|
|
|
|
|
|
acpi_fill_ssdt(ctx);
|
|
|
|
|
2020-11-05 01:57:31 +09:00
|
|
|
/* (Re)calculate length and checksum */
|
2020-07-08 04:12:07 +09:00
|
|
|
ssdt->length = ctx->current - (void *)ssdt;
|
|
|
|
ssdt->checksum = table_compute_checksum((void *)ssdt, ssdt->length);
|
2020-11-05 01:57:31 +09:00
|
|
|
log_debug("SSDT at %p, length %x\n", ssdt, ssdt->length);
|
|
|
|
|
|
|
|
/* Drop the table if it is empty */
|
|
|
|
if (ssdt->length == sizeof(struct acpi_table_header)) {
|
|
|
|
ctx->current = ssdt;
|
|
|
|
return -ENOENT;
|
|
|
|
}
|
|
|
|
acpi_align(ctx);
|
|
|
|
|
|
|
|
return 0;
|
2020-07-08 04:12:07 +09:00
|
|
|
}
|
|
|
|
|
2016-01-20 18:57:06 +09:00
|
|
|
/*
|
2018-01-11 02:33:10 +09:00
|
|
|
* QEMU's version of write_acpi_tables is defined in drivers/misc/qfw.c
|
2016-01-20 18:57:06 +09:00
|
|
|
*/
|
2020-04-27 00:19:47 +09:00
|
|
|
ulong write_acpi_tables(ulong start_addr)
|
x86: Generate a valid ACPI table
Implement write_acpi_table() to create a minimal working ACPI table.
This includes writing FACS, XSDT, RSDP, FADT, MCFG, MADT, DSDT & SSDT
ACPI table entries.
Use a Kconfig option GENERATE_ACPI_TABLE to tell U-Boot whether we need
actually write the APCI table just like we did for PIRQ routing, MP table
and SFI tables. With ACPI table existence, linux kernel gets control of
power management, thermal management, configuration management and
monitoring in hardware.
Signed-off-by: Saket Sinha <saket.sinha89@gmail.com>
Reviewed-by: Bin Meng <bmeng.cn@gmail.com>
Tidied up whitespace and aligned some tabs:
Signed-off-by: Simon Glass <sjg@chromium.org>
2015-08-22 15:50:55 +09:00
|
|
|
{
|
2020-11-05 01:57:32 +09:00
|
|
|
const int thl = sizeof(struct acpi_table_header);
|
2020-11-05 01:57:19 +09:00
|
|
|
struct acpi_ctx *ctx;
|
x86: Generate a valid ACPI table
Implement write_acpi_table() to create a minimal working ACPI table.
This includes writing FACS, XSDT, RSDP, FADT, MCFG, MADT, DSDT & SSDT
ACPI table entries.
Use a Kconfig option GENERATE_ACPI_TABLE to tell U-Boot whether we need
actually write the APCI table just like we did for PIRQ routing, MP table
and SFI tables. With ACPI table existence, linux kernel gets control of
power management, thermal management, configuration management and
monitoring in hardware.
Signed-off-by: Saket Sinha <saket.sinha89@gmail.com>
Reviewed-by: Bin Meng <bmeng.cn@gmail.com>
Tidied up whitespace and aligned some tabs:
Signed-off-by: Simon Glass <sjg@chromium.org>
2015-08-22 15:50:55 +09:00
|
|
|
struct acpi_facs *facs;
|
2016-05-07 23:46:21 +09:00
|
|
|
struct acpi_table_header *dsdt;
|
x86: Generate a valid ACPI table
Implement write_acpi_table() to create a minimal working ACPI table.
This includes writing FACS, XSDT, RSDP, FADT, MCFG, MADT, DSDT & SSDT
ACPI table entries.
Use a Kconfig option GENERATE_ACPI_TABLE to tell U-Boot whether we need
actually write the APCI table just like we did for PIRQ routing, MP table
and SFI tables. With ACPI table existence, linux kernel gets control of
power management, thermal management, configuration management and
monitoring in hardware.
Signed-off-by: Saket Sinha <saket.sinha89@gmail.com>
Reviewed-by: Bin Meng <bmeng.cn@gmail.com>
Tidied up whitespace and aligned some tabs:
Signed-off-by: Simon Glass <sjg@chromium.org>
2015-08-22 15:50:55 +09:00
|
|
|
struct acpi_fadt *fadt;
|
2020-07-08 04:12:07 +09:00
|
|
|
struct acpi_table_header *ssdt;
|
x86: Generate a valid ACPI table
Implement write_acpi_table() to create a minimal working ACPI table.
This includes writing FACS, XSDT, RSDP, FADT, MCFG, MADT, DSDT & SSDT
ACPI table entries.
Use a Kconfig option GENERATE_ACPI_TABLE to tell U-Boot whether we need
actually write the APCI table just like we did for PIRQ routing, MP table
and SFI tables. With ACPI table existence, linux kernel gets control of
power management, thermal management, configuration management and
monitoring in hardware.
Signed-off-by: Saket Sinha <saket.sinha89@gmail.com>
Reviewed-by: Bin Meng <bmeng.cn@gmail.com>
Tidied up whitespace and aligned some tabs:
Signed-off-by: Simon Glass <sjg@chromium.org>
2015-08-22 15:50:55 +09:00
|
|
|
struct acpi_mcfg *mcfg;
|
2020-09-23 03:45:33 +09:00
|
|
|
struct acpi_tcpa *tcpa;
|
x86: Generate a valid ACPI table
Implement write_acpi_table() to create a minimal working ACPI table.
This includes writing FACS, XSDT, RSDP, FADT, MCFG, MADT, DSDT & SSDT
ACPI table entries.
Use a Kconfig option GENERATE_ACPI_TABLE to tell U-Boot whether we need
actually write the APCI table just like we did for PIRQ routing, MP table
and SFI tables. With ACPI table existence, linux kernel gets control of
power management, thermal management, configuration management and
monitoring in hardware.
Signed-off-by: Saket Sinha <saket.sinha89@gmail.com>
Reviewed-by: Bin Meng <bmeng.cn@gmail.com>
Tidied up whitespace and aligned some tabs:
Signed-off-by: Simon Glass <sjg@chromium.org>
2015-08-22 15:50:55 +09:00
|
|
|
struct acpi_madt *madt;
|
2019-07-15 01:23:57 +09:00
|
|
|
struct acpi_csrt *csrt;
|
2018-11-21 06:52:38 +09:00
|
|
|
struct acpi_spcr *spcr;
|
2020-04-27 00:19:47 +09:00
|
|
|
void *start;
|
2020-11-05 01:57:32 +09:00
|
|
|
int aml_len;
|
2020-04-27 00:19:47 +09:00
|
|
|
ulong addr;
|
2020-09-23 03:45:33 +09:00
|
|
|
int ret;
|
2016-06-17 18:13:16 +09:00
|
|
|
int i;
|
x86: Generate a valid ACPI table
Implement write_acpi_table() to create a minimal working ACPI table.
This includes writing FACS, XSDT, RSDP, FADT, MCFG, MADT, DSDT & SSDT
ACPI table entries.
Use a Kconfig option GENERATE_ACPI_TABLE to tell U-Boot whether we need
actually write the APCI table just like we did for PIRQ routing, MP table
and SFI tables. With ACPI table existence, linux kernel gets control of
power management, thermal management, configuration management and
monitoring in hardware.
Signed-off-by: Saket Sinha <saket.sinha89@gmail.com>
Reviewed-by: Bin Meng <bmeng.cn@gmail.com>
Tidied up whitespace and aligned some tabs:
Signed-off-by: Simon Glass <sjg@chromium.org>
2015-08-22 15:50:55 +09:00
|
|
|
|
2020-11-05 01:57:19 +09:00
|
|
|
ctx = calloc(1, sizeof(*ctx));
|
|
|
|
if (!ctx)
|
|
|
|
return log_msg_ret("mem", -ENOMEM);
|
|
|
|
gd->acpi_ctx = ctx;
|
|
|
|
|
2020-04-27 00:19:47 +09:00
|
|
|
start = map_sysmem(start_addr, 0);
|
x86: Generate a valid ACPI table
Implement write_acpi_table() to create a minimal working ACPI table.
This includes writing FACS, XSDT, RSDP, FADT, MCFG, MADT, DSDT & SSDT
ACPI table entries.
Use a Kconfig option GENERATE_ACPI_TABLE to tell U-Boot whether we need
actually write the APCI table just like we did for PIRQ routing, MP table
and SFI tables. With ACPI table existence, linux kernel gets control of
power management, thermal management, configuration management and
monitoring in hardware.
Signed-off-by: Saket Sinha <saket.sinha89@gmail.com>
Reviewed-by: Bin Meng <bmeng.cn@gmail.com>
Tidied up whitespace and aligned some tabs:
Signed-off-by: Simon Glass <sjg@chromium.org>
2015-08-22 15:50:55 +09:00
|
|
|
|
2020-04-27 00:19:47 +09:00
|
|
|
debug("ACPI: Writing ACPI tables at %lx\n", start_addr);
|
x86: Generate a valid ACPI table
Implement write_acpi_table() to create a minimal working ACPI table.
This includes writing FACS, XSDT, RSDP, FADT, MCFG, MADT, DSDT & SSDT
ACPI table entries.
Use a Kconfig option GENERATE_ACPI_TABLE to tell U-Boot whether we need
actually write the APCI table just like we did for PIRQ routing, MP table
and SFI tables. With ACPI table existence, linux kernel gets control of
power management, thermal management, configuration management and
monitoring in hardware.
Signed-off-by: Saket Sinha <saket.sinha89@gmail.com>
Reviewed-by: Bin Meng <bmeng.cn@gmail.com>
Tidied up whitespace and aligned some tabs:
Signed-off-by: Simon Glass <sjg@chromium.org>
2015-08-22 15:50:55 +09:00
|
|
|
|
2020-11-05 01:57:33 +09:00
|
|
|
acpi_reset_items();
|
2020-04-27 00:19:51 +09:00
|
|
|
acpi_setup_base_tables(ctx, start);
|
x86: Generate a valid ACPI table
Implement write_acpi_table() to create a minimal working ACPI table.
This includes writing FACS, XSDT, RSDP, FADT, MCFG, MADT, DSDT & SSDT
ACPI table entries.
Use a Kconfig option GENERATE_ACPI_TABLE to tell U-Boot whether we need
actually write the APCI table just like we did for PIRQ routing, MP table
and SFI tables. With ACPI table existence, linux kernel gets control of
power management, thermal management, configuration management and
monitoring in hardware.
Signed-off-by: Saket Sinha <saket.sinha89@gmail.com>
Reviewed-by: Bin Meng <bmeng.cn@gmail.com>
Tidied up whitespace and aligned some tabs:
Signed-off-by: Simon Glass <sjg@chromium.org>
2015-08-22 15:50:55 +09:00
|
|
|
|
|
|
|
debug("ACPI: * FACS\n");
|
2020-04-27 00:19:47 +09:00
|
|
|
facs = ctx->current;
|
|
|
|
acpi_inc_align(ctx, sizeof(struct acpi_facs));
|
x86: Generate a valid ACPI table
Implement write_acpi_table() to create a minimal working ACPI table.
This includes writing FACS, XSDT, RSDP, FADT, MCFG, MADT, DSDT & SSDT
ACPI table entries.
Use a Kconfig option GENERATE_ACPI_TABLE to tell U-Boot whether we need
actually write the APCI table just like we did for PIRQ routing, MP table
and SFI tables. With ACPI table existence, linux kernel gets control of
power management, thermal management, configuration management and
monitoring in hardware.
Signed-off-by: Saket Sinha <saket.sinha89@gmail.com>
Reviewed-by: Bin Meng <bmeng.cn@gmail.com>
Tidied up whitespace and aligned some tabs:
Signed-off-by: Simon Glass <sjg@chromium.org>
2015-08-22 15:50:55 +09:00
|
|
|
|
|
|
|
acpi_create_facs(facs);
|
|
|
|
|
|
|
|
debug("ACPI: * DSDT\n");
|
2020-04-27 00:19:47 +09:00
|
|
|
dsdt = ctx->current;
|
2020-07-08 04:12:09 +09:00
|
|
|
|
|
|
|
/* Put the table header first */
|
2020-11-05 01:57:32 +09:00
|
|
|
memcpy(dsdt, &AmlCode, thl);
|
|
|
|
acpi_inc(ctx, thl);
|
|
|
|
log_debug("DSDT starts at %p, hdr ends at %p\n", dsdt, ctx->current);
|
2020-07-08 04:12:09 +09:00
|
|
|
|
|
|
|
/* If the table is not empty, allow devices to inject things */
|
2020-11-05 01:57:32 +09:00
|
|
|
aml_len = dsdt->length - thl;
|
|
|
|
if (aml_len) {
|
|
|
|
void *base = ctx->current;
|
2020-07-08 04:12:09 +09:00
|
|
|
|
2020-11-05 01:57:32 +09:00
|
|
|
acpi_inject_dsdt(ctx);
|
|
|
|
log_debug("Added %x bytes from inject_dsdt, now at %p\n",
|
|
|
|
ctx->current - base, ctx->current);
|
|
|
|
log_debug("Copy AML code size %x to %p\n", aml_len,
|
|
|
|
ctx->current);
|
|
|
|
memcpy(ctx->current, AmlCode + thl, aml_len);
|
|
|
|
acpi_inc(ctx, aml_len);
|
|
|
|
}
|
2020-07-08 04:12:09 +09:00
|
|
|
|
2020-09-23 03:44:53 +09:00
|
|
|
dsdt->length = ctx->current - (void *)dsdt;
|
|
|
|
acpi_align(ctx);
|
2020-11-05 01:57:32 +09:00
|
|
|
log_debug("Updated DSDT length to %x, total %x\n", dsdt->length,
|
|
|
|
ctx->current - (void *)dsdt);
|
x86: Generate a valid ACPI table
Implement write_acpi_table() to create a minimal working ACPI table.
This includes writing FACS, XSDT, RSDP, FADT, MCFG, MADT, DSDT & SSDT
ACPI table entries.
Use a Kconfig option GENERATE_ACPI_TABLE to tell U-Boot whether we need
actually write the APCI table just like we did for PIRQ routing, MP table
and SFI tables. With ACPI table existence, linux kernel gets control of
power management, thermal management, configuration management and
monitoring in hardware.
Signed-off-by: Saket Sinha <saket.sinha89@gmail.com>
Reviewed-by: Bin Meng <bmeng.cn@gmail.com>
Tidied up whitespace and aligned some tabs:
Signed-off-by: Simon Glass <sjg@chromium.org>
2015-08-22 15:50:55 +09:00
|
|
|
|
2020-09-23 03:44:53 +09:00
|
|
|
if (!IS_ENABLED(CONFIG_ACPI_GNVS_EXTERNAL)) {
|
|
|
|
/* Pack GNVS into the ACPI table area */
|
|
|
|
for (i = 0; i < dsdt->length; i++) {
|
|
|
|
u32 *gnvs = (u32 *)((u32)dsdt + i);
|
|
|
|
|
|
|
|
if (*gnvs == ACPI_GNVS_ADDR) {
|
|
|
|
*gnvs = map_to_sysmem(ctx->current);
|
|
|
|
debug("Fix up global NVS in DSDT to %#08x\n",
|
|
|
|
*gnvs);
|
|
|
|
break;
|
|
|
|
}
|
2016-06-17 18:13:16 +09:00
|
|
|
}
|
2020-09-23 03:44:53 +09:00
|
|
|
|
|
|
|
/*
|
|
|
|
* Fill in platform-specific global NVS variables. If this fails
|
|
|
|
* we cannot return the error but this should only happen while
|
|
|
|
* debugging.
|
|
|
|
*/
|
|
|
|
addr = acpi_create_gnvs(ctx->current);
|
|
|
|
if (IS_ERR_VALUE(addr))
|
|
|
|
printf("Error: Gailed to create GNVS\n");
|
|
|
|
acpi_inc_align(ctx, sizeof(struct acpi_global_nvs));
|
2016-06-17 18:13:16 +09:00
|
|
|
}
|
|
|
|
|
2020-07-08 04:12:09 +09:00
|
|
|
/*
|
|
|
|
* Recalculate the length and update the DSDT checksum since we patched
|
|
|
|
* the GNVS address. Set the checksum to zero since it is part of the
|
|
|
|
* region being checksummed.
|
|
|
|
*/
|
2016-06-17 18:13:16 +09:00
|
|
|
dsdt->checksum = 0;
|
|
|
|
dsdt->checksum = table_compute_checksum((void *)dsdt, dsdt->length);
|
|
|
|
|
2020-07-08 12:32:05 +09:00
|
|
|
/*
|
|
|
|
* Fill in platform-specific global NVS variables. If this fails we
|
|
|
|
* cannot return the error but this should only happen while debugging.
|
|
|
|
*/
|
|
|
|
addr = acpi_create_gnvs(ctx->current);
|
|
|
|
if (IS_ERR_VALUE(addr))
|
|
|
|
printf("Error: Failed to create GNVS\n");
|
|
|
|
|
2020-04-27 00:19:47 +09:00
|
|
|
acpi_inc_align(ctx, sizeof(struct acpi_global_nvs));
|
2016-06-17 18:13:16 +09:00
|
|
|
|
x86: Generate a valid ACPI table
Implement write_acpi_table() to create a minimal working ACPI table.
This includes writing FACS, XSDT, RSDP, FADT, MCFG, MADT, DSDT & SSDT
ACPI table entries.
Use a Kconfig option GENERATE_ACPI_TABLE to tell U-Boot whether we need
actually write the APCI table just like we did for PIRQ routing, MP table
and SFI tables. With ACPI table existence, linux kernel gets control of
power management, thermal management, configuration management and
monitoring in hardware.
Signed-off-by: Saket Sinha <saket.sinha89@gmail.com>
Reviewed-by: Bin Meng <bmeng.cn@gmail.com>
Tidied up whitespace and aligned some tabs:
Signed-off-by: Simon Glass <sjg@chromium.org>
2015-08-22 15:50:55 +09:00
|
|
|
debug("ACPI: * FADT\n");
|
2020-04-27 00:19:47 +09:00
|
|
|
fadt = ctx->current;
|
|
|
|
acpi_inc_align(ctx, sizeof(struct acpi_fadt));
|
x86: Generate a valid ACPI table
Implement write_acpi_table() to create a minimal working ACPI table.
This includes writing FACS, XSDT, RSDP, FADT, MCFG, MADT, DSDT & SSDT
ACPI table entries.
Use a Kconfig option GENERATE_ACPI_TABLE to tell U-Boot whether we need
actually write the APCI table just like we did for PIRQ routing, MP table
and SFI tables. With ACPI table existence, linux kernel gets control of
power management, thermal management, configuration management and
monitoring in hardware.
Signed-off-by: Saket Sinha <saket.sinha89@gmail.com>
Reviewed-by: Bin Meng <bmeng.cn@gmail.com>
Tidied up whitespace and aligned some tabs:
Signed-off-by: Simon Glass <sjg@chromium.org>
2015-08-22 15:50:55 +09:00
|
|
|
acpi_create_fadt(fadt, facs, dsdt);
|
2020-04-27 00:19:50 +09:00
|
|
|
acpi_add_table(ctx, fadt);
|
x86: Generate a valid ACPI table
Implement write_acpi_table() to create a minimal working ACPI table.
This includes writing FACS, XSDT, RSDP, FADT, MCFG, MADT, DSDT & SSDT
ACPI table entries.
Use a Kconfig option GENERATE_ACPI_TABLE to tell U-Boot whether we need
actually write the APCI table just like we did for PIRQ routing, MP table
and SFI tables. With ACPI table existence, linux kernel gets control of
power management, thermal management, configuration management and
monitoring in hardware.
Signed-off-by: Saket Sinha <saket.sinha89@gmail.com>
Reviewed-by: Bin Meng <bmeng.cn@gmail.com>
Tidied up whitespace and aligned some tabs:
Signed-off-by: Simon Glass <sjg@chromium.org>
2015-08-22 15:50:55 +09:00
|
|
|
|
2020-07-08 04:12:07 +09:00
|
|
|
debug("ACPI: * SSDT\n");
|
|
|
|
ssdt = (struct acpi_table_header *)ctx->current;
|
2020-11-05 01:57:31 +09:00
|
|
|
if (!acpi_create_ssdt(ctx, ssdt, OEM_TABLE_ID))
|
2020-07-08 04:12:07 +09:00
|
|
|
acpi_add_table(ctx, ssdt);
|
|
|
|
|
2016-05-07 23:46:25 +09:00
|
|
|
debug("ACPI: * MCFG\n");
|
2020-04-27 00:19:47 +09:00
|
|
|
mcfg = ctx->current;
|
2016-05-07 23:46:25 +09:00
|
|
|
acpi_create_mcfg(mcfg);
|
2020-04-27 00:19:47 +09:00
|
|
|
acpi_inc_align(ctx, mcfg->header.length);
|
2020-04-27 00:19:50 +09:00
|
|
|
acpi_add_table(ctx, mcfg);
|
2016-05-07 23:46:25 +09:00
|
|
|
|
2020-09-23 03:45:32 +09:00
|
|
|
if (IS_ENABLED(CONFIG_TPM_V2)) {
|
|
|
|
struct acpi_tpm2 *tpm2;
|
|
|
|
|
|
|
|
debug("ACPI: * TPM2\n");
|
|
|
|
tpm2 = (struct acpi_tpm2 *)ctx->current;
|
|
|
|
ret = acpi_create_tpm2(tpm2);
|
|
|
|
if (!ret) {
|
|
|
|
acpi_inc_align(ctx, tpm2->header.length);
|
|
|
|
acpi_add_table(ctx, tpm2);
|
|
|
|
} else {
|
|
|
|
log_warning("TPM2 table creation failed\n");
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2020-07-08 04:12:04 +09:00
|
|
|
debug("ACPI: * MADT\n");
|
|
|
|
madt = ctx->current;
|
|
|
|
acpi_create_madt(madt);
|
|
|
|
acpi_inc_align(ctx, madt->header.length);
|
|
|
|
acpi_add_table(ctx, madt);
|
|
|
|
|
2020-11-05 01:57:40 +09:00
|
|
|
if (IS_ENABLED(CONFIG_TPM_V1)) {
|
|
|
|
debug("ACPI: * TCPA\n");
|
|
|
|
tcpa = (struct acpi_tcpa *)ctx->current;
|
|
|
|
ret = acpi_create_tcpa(tcpa);
|
|
|
|
if (ret) {
|
|
|
|
log_warning("Failed to create TCPA table (err=%d)\n",
|
|
|
|
ret);
|
|
|
|
} else {
|
|
|
|
acpi_inc_align(ctx, tcpa->header.length);
|
|
|
|
acpi_add_table(ctx, tcpa);
|
|
|
|
}
|
2020-09-23 03:45:33 +09:00
|
|
|
}
|
|
|
|
|
2019-07-15 01:23:57 +09:00
|
|
|
debug("ACPI: * CSRT\n");
|
2020-04-27 00:19:47 +09:00
|
|
|
csrt = ctx->current;
|
2020-07-08 12:32:24 +09:00
|
|
|
if (!acpi_create_csrt(csrt)) {
|
|
|
|
acpi_inc_align(ctx, csrt->header.length);
|
|
|
|
acpi_add_table(ctx, csrt);
|
|
|
|
}
|
2019-07-15 01:23:57 +09:00
|
|
|
|
2018-11-21 06:52:38 +09:00
|
|
|
debug("ACPI: * SPCR\n");
|
2020-04-27 00:19:47 +09:00
|
|
|
spcr = ctx->current;
|
2018-11-21 06:52:38 +09:00
|
|
|
acpi_create_spcr(spcr);
|
2020-04-27 00:19:47 +09:00
|
|
|
acpi_inc_align(ctx, spcr->header.length);
|
2020-04-27 00:19:50 +09:00
|
|
|
acpi_add_table(ctx, spcr);
|
2018-11-21 06:52:38 +09:00
|
|
|
|
2020-04-27 00:19:48 +09:00
|
|
|
acpi_write_dev_tables(ctx);
|
|
|
|
|
2020-04-27 00:19:47 +09:00
|
|
|
addr = map_to_sysmem(ctx->current);
|
|
|
|
debug("current = %lx\n", addr);
|
x86: Generate a valid ACPI table
Implement write_acpi_table() to create a minimal working ACPI table.
This includes writing FACS, XSDT, RSDP, FADT, MCFG, MADT, DSDT & SSDT
ACPI table entries.
Use a Kconfig option GENERATE_ACPI_TABLE to tell U-Boot whether we need
actually write the APCI table just like we did for PIRQ routing, MP table
and SFI tables. With ACPI table existence, linux kernel gets control of
power management, thermal management, configuration management and
monitoring in hardware.
Signed-off-by: Saket Sinha <saket.sinha89@gmail.com>
Reviewed-by: Bin Meng <bmeng.cn@gmail.com>
Tidied up whitespace and aligned some tabs:
Signed-off-by: Simon Glass <sjg@chromium.org>
2015-08-22 15:50:55 +09:00
|
|
|
|
2020-04-27 00:19:50 +09:00
|
|
|
acpi_rsdp_addr = (unsigned long)ctx->rsdp;
|
2016-05-07 23:46:12 +09:00
|
|
|
debug("ACPI: done\n");
|
x86: Generate a valid ACPI table
Implement write_acpi_table() to create a minimal working ACPI table.
This includes writing FACS, XSDT, RSDP, FADT, MCFG, MADT, DSDT & SSDT
ACPI table entries.
Use a Kconfig option GENERATE_ACPI_TABLE to tell U-Boot whether we need
actually write the APCI table just like we did for PIRQ routing, MP table
and SFI tables. With ACPI table existence, linux kernel gets control of
power management, thermal management, configuration management and
monitoring in hardware.
Signed-off-by: Saket Sinha <saket.sinha89@gmail.com>
Reviewed-by: Bin Meng <bmeng.cn@gmail.com>
Tidied up whitespace and aligned some tabs:
Signed-off-by: Simon Glass <sjg@chromium.org>
2015-08-22 15:50:55 +09:00
|
|
|
|
2020-04-27 00:19:47 +09:00
|
|
|
return addr;
|
x86: Generate a valid ACPI table
Implement write_acpi_table() to create a minimal working ACPI table.
This includes writing FACS, XSDT, RSDP, FADT, MCFG, MADT, DSDT & SSDT
ACPI table entries.
Use a Kconfig option GENERATE_ACPI_TABLE to tell U-Boot whether we need
actually write the APCI table just like we did for PIRQ routing, MP table
and SFI tables. With ACPI table existence, linux kernel gets control of
power management, thermal management, configuration management and
monitoring in hardware.
Signed-off-by: Saket Sinha <saket.sinha89@gmail.com>
Reviewed-by: Bin Meng <bmeng.cn@gmail.com>
Tidied up whitespace and aligned some tabs:
Signed-off-by: Simon Glass <sjg@chromium.org>
2015-08-22 15:50:55 +09:00
|
|
|
}
|
2017-04-21 23:24:36 +09:00
|
|
|
|
2018-01-30 22:01:16 +09:00
|
|
|
ulong acpi_get_rsdp_addr(void)
|
|
|
|
{
|
|
|
|
return acpi_rsdp_addr;
|
|
|
|
}
|
2020-09-23 03:45:09 +09:00
|
|
|
|
|
|
|
/**
|
|
|
|
* acpi_write_hpet() - Write out a HPET table
|
|
|
|
*
|
|
|
|
* Write out the table for High-Precision Event Timers
|
|
|
|
*
|
|
|
|
* @hpet: Place to put HPET table
|
|
|
|
*/
|
|
|
|
static int acpi_create_hpet(struct acpi_hpet *hpet)
|
|
|
|
{
|
|
|
|
struct acpi_table_header *header = &hpet->header;
|
|
|
|
struct acpi_gen_regaddr *addr = &hpet->addr;
|
|
|
|
|
|
|
|
/*
|
|
|
|
* See IA-PC HPET (High Precision Event Timers) Specification v1.0a
|
|
|
|
* https://www.intel.com/content/dam/www/public/us/en/documents/technical-specifications/software-developers-hpet-spec-1-0a.pdf
|
|
|
|
*/
|
|
|
|
memset((void *)hpet, '\0', sizeof(struct acpi_hpet));
|
|
|
|
|
|
|
|
/* Fill out header fields. */
|
|
|
|
acpi_fill_header(header, "HPET");
|
|
|
|
|
|
|
|
header->aslc_revision = ASL_REVISION;
|
|
|
|
header->length = sizeof(struct acpi_hpet);
|
|
|
|
header->revision = acpi_get_table_revision(ACPITAB_HPET);
|
|
|
|
|
|
|
|
/* Fill out HPET address */
|
|
|
|
addr->space_id = 0; /* Memory */
|
|
|
|
addr->bit_width = 64;
|
|
|
|
addr->bit_offset = 0;
|
|
|
|
addr->addrl = CONFIG_HPET_ADDRESS & 0xffffffff;
|
|
|
|
addr->addrh = ((unsigned long long)CONFIG_HPET_ADDRESS) >> 32;
|
|
|
|
|
|
|
|
hpet->id = *(u32 *)CONFIG_HPET_ADDRESS;
|
|
|
|
hpet->number = 0;
|
|
|
|
hpet->min_tick = 0; /* HPET_MIN_TICKS */
|
|
|
|
|
|
|
|
header->checksum = table_compute_checksum(hpet,
|
|
|
|
sizeof(struct acpi_hpet));
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
int acpi_write_hpet(struct acpi_ctx *ctx)
|
|
|
|
{
|
|
|
|
struct acpi_hpet *hpet;
|
|
|
|
int ret;
|
|
|
|
|
|
|
|
log_debug("ACPI: * HPET\n");
|
|
|
|
|
|
|
|
hpet = ctx->current;
|
|
|
|
acpi_inc_align(ctx, sizeof(struct acpi_hpet));
|
|
|
|
acpi_create_hpet(hpet);
|
|
|
|
ret = acpi_add_table(ctx, hpet);
|
|
|
|
if (ret)
|
|
|
|
return log_msg_ret("add", ret);
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
2020-09-23 03:45:10 +09:00
|
|
|
|
|
|
|
int acpi_write_dbg2_pci_uart(struct acpi_ctx *ctx, struct udevice *dev,
|
|
|
|
uint access_size)
|
|
|
|
{
|
|
|
|
struct acpi_dbg2_header *dbg2 = ctx->current;
|
|
|
|
char path[ACPI_PATH_MAX];
|
|
|
|
struct acpi_gen_regaddr address;
|
|
|
|
phys_addr_t addr;
|
|
|
|
int ret;
|
|
|
|
|
|
|
|
if (!device_active(dev)) {
|
|
|
|
log_info("Device not enabled\n");
|
|
|
|
return -EACCES;
|
|
|
|
}
|
|
|
|
/*
|
|
|
|
* PCI devices don't remember their resource allocation information in
|
|
|
|
* U-Boot at present. We assume that MMIO is used for the UART and that
|
|
|
|
* the address space is 32 bytes: ns16550 uses 8 registers of up to
|
|
|
|
* 32-bits each. This is only for debugging so it is not a big deal.
|
|
|
|
*/
|
|
|
|
addr = dm_pci_read_bar32(dev, 0);
|
|
|
|
printf("UART addr %lx\n", (ulong)addr);
|
|
|
|
|
|
|
|
memset(&address, '\0', sizeof(address));
|
|
|
|
address.space_id = ACPI_ADDRESS_SPACE_MEMORY;
|
|
|
|
address.addrl = (uint32_t)addr;
|
|
|
|
address.addrh = (uint32_t)((addr >> 32) & 0xffffffff);
|
|
|
|
address.access_size = access_size;
|
|
|
|
|
|
|
|
ret = acpi_device_path(dev, path, sizeof(path));
|
|
|
|
if (ret)
|
|
|
|
return log_msg_ret("path", ret);
|
|
|
|
acpi_create_dbg2(dbg2, ACPI_DBG2_SERIAL_PORT,
|
|
|
|
ACPI_DBG2_16550_COMPATIBLE, &address, 0x1000, path);
|
|
|
|
|
|
|
|
acpi_inc_align(ctx, dbg2->header.length);
|
|
|
|
acpi_add_table(ctx, dbg2);
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
2020-09-23 03:45:16 +09:00
|
|
|
|
|
|
|
void acpi_fadt_common(struct acpi_fadt *fadt, struct acpi_facs *facs,
|
|
|
|
void *dsdt)
|
|
|
|
{
|
|
|
|
struct acpi_table_header *header = &fadt->header;
|
|
|
|
|
|
|
|
memset((void *)fadt, '\0', sizeof(struct acpi_fadt));
|
|
|
|
|
|
|
|
acpi_fill_header(header, "FACP");
|
|
|
|
header->length = sizeof(struct acpi_fadt);
|
|
|
|
header->revision = 4;
|
|
|
|
memcpy(header->oem_id, OEM_ID, 6);
|
|
|
|
memcpy(header->oem_table_id, OEM_TABLE_ID, 8);
|
|
|
|
memcpy(header->aslc_id, ASLC_ID, 4);
|
|
|
|
header->aslc_revision = 1;
|
|
|
|
|
|
|
|
fadt->firmware_ctrl = (unsigned long)facs;
|
|
|
|
fadt->dsdt = (unsigned long)dsdt;
|
|
|
|
|
|
|
|
fadt->x_firmware_ctl_l = (unsigned long)facs;
|
|
|
|
fadt->x_firmware_ctl_h = 0;
|
|
|
|
fadt->x_dsdt_l = (unsigned long)dsdt;
|
|
|
|
fadt->x_dsdt_h = 0;
|
|
|
|
|
|
|
|
fadt->preferred_pm_profile = ACPI_PM_MOBILE;
|
|
|
|
|
|
|
|
/* Use ACPI 3.0 revision */
|
|
|
|
fadt->header.revision = 4;
|
|
|
|
}
|
|
|
|
|
|
|
|
void acpi_create_dmar_drhd(struct acpi_ctx *ctx, uint flags, uint segment,
|
|
|
|
u64 bar)
|
|
|
|
{
|
|
|
|
struct dmar_entry *drhd = ctx->current;
|
|
|
|
|
|
|
|
memset(drhd, '\0', sizeof(*drhd));
|
|
|
|
drhd->type = DMAR_DRHD;
|
|
|
|
drhd->length = sizeof(*drhd); /* will be fixed up later */
|
|
|
|
drhd->flags = flags;
|
|
|
|
drhd->segment = segment;
|
|
|
|
drhd->bar = bar;
|
|
|
|
acpi_inc(ctx, drhd->length);
|
|
|
|
}
|
|
|
|
|
|
|
|
void acpi_create_dmar_rmrr(struct acpi_ctx *ctx, uint segment, u64 bar,
|
|
|
|
u64 limit)
|
|
|
|
{
|
|
|
|
struct dmar_rmrr_entry *rmrr = ctx->current;
|
|
|
|
|
|
|
|
memset(rmrr, '\0', sizeof(*rmrr));
|
|
|
|
rmrr->type = DMAR_RMRR;
|
|
|
|
rmrr->length = sizeof(*rmrr); /* will be fixed up later */
|
|
|
|
rmrr->segment = segment;
|
|
|
|
rmrr->bar = bar;
|
|
|
|
rmrr->limit = limit;
|
|
|
|
acpi_inc(ctx, rmrr->length);
|
|
|
|
}
|
|
|
|
|
|
|
|
void acpi_dmar_drhd_fixup(struct acpi_ctx *ctx, void *base)
|
|
|
|
{
|
|
|
|
struct dmar_entry *drhd = base;
|
|
|
|
|
|
|
|
drhd->length = ctx->current - base;
|
|
|
|
}
|
|
|
|
|
|
|
|
void acpi_dmar_rmrr_fixup(struct acpi_ctx *ctx, void *base)
|
|
|
|
{
|
|
|
|
struct dmar_rmrr_entry *rmrr = base;
|
|
|
|
|
|
|
|
rmrr->length = ctx->current - base;
|
|
|
|
}
|
|
|
|
|
|
|
|
static int acpi_create_dmar_ds(struct acpi_ctx *ctx, enum dev_scope_type type,
|
|
|
|
uint enumeration_id, pci_dev_t bdf)
|
|
|
|
{
|
|
|
|
/* we don't support longer paths yet */
|
|
|
|
const size_t dev_scope_length = sizeof(struct dev_scope) + 2;
|
|
|
|
struct dev_scope *ds = ctx->current;
|
|
|
|
|
|
|
|
memset(ds, '\0', dev_scope_length);
|
|
|
|
ds->type = type;
|
|
|
|
ds->length = dev_scope_length;
|
|
|
|
ds->enumeration = enumeration_id;
|
|
|
|
ds->start_bus = PCI_BUS(bdf);
|
|
|
|
ds->path[0].dev = PCI_DEV(bdf);
|
|
|
|
ds->path[0].fn = PCI_FUNC(bdf);
|
|
|
|
|
|
|
|
return ds->length;
|
|
|
|
}
|
|
|
|
|
|
|
|
int acpi_create_dmar_ds_pci_br(struct acpi_ctx *ctx, pci_dev_t bdf)
|
|
|
|
{
|
|
|
|
return acpi_create_dmar_ds(ctx, SCOPE_PCI_SUB, 0, bdf);
|
|
|
|
}
|
|
|
|
|
|
|
|
int acpi_create_dmar_ds_pci(struct acpi_ctx *ctx, pci_dev_t bdf)
|
|
|
|
{
|
|
|
|
return acpi_create_dmar_ds(ctx, SCOPE_PCI_ENDPOINT, 0, bdf);
|
|
|
|
}
|
|
|
|
|
|
|
|
int acpi_create_dmar_ds_ioapic(struct acpi_ctx *ctx, uint enumeration_id,
|
|
|
|
pci_dev_t bdf)
|
|
|
|
{
|
|
|
|
return acpi_create_dmar_ds(ctx, SCOPE_IOAPIC, enumeration_id, bdf);
|
|
|
|
}
|
|
|
|
|
|
|
|
int acpi_create_dmar_ds_msi_hpet(struct acpi_ctx *ctx, uint enumeration_id,
|
|
|
|
pci_dev_t bdf)
|
|
|
|
{
|
|
|
|
return acpi_create_dmar_ds(ctx, SCOPE_MSI_HPET, enumeration_id, bdf);
|
|
|
|
}
|