LXR linux/arch/x86/boot/compressed/acpi.c

   1// SPDX-License-Identifier: GPL-2.0
   2#define BOOT_CTYPE_H
   3#include "misc.h"
   4#include "error.h"
   5#include "../string.h"
   6
   7#include <linux/numa.h>
   8#include <linux/efi.h>
   9#include <asm/efi.h>
  10
  11/*
  12 * Longest parameter of 'acpi=' is 'copy_dsdt', plus an extra '\0'
  13 * for termination.
  14 */
  15#define MAX_ACPI_ARG_LENGTH 10
  16
  17/*
  18 * Immovable memory regions representation. Max amount of memory regions is
  19 * MAX_NUMNODES*2.
  20 */
  21struct mem_vector immovable_mem[MAX_NUMNODES*2];
  22
  23/*
  24 * Search EFI system tables for RSDP.  If both ACPI_20_TABLE_GUID and
  25 * ACPI_TABLE_GUID are found, take the former, which has more features.
  26 */
  27static acpi_physical_address
  28__efi_get_rsdp_addr(unsigned long config_tables, unsigned int nr_tables,
  29                    bool efi_64)
  30{
  31        acpi_physical_address rsdp_addr = 0;
  32
  33#ifdef CONFIG_EFI
  34        int i;
  35
  36        /* Get EFI tables from systab. */
  37        for (i = 0; i < nr_tables; i++) {
  38                acpi_physical_address table;
  39                efi_guid_t guid;
  40
  41                if (efi_64) {
  42                        efi_config_table_64_t *tbl = (efi_config_table_64_t *)config_tables + i;
  43
  44                        guid  = tbl->guid;
  45                        table = tbl->table;
  46
  47                        if (!IS_ENABLED(CONFIG_X86_64) && table >> 32) {
  48                                debug_putstr("Error getting RSDP address: EFI config table located above 4GB.\n");
  49                                return 0;
  50                        }
  51                } else {
  52                        efi_config_table_32_t *tbl = (efi_config_table_32_t *)config_tables + i;
  53
  54                        guid  = tbl->guid;
  55                        table = tbl->table;
  56                }
  57
  58                if (!(efi_guidcmp(guid, ACPI_TABLE_GUID)))
  59                        rsdp_addr = table;
  60                else if (!(efi_guidcmp(guid, ACPI_20_TABLE_GUID)))
  61                        return table;
  62        }
  63#endif
  64        return rsdp_addr;
  65}
  66
  67/* EFI/kexec support is 64-bit only. */
  68#ifdef CONFIG_X86_64
  69static struct efi_setup_data *get_kexec_setup_data_addr(void)
  70{
  71        struct setup_data *data;
  72        u64 pa_data;
  73
  74        pa_data = boot_params->hdr.setup_data;
  75        while (pa_data) {
  76                data = (struct setup_data *)pa_data;
  77                if (data->type == SETUP_EFI)
  78                        return (struct efi_setup_data *)(pa_data + sizeof(struct setup_data));
  79
  80                pa_data = data->next;
  81        }
  82        return NULL;
  83}
  84
  85static acpi_physical_address kexec_get_rsdp_addr(void)
  86{
  87        efi_system_table_64_t *systab;
  88        struct efi_setup_data *esd;
  89        struct efi_info *ei;
  90        char *sig;
  91
  92        esd = (struct efi_setup_data *)get_kexec_setup_data_addr();
  93        if (!esd)
  94                return 0;
  95
  96        if (!esd->tables) {
  97                debug_putstr("Wrong kexec SETUP_EFI data.\n");
  98                return 0;
  99        }
 100
 101        ei = &boot_params->efi_info;
 102        sig = (char *)&ei->efi_loader_signature;
 103        if (strncmp(sig, EFI64_LOADER_SIGNATURE, 4)) {
 104                debug_putstr("Wrong kexec EFI loader signature.\n");
 105                return 0;
 106        }
 107
 108        /* Get systab from boot params. */
 109        systab = (efi_system_table_64_t *) (ei->efi_systab | ((__u64)ei->efi_systab_hi << 32));
 110        if (!systab)
 111                error("EFI system table not found in kexec boot_params.");
 112
 113        return __efi_get_rsdp_addr((unsigned long)esd->tables, systab->nr_tables, true);
 114}
 115#else
 116static acpi_physical_address kexec_get_rsdp_addr(void) { return 0; }
 117#endif /* CONFIG_X86_64 */
 118
 119static acpi_physical_address efi_get_rsdp_addr(void)
 120{
 121#ifdef CONFIG_EFI
 122        unsigned long systab, config_tables;
 123        unsigned int nr_tables;
 124        struct efi_info *ei;
 125        bool efi_64;
 126        char *sig;
 127
 128        ei = &boot_params->efi_info;
 129        sig = (char *)&ei->efi_loader_signature;
 130
 131        if (!strncmp(sig, EFI64_LOADER_SIGNATURE, 4)) {
 132                efi_64 = true;
 133        } else if (!strncmp(sig, EFI32_LOADER_SIGNATURE, 4)) {
 134                efi_64 = false;
 135        } else {
 136                debug_putstr("Wrong EFI loader signature.\n");
 137                return 0;
 138        }
 139
 140        /* Get systab from boot params. */
 141#ifdef CONFIG_X86_64
 142        systab = ei->efi_systab | ((__u64)ei->efi_systab_hi << 32);
 143#else
 144        if (ei->efi_systab_hi || ei->efi_memmap_hi) {
 145                debug_putstr("Error getting RSDP address: EFI system table located above 4GB.\n");
 146                return 0;
 147        }
 148        systab = ei->efi_systab;
 149#endif
 150        if (!systab)
 151                error("EFI system table not found.");
 152
 153        /* Handle EFI bitness properly */
 154        if (efi_64) {
 155                efi_system_table_64_t *stbl = (efi_system_table_64_t *)systab;
 156
 157                config_tables   = stbl->tables;
 158                nr_tables       = stbl->nr_tables;
 159        } else {
 160                efi_system_table_32_t *stbl = (efi_system_table_32_t *)systab;
 161
 162                config_tables   = stbl->tables;
 163                nr_tables       = stbl->nr_tables;
 164        }
 165
 166        if (!config_tables)
 167                error("EFI config tables not found.");
 168
 169        return __efi_get_rsdp_addr(config_tables, nr_tables, efi_64);
 170#else
 171        return 0;
 172#endif
 173}
 174
 175static u8 compute_checksum(u8 *buffer, u32 length)
 176{
 177        u8 *end = buffer + length;
 178        u8 sum = 0;
 179
 180        while (buffer < end)
 181                sum += *(buffer++);
 182
 183        return sum;
 184}
 185
 186/* Search a block of memory for the RSDP signature. */
 187static u8 *scan_mem_for_rsdp(u8 *start, u32 length)
 188{
 189        struct acpi_table_rsdp *rsdp;
 190        u8 *address, *end;
 191
 192        end = start + length;
 193
 194        /* Search from given start address for the requested length */
 195        for (address = start; address < end; address += ACPI_RSDP_SCAN_STEP) {
 196                /*
 197                 * Both RSDP signature and checksum must be correct.
 198                 * Note: Sometimes there exists more than one RSDP in memory;
 199                 * the valid RSDP has a valid checksum, all others have an
 200                 * invalid checksum.
 201                 */
 202                rsdp = (struct acpi_table_rsdp *)address;
 203
 204                /* BAD Signature */
 205                if (!ACPI_VALIDATE_RSDP_SIG(rsdp->signature))
 206                        continue;
 207
 208                /* Check the standard checksum */
 209                if (compute_checksum((u8 *)rsdp, ACPI_RSDP_CHECKSUM_LENGTH))
 210                        continue;
 211
 212                /* Check extended checksum if table version >= 2 */
 213                if ((rsdp->revision >= 2) &&
 214                    (compute_checksum((u8 *)rsdp, ACPI_RSDP_XCHECKSUM_LENGTH)))
 215                        continue;
 216
 217                /* Signature and checksum valid, we have found a real RSDP */
 218                return address;
 219        }
 220        return NULL;
 221}
 222
 223/* Search RSDP address in EBDA. */
 224static acpi_physical_address bios_get_rsdp_addr(void)
 225{
 226        unsigned long address;
 227        u8 *rsdp;
 228
 229        /* Get the location of the Extended BIOS Data Area (EBDA) */
 230        address = *(u16 *)ACPI_EBDA_PTR_LOCATION;
 231        address <<= 4;
 232
 233        /*
 234         * Search EBDA paragraphs (EBDA is required to be a minimum of
 235         * 1K length)
 236         */
 237        if (address > 0x400) {
 238                rsdp = scan_mem_for_rsdp((u8 *)address, ACPI_EBDA_WINDOW_SIZE);
 239                if (rsdp)
 240                        return (acpi_physical_address)(unsigned long)rsdp;
 241        }
 242
 243        /* Search upper memory: 16-byte boundaries in E0000h-FFFFFh */
 244        rsdp = scan_mem_for_rsdp((u8 *) ACPI_HI_RSDP_WINDOW_BASE,
 245                                        ACPI_HI_RSDP_WINDOW_SIZE);
 246        if (rsdp)
 247                return (acpi_physical_address)(unsigned long)rsdp;
 248
 249        return 0;
 250}
 251
 252/* Return RSDP address on success, otherwise 0. */
 253acpi_physical_address get_rsdp_addr(void)
 254{
 255        acpi_physical_address pa;
 256
 257        pa = boot_params->acpi_rsdp_addr;
 258
 259        /*
 260         * Try to get EFI data from setup_data. This can happen when we're a
 261         * kexec'ed kernel and kexec(1) has passed all the required EFI info to
 262         * us.
 263         */
 264        if (!pa)
 265                pa = kexec_get_rsdp_addr();
 266
 267        if (!pa)
 268                pa = efi_get_rsdp_addr();
 269
 270        if (!pa)
 271                pa = bios_get_rsdp_addr();
 272
 273        return pa;
 274}
 275
 276#if defined(CONFIG_RANDOMIZE_BASE) && defined(CONFIG_MEMORY_HOTREMOVE)
 277/*
 278 * Max length of 64-bit hex address string is 19, prefix "0x" + 16 hex
 279 * digits, and '\0' for termination.
 280 */
 281#define MAX_ADDR_LEN 19
 282
 283static unsigned long get_cmdline_acpi_rsdp(void)
 284{
 285        unsigned long addr = 0;
 286
 287#ifdef CONFIG_KEXEC
 288        char val[MAX_ADDR_LEN] = { };
 289        int ret;
 290
 291        ret = cmdline_find_option("acpi_rsdp", val, MAX_ADDR_LEN);
 292        if (ret < 0)
 293                return 0;
 294
 295        if (boot_kstrtoul(val, 16, &addr))
 296                return 0;
 297#endif
 298        return addr;
 299}
 300
 301/* Compute SRAT address from RSDP. */
 302static unsigned long get_acpi_srat_table(void)
 303{
 304        unsigned long root_table, acpi_table;
 305        struct acpi_table_header *header;
 306        struct acpi_table_rsdp *rsdp;
 307        u32 num_entries, size, len;
 308        char arg[10];
 309        u8 *entry;
 310
 311        /*
 312         * Check whether we were given an RSDP on the command line. We don't
 313         * stash this in boot params because the kernel itself may have
 314         * different ideas about whether to trust a command-line parameter.
 315         */
 316        rsdp = (struct acpi_table_rsdp *)get_cmdline_acpi_rsdp();
 317        if (!rsdp)
 318                rsdp = (struct acpi_table_rsdp *)(long)
 319                        boot_params->acpi_rsdp_addr;
 320
 321        if (!rsdp)
 322                return 0;
 323
 324        /* Get ACPI root table from RSDP.*/
 325        if (!(cmdline_find_option("acpi", arg, sizeof(arg)) == 4 &&
 326            !strncmp(arg, "rsdt", 4)) &&
 327            rsdp->xsdt_physical_address &&
 328            rsdp->revision > 1) {
 329                root_table = rsdp->xsdt_physical_address;
 330                size = ACPI_XSDT_ENTRY_SIZE;
 331        } else {
 332                root_table = rsdp->rsdt_physical_address;
 333                size = ACPI_RSDT_ENTRY_SIZE;
 334        }
 335
 336        if (!root_table)
 337                return 0;
 338
 339        header = (struct acpi_table_header *)root_table;
 340        len = header->length;
 341        if (len < sizeof(struct acpi_table_header) + size)
 342                return 0;
 343
 344        num_entries = (len - sizeof(struct acpi_table_header)) / size;
 345        entry = (u8 *)(root_table + sizeof(struct acpi_table_header));
 346
 347        while (num_entries--) {
 348                if (size == ACPI_RSDT_ENTRY_SIZE)
 349                        acpi_table = *(u32 *)entry;
 350                else
 351                        acpi_table = *(u64 *)entry;
 352
 353                if (acpi_table) {
 354                        header = (struct acpi_table_header *)acpi_table;
 355
 356                        if (ACPI_COMPARE_NAMESEG(header->signature, ACPI_SIG_SRAT))
 357                                return acpi_table;
 358                }
 359                entry += size;
 360        }
 361        return 0;
 362}
 363
 364/**
 365 * count_immovable_mem_regions - Parse SRAT and cache the immovable
 366 * memory regions into the immovable_mem array.
 367 *
 368 * Return the number of immovable memory regions on success, 0 on failure:
 369 *
 370 * - Too many immovable memory regions
 371 * - ACPI off or no SRAT found
 372 * - No immovable memory region found.
 373 */
 374int count_immovable_mem_regions(void)
 375{
 376        unsigned long table_addr, table_end, table;
 377        struct acpi_subtable_header *sub_table;
 378        struct acpi_table_header *table_header;
 379        char arg[MAX_ACPI_ARG_LENGTH];
 380        int num = 0;
 381
 382        if (cmdline_find_option("acpi", arg, sizeof(arg)) == 3 &&
 383            !strncmp(arg, "off", 3))
 384                return 0;
 385
 386        table_addr = get_acpi_srat_table();
 387        if (!table_addr)
 388                return 0;
 389
 390        table_header = (struct acpi_table_header *)table_addr;
 391        table_end = table_addr + table_header->length;
 392        table = table_addr + sizeof(struct acpi_table_srat);
 393
 394        while (table + sizeof(struct acpi_subtable_header) < table_end) {
 395
 396                sub_table = (struct acpi_subtable_header *)table;
 397                if (!sub_table->length) {
 398                        debug_putstr("Invalid zero length SRAT subtable.\n");
 399                        return 0;
 400                }
 401
 402                if (sub_table->type == ACPI_SRAT_TYPE_MEMORY_AFFINITY) {
 403                        struct acpi_srat_mem_affinity *ma;
 404
 405                        ma = (struct acpi_srat_mem_affinity *)sub_table;
 406                        if (!(ma->flags & ACPI_SRAT_MEM_HOT_PLUGGABLE) && ma->length) {
 407                                immovable_mem[num].start = ma->base_address;
 408                                immovable_mem[num].size = ma->length;
 409                                num++;
 410                        }
 411
 412                        if (num >= MAX_NUMNODES*2) {
 413                                debug_putstr("Too many immovable memory regions, aborting.\n");
 414                                return 0;
 415                        }
 416                }
 417                table += sub_table->length;
 418        }
 419        return num;
 420}
 421#endif /* CONFIG_RANDOMIZE_BASE && CONFIG_MEMORY_HOTREMOVE */
 422