[linux-block.git] / arch / x86 / boot / compressed / acpi.c

// SPDX-License-Identifier: GPL-2.0
#define BOOT_CTYPE_H
#include "misc.h"
#include "error.h"
#include "../string.h"
#include "efi.h"

#include <linux/numa.h>

/*
 * Longest parameter of 'acpi=' is 'copy_dsdt', plus an extra '\0'
 * for termination.
 */
#define MAX_ACPI_ARG_LENGTH 10

/*
 * Immovable memory regions representation. Max amount of memory regions is
 * MAX_NUMNODES*2.
 */
struct mem_vector immovable_mem[MAX_NUMNODES*2];

static acpi_physical_address
__efi_get_rsdp_addr(unsigned long cfg_tbl_pa, unsigned int cfg_tbl_len)
{
#ifdef CONFIG_EFI
	unsigned long rsdp_addr;
	int ret;

	/*
	 * Search EFI system tables for RSDP. Preferred is ACPI_20_TABLE_GUID to
	 * ACPI_TABLE_GUID because it has more features.
	 */
	rsdp_addr = efi_find_vendor_table(boot_params, cfg_tbl_pa, cfg_tbl_len,
					  ACPI_20_TABLE_GUID);
	if (rsdp_addr)
		return (acpi_physical_address)rsdp_addr;

	/* No ACPI_20_TABLE_GUID found, fallback to ACPI_TABLE_GUID. */
	rsdp_addr = efi_find_vendor_table(boot_params, cfg_tbl_pa, cfg_tbl_len,
					  ACPI_TABLE_GUID);
	if (rsdp_addr)
		return (acpi_physical_address)rsdp_addr;

	debug_putstr("Error getting RSDP address.\n");
#endif
	return 0;
}

static acpi_physical_address efi_get_rsdp_addr(void)
{
#ifdef CONFIG_EFI
	unsigned long cfg_tbl_pa = 0;
	unsigned int cfg_tbl_len;
	unsigned long systab_pa;
	unsigned int nr_tables;
	enum efi_type et;
	int ret;

	et = efi_get_type(boot_params);
	if (et == EFI_TYPE_NONE)
		return 0;

	systab_pa = efi_get_system_table(boot_params);
	if (!systab_pa)
		error("EFI support advertised, but unable to locate system table.");

	ret = efi_get_conf_table(boot_params, &cfg_tbl_pa, &cfg_tbl_len);
	if (ret || !cfg_tbl_pa)
		error("EFI config table not found.");

	return __efi_get_rsdp_addr(cfg_tbl_pa, cfg_tbl_len);
#else
	return 0;
#endif
}

static u8 compute_checksum(u8 *buffer, u32 length)
{
	u8 *end = buffer + length;
	u8 sum = 0;

	while (buffer < end)
		sum += *(buffer++);

	return sum;
}

/* Search a block of memory for the RSDP signature. */
static u8 *scan_mem_for_rsdp(u8 *start, u32 length)
{
	struct acpi_table_rsdp *rsdp;
	u8 *address, *end;

	end = start + length;

	/* Search from given start address for the requested length */
	for (address = start; address < end; address += ACPI_RSDP_SCAN_STEP) {
		/*
		 * Both RSDP signature and checksum must be correct.
		 * Note: Sometimes there exists more than one RSDP in memory;
		 * the valid RSDP has a valid checksum, all others have an
		 * invalid checksum.
		 */
		rsdp = (struct acpi_table_rsdp *)address;

		/* BAD Signature */
		if (!ACPI_VALIDATE_RSDP_SIG(rsdp->signature))
			continue;

		/* Check the standard checksum */
		if (compute_checksum((u8 *)rsdp, ACPI_RSDP_CHECKSUM_LENGTH))
			continue;

		/* Check extended checksum if table version >= 2 */
		if ((rsdp->revision >= 2) &&
		    (compute_checksum((u8 *)rsdp, ACPI_RSDP_XCHECKSUM_LENGTH)))
			continue;

		/* Signature and checksum valid, we have found a real RSDP */
		return address;
	}
	return NULL;
}

/* Search RSDP address in EBDA. */
static acpi_physical_address bios_get_rsdp_addr(void)
{
	unsigned long address;
	u8 *rsdp;

	/* Get the location of the Extended BIOS Data Area (EBDA) */
	address = *(u16 *)ACPI_EBDA_PTR_LOCATION;
	address <<= 4;

	/*
	 * Search EBDA paragraphs (EBDA is required to be a minimum of
	 * 1K length)
	 */
	if (address > 0x400) {
		rsdp = scan_mem_for_rsdp((u8 *)address, ACPI_EBDA_WINDOW_SIZE);
		if (rsdp)
			return (acpi_physical_address)(unsigned long)rsdp;
	}

	/* Search upper memory: 16-byte boundaries in E0000h-FFFFFh */
	rsdp = scan_mem_for_rsdp((u8 *) ACPI_HI_RSDP_WINDOW_BASE,
					ACPI_HI_RSDP_WINDOW_SIZE);
	if (rsdp)
		return (acpi_physical_address)(unsigned long)rsdp;

	return 0;
}

/* Return RSDP address on success, otherwise 0. */
acpi_physical_address get_rsdp_addr(void)
{
	acpi_physical_address pa;

	pa = boot_params->acpi_rsdp_addr;

	if (!pa)
		pa = efi_get_rsdp_addr();

	if (!pa)
		pa = bios_get_rsdp_addr();

	return pa;
}

#if defined(CONFIG_RANDOMIZE_BASE) && defined(CONFIG_MEMORY_HOTREMOVE)
/*
 * Max length of 64-bit hex address string is 19, prefix "0x" + 16 hex
 * digits, and '\0' for termination.
 */
#define MAX_ADDR_LEN 19

static unsigned long get_cmdline_acpi_rsdp(void)
{
	unsigned long addr = 0;

#ifdef CONFIG_KEXEC
	char val[MAX_ADDR_LEN] = { };
	int ret;

	ret = cmdline_find_option("acpi_rsdp", val, MAX_ADDR_LEN);
	if (ret < 0)
		return 0;

	if (boot_kstrtoul(val, 16, &addr))
		return 0;
#endif
	return addr;
}

/* Compute SRAT address from RSDP. */
static unsigned long get_acpi_srat_table(void)
{
	unsigned long root_table, acpi_table;
	struct acpi_table_header *header;
	struct acpi_table_rsdp *rsdp;
	u32 num_entries, size, len;
	char arg[10];
	u8 *entry;

	/*
	 * Check whether we were given an RSDP on the command line. We don't
	 * stash this in boot params because the kernel itself may have
	 * different ideas about whether to trust a command-line parameter.
	 */
	rsdp = (struct acpi_table_rsdp *)get_cmdline_acpi_rsdp();
	if (!rsdp)
		rsdp = (struct acpi_table_rsdp *)(long)
			boot_params->acpi_rsdp_addr;

	if (!rsdp)
		return 0;

	/* Get ACPI root table from RSDP.*/
	if (!(cmdline_find_option("acpi", arg, sizeof(arg)) == 4 &&
	    !strncmp(arg, "rsdt", 4)) &&
	    rsdp->xsdt_physical_address &&
	    rsdp->revision > 1) {
		root_table = rsdp->xsdt_physical_address;
		size = ACPI_XSDT_ENTRY_SIZE;
	} else {
		root_table = rsdp->rsdt_physical_address;
		size = ACPI_RSDT_ENTRY_SIZE;
	}

	if (!root_table)
		return 0;

	header = (struct acpi_table_header *)root_table;
	len = header->length;
	if (len < sizeof(struct acpi_table_header) + size)
		return 0;

	num_entries = (len - sizeof(struct acpi_table_header)) / size;
	entry = (u8 *)(root_table + sizeof(struct acpi_table_header));

	while (num_entries--) {
		if (size == ACPI_RSDT_ENTRY_SIZE)
			acpi_table = *(u32 *)entry;
		else
			acpi_table = *(u64 *)entry;

		if (acpi_table) {
			header = (struct acpi_table_header *)acpi_table;

			if (ACPI_COMPARE_NAMESEG(header->signature, ACPI_SIG_SRAT))
				return acpi_table;
		}
		entry += size;
	}
	return 0;
}

/**
 * count_immovable_mem_regions - Parse SRAT and cache the immovable
 * memory regions into the immovable_mem array.
 *
 * Return the number of immovable memory regions on success, 0 on failure:
 *
 * - Too many immovable memory regions
 * - ACPI off or no SRAT found
 * - No immovable memory region found.
 */
int count_immovable_mem_regions(void)
{
	unsigned long table_addr, table_end, table;
	struct acpi_subtable_header *sub_table;
	struct acpi_table_header *table_header;
	char arg[MAX_ACPI_ARG_LENGTH];
	int num = 0;

	if (cmdline_find_option("acpi", arg, sizeof(arg)) == 3 &&
	    !strncmp(arg, "off", 3))
		return 0;

	table_addr = get_acpi_srat_table();
	if (!table_addr)
		return 0;

	table_header = (struct acpi_table_header *)table_addr;
	table_end = table_addr + table_header->length;
	table = table_addr + sizeof(struct acpi_table_srat);

	while (table + sizeof(struct acpi_subtable_header) < table_end) {

		sub_table = (struct acpi_subtable_header *)table;
		if (!sub_table->length) {
			debug_putstr("Invalid zero length SRAT subtable.\n");
			return 0;
		}

		if (sub_table->type == ACPI_SRAT_TYPE_MEMORY_AFFINITY) {
			struct acpi_srat_mem_affinity *ma;

			ma = (struct acpi_srat_mem_affinity *)sub_table;
			if (!(ma->flags & ACPI_SRAT_MEM_HOT_PLUGGABLE) && ma->length) {
				immovable_mem[num].start = ma->base_address;
				immovable_mem[num].size = ma->length;
				num++;
			}

			if (num >= MAX_NUMNODES*2) {
				debug_putstr("Too many immovable memory regions, aborting.\n");
				return 0;
			}
		}
		table += sub_table->length;
	}
	return num;
}
#endif /* CONFIG_RANDOMIZE_BASE && CONFIG_MEMORY_HOTREMOVE */
Commit	Line	Data
3c98e71b CF	1	// SPDX-License-Identifier: GPL-2.0
	2	#define BOOT_CTYPE_H
	3	#include "misc.h"
	4	#include "error.h"
	5	#include "../string.h"
5dc91f2d	6	#include "efi.h"
3c98e71b	7
02a3e3cd	8	#include <linux/numa.h>
3c98e71b	9
02a3e3cd CF	10	/*
	11	* Longest parameter of 'acpi=' is 'copy_dsdt', plus an extra '\0'
	12	* for termination.
	13	*/
	14	#define MAX_ACPI_ARG_LENGTH 10
	15
	16	/*
	17	* Immovable memory regions representation. Max amount of memory regions is
	18	* MAX_NUMNODES*2.
	19	*/
	20	struct mem_vector immovable_mem[MAX_NUMNODES*2];
	21
0a23ebc6	22	static acpi_physical_address
dee602dd	23	__efi_get_rsdp_addr(unsigned long cfg_tbl_pa, unsigned int cfg_tbl_len)
33f0df8d	24	{
33f0df8d	25	#ifdef CONFIG_EFI
dee602dd MR	26	unsigned long rsdp_addr;
	27	int ret;
	28
	29	/*
	30	* Search EFI system tables for RSDP. Preferred is ACPI_20_TABLE_GUID to
	31	* ACPI_TABLE_GUID because it has more features.
	32	*/
	33	rsdp_addr = efi_find_vendor_table(boot_params, cfg_tbl_pa, cfg_tbl_len,
	34	ACPI_20_TABLE_GUID);
	35	if (rsdp_addr)
	36	return (acpi_physical_address)rsdp_addr;
	37
	38	/* No ACPI_20_TABLE_GUID found, fallback to ACPI_TABLE_GUID. */
	39	rsdp_addr = efi_find_vendor_table(boot_params, cfg_tbl_pa, cfg_tbl_len,
	40	ACPI_TABLE_GUID);
	41	if (rsdp_addr)
	42	return (acpi_physical_address)rsdp_addr;
	43
	44	debug_putstr("Error getting RSDP address.\n");
0a23ebc6	45	#endif
dee602dd	46	return 0;
0a23ebc6 JN	47	}
0a23ebc6 JN	48
0a23ebc6 JN	49	static acpi_physical_address efi_get_rsdp_addr(void)
	50	{
	51	#ifdef CONFIG_EFI
61c14ced MR	52	unsigned long cfg_tbl_pa = 0;
	53	unsigned int cfg_tbl_len;
	54	unsigned long systab_pa;
f9d230e8	55	unsigned int nr_tables;
7c4146e8	56	enum efi_type et;
61c14ced	57	int ret;
33f0df8d	58
7c4146e8	59	et = efi_get_type(boot_params);
dee602dd	60	if (et == EFI_TYPE_NONE)
33f0df8d	61	return 0;
33f0df8d	62
58f3e6b7 MR	63	systab_pa = efi_get_system_table(boot_params);
	64	if (!systab_pa)
	65	error("EFI support advertised, but unable to locate system table.");
33f0df8d	66
61c14ced MR	67	ret = efi_get_conf_table(boot_params, &cfg_tbl_pa, &cfg_tbl_len);
	68	if (ret \|\| !cfg_tbl_pa)
	69	error("EFI config table not found.");
33f0df8d	70
dee602dd	71	return __efi_get_rsdp_addr(cfg_tbl_pa, cfg_tbl_len);
0a23ebc6 JN	72	#else
0a23ebc6 JN	73	return 0;
33f0df8d	74	#endif
33f0df8d	75	}
93a209aa CF	76
	77	static u8 compute_checksum(u8 *buffer, u32 length)
	78	{
	79	u8 *end = buffer + length;
	80	u8 sum = 0;
	81
	82	while (buffer < end)
	83	sum += *(buffer++);
	84
	85	return sum;
	86	}
	87
	88	/* Search a block of memory for the RSDP signature. */
	89	static u8 scan_mem_for_rsdp(u8 start, u32 length)
	90	{
	91	struct acpi_table_rsdp *rsdp;
	92	u8 address, end;
	93
	94	end = start + length;
	95
	96	/* Search from given start address for the requested length */
	97	for (address = start; address < end; address += ACPI_RSDP_SCAN_STEP) {
	98	/*
	99	* Both RSDP signature and checksum must be correct.
	100	* Note: Sometimes there exists more than one RSDP in memory;
	101	* the valid RSDP has a valid checksum, all others have an
	102	* invalid checksum.
	103	*/
	104	rsdp = (struct acpi_table_rsdp *)address;
	105
	106	/* BAD Signature */
	107	if (!ACPI_VALIDATE_RSDP_SIG(rsdp->signature))
	108	continue;
	109
	110	/* Check the standard checksum */
	111	if (compute_checksum((u8 *)rsdp, ACPI_RSDP_CHECKSUM_LENGTH))
	112	continue;
	113
	114	/* Check extended checksum if table version >= 2 */
	115	if ((rsdp->revision >= 2) &&
	116	(compute_checksum((u8 *)rsdp, ACPI_RSDP_XCHECKSUM_LENGTH)))
	117	continue;
	118
	119	/* Signature and checksum valid, we have found a real RSDP */
	120	return address;
	121	}
	122	return NULL;
	123	}
	124
	125	/* Search RSDP address in EBDA. */
	126	static acpi_physical_address bios_get_rsdp_addr(void)
	127	{
	128	unsigned long address;
	129	u8 *rsdp;
	130
	131	/* Get the location of the Extended BIOS Data Area (EBDA) */
	132	address = (u16 )ACPI_EBDA_PTR_LOCATION;
	133	address <<= 4;
	134
	135	/*
	136	* Search EBDA paragraphs (EBDA is required to be a minimum of
	137	* 1K length)
	138	*/
	139	if (address > 0x400) {
140	rsdp = scan_mem_for_rsdp((u8 *)address, ACPI_EBDA_WINDOW_SIZE);
141	if (rsdp)
142	return (acpi_physical_address)(unsigned long)rsdp;
143	}
144
145	/* Search upper memory: 16-byte boundaries in E0000h-FFFFFh */
146	rsdp = scan_mem_for_rsdp((u8 *) ACPI_HI_RSDP_WINDOW_BASE,
147	ACPI_HI_RSDP_WINDOW_SIZE);
148	if (rsdp)
149	return (acpi_physical_address)(unsigned long)rsdp;
150
151	return 0;
152	}
3a63f70b CF	153
	154	/* Return RSDP address on success, otherwise 0. */
	155	acpi_physical_address get_rsdp_addr(void)
	156	{
	157	acpi_physical_address pa;
	158
41fa1ee9	159	pa = boot_params->acpi_rsdp_addr;
3a63f70b CF	160
	161	if (!pa)
	162	pa = efi_get_rsdp_addr();
	163
	164	if (!pa)
	165	pa = bios_get_rsdp_addr();
	166
	167	return pa;
	168	}
02a3e3cd CF	169
02a3e3cd CF	170	#if defined(CONFIG_RANDOMIZE_BASE) && defined(CONFIG_MEMORY_HOTREMOVE)
228d1200 ZD	171	/*
	172	* Max length of 64-bit hex address string is 19, prefix "0x" + 16 hex
	173	* digits, and '\0' for termination.
	174	*/
	175	#define MAX_ADDR_LEN 19
	176
40ba9309	177	static unsigned long get_cmdline_acpi_rsdp(void)
228d1200	178	{
40ba9309	179	unsigned long addr = 0;
228d1200 ZD	180
	181	#ifdef CONFIG_KEXEC
	182	char val[MAX_ADDR_LEN] = { };
	183	int ret;
	184
	185	ret = cmdline_find_option("acpi_rsdp", val, MAX_ADDR_LEN);
	186	if (ret < 0)
	187	return 0;
	188
40ba9309	189	if (boot_kstrtoul(val, 16, &addr))
228d1200 ZD	190	return 0;
	191	#endif
	192	return addr;
	193	}
	194
02a3e3cd CF	195	/* Compute SRAT address from RSDP. */
	196	static unsigned long get_acpi_srat_table(void)
	197	{
	198	unsigned long root_table, acpi_table;
	199	struct acpi_table_header *header;
	200	struct acpi_table_rsdp *rsdp;
	201	u32 num_entries, size, len;
	202	char arg[10];
	203	u8 *entry;
	204
41fa1ee9 JB	205	/*
	206	* Check whether we were given an RSDP on the command line. We don't
	207	* stash this in boot params because the kernel itself may have
	208	* different ideas about whether to trust a command-line parameter.
	209	*/
	210	rsdp = (struct acpi_table_rsdp *)get_cmdline_acpi_rsdp();
41fa1ee9 JB	211	if (!rsdp)
	212	rsdp = (struct acpi_table_rsdp *)(long)
	213	boot_params->acpi_rsdp_addr;
	214
02a3e3cd CF	215	if (!rsdp)
	216	return 0;
	217
	218	/* Get ACPI root table from RSDP.*/
	219	if (!(cmdline_find_option("acpi", arg, sizeof(arg)) == 4 &&
	220	!strncmp(arg, "rsdt", 4)) &&
	221	rsdp->xsdt_physical_address &&
	222	rsdp->revision > 1) {
	223	root_table = rsdp->xsdt_physical_address;
	224	size = ACPI_XSDT_ENTRY_SIZE;
	225	} else {
	226	root_table = rsdp->rsdt_physical_address;
	227	size = ACPI_RSDT_ENTRY_SIZE;
	228	}
	229
	230	if (!root_table)
	231	return 0;
	232
	233	header = (struct acpi_table_header *)root_table;
	234	len = header->length;
	235	if (len < sizeof(struct acpi_table_header) + size)
	236	return 0;
	237
	238	num_entries = (len - sizeof(struct acpi_table_header)) / size;
	239	entry = (u8 *)(root_table + sizeof(struct acpi_table_header));
	240
	241	while (num_entries--) {
	242	if (size == ACPI_RSDT_ENTRY_SIZE)
	243	acpi_table = (u32 )entry;
	244	else
	245	acpi_table = (u64 )entry;
	246
	247	if (acpi_table) {
	248	header = (struct acpi_table_header *)acpi_table;
	249
5599fb69	250	if (ACPI_COMPARE_NAMESEG(header->signature, ACPI_SIG_SRAT))
02a3e3cd CF	251	return acpi_table;
	252	}
	253	entry += size;
	254	}
	255	return 0;
	256	}
	257
	258	/**
	259	* count_immovable_mem_regions - Parse SRAT and cache the immovable
	260	* memory regions into the immovable_mem array.
	261	*
	262	* Return the number of immovable memory regions on success, 0 on failure:
	263	*
	264	* - Too many immovable memory regions
	265	* - ACPI off or no SRAT found
	266	* - No immovable memory region found.
	267	*/
	268	int count_immovable_mem_regions(void)
	269	{
	270	unsigned long table_addr, table_end, table;
	271	struct acpi_subtable_header *sub_table;
	272	struct acpi_table_header *table_header;
	273	char arg[MAX_ACPI_ARG_LENGTH];
	274	int num = 0;
	275
	276	if (cmdline_find_option("acpi", arg, sizeof(arg)) == 3 &&
	277	!strncmp(arg, "off", 3))
	278	return 0;
	279
	280	table_addr = get_acpi_srat_table();
	281	if (!table_addr)
	282	return 0;
	283
	284	table_header = (struct acpi_table_header *)table_addr;
	285	table_end = table_addr + table_header->length;
	286	table = table_addr + sizeof(struct acpi_table_srat);
	287
	288	while (table + sizeof(struct acpi_subtable_header) < table_end) {
2b73ea37	289
02a3e3cd	290	sub_table = (struct acpi_subtable_header *)table;
2b73ea37 SC	291	if (!sub_table->length) {
	292	debug_putstr("Invalid zero length SRAT subtable.\n");
	293	return 0;
	294	}
	295
02a3e3cd CF	296	if (sub_table->type == ACPI_SRAT_TYPE_MEMORY_AFFINITY) {
	297	struct acpi_srat_mem_affinity *ma;
	298
	299	ma = (struct acpi_srat_mem_affinity *)sub_table;
	300	if (!(ma->flags & ACPI_SRAT_MEM_HOT_PLUGGABLE) && ma->length) {
	301	immovable_mem[num].start = ma->base_address;
	302	immovable_mem[num].size = ma->length;
	303	num++;
	304	}
	305
	306	if (num >= MAX_NUMNODES*2) {
	307	debug_putstr("Too many immovable memory regions, aborting.\n");
	308	return 0;
	309	}
	310	}
	311	table += sub_table->length;
	312	}
	313	return num;
	314	}
	315	#endif /* CONFIG_RANDOMIZE_BASE && CONFIG_MEMORY_HOTREMOVE */