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