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 <linux/numa.h>
   9
  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
  22 static acpi_physical_address
  23 __efi_get_rsdp_addr(unsigned long cfg_tbl_pa, unsigned int cfg_tbl_len)
  24 {
  25 #ifdef CONFIG_EFI
  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");
  45 #endif
  46         return 0;
  47 }
  48
  49 static acpi_physical_address efi_get_rsdp_addr(void)
  50 {
  51 #ifdef CONFIG_EFI
  52         unsigned long cfg_tbl_pa = 0;
  53         unsigned int cfg_tbl_len;
  54         unsigned long systab_pa;
  55         unsigned int nr_tables;
  56         enum efi_type et;
  57         int ret;
  58
  59         et = efi_get_type(boot_params);
  60         if (et == EFI_TYPE_NONE)
  61                 return 0;
  62
  63         systab_pa = efi_get_system_table(boot_params);
  64         if (!systab_pa)
  65                 error("EFI support advertised, but unable to locate system table.");
  66
  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.");
  70
  71         return __efi_get_rsdp_addr(cfg_tbl_pa, cfg_tbl_len);
  72 #else
  73         return 0;
  74 #endif
  75 }
  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 }
 153
 154 /* Return RSDP address on success, otherwise 0. */
 155 acpi_physical_address get_rsdp_addr(void)
 156 {
 157         acpi_physical_address pa;
 158
 159         pa = boot_params->acpi_rsdp_addr;
 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 }
 169
 170 #if defined(CONFIG_RANDOMIZE_BASE) && defined(CONFIG_MEMORY_HOTREMOVE)
 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
 177 static unsigned long get_cmdline_acpi_rsdp(void)
 178 {
 179         unsigned long addr = 0;
 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
 189         if (boot_kstrtoul(val, 16, &addr))
 190                 return 0;
 191 #endif
 192         return addr;
 193 }
 194
 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
 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();
 211         if (!rsdp)
 212                 rsdp = (struct acpi_table_rsdp *)(long)
 213                         boot_params->acpi_rsdp_addr;
 214
 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
 250                         if (ACPI_COMPARE_NAMESEG(header->signature, ACPI_SIG_SRAT))
 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) {
 289
 290                 sub_table = (struct acpi_subtable_header *)table;
 291                 if (!sub_table->length) {
 292                         debug_putstr("Invalid zero length SRAT subtable.\n");
 293                         return 0;
 294                 }
 295
 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 */