1// SPDX-License-Identifier: GPL-2.0-or-later 2/* 3 * acpi_tables.c - ACPI Boot-Time Table Parsing 4 * 5 * Copyright (C) 2001 Paul Diefenbaugh <paul.s.diefenbaugh@intel.com> 6 */ 7 8/* Uncomment next line to get verbose printout */ 9/* #define DEBUG */ 10#define pr_fmt(fmt) "ACPI: " fmt 11 12#include <linux/init.h> 13#include <linux/kernel.h> 14#include <linux/smp.h> 15#include <linux/string.h> 16#include <linux/types.h> 17#include <linux/irq.h> 18#include <linux/errno.h> 19#include <linux/acpi.h> 20#include <linux/memblock.h> 21#include <linux/earlycpio.h> 22#include <linux/initrd.h> 23#include <linux/security.h> 24#include <linux/kmemleak.h> 25#include "internal.h" 26 27#ifdef CONFIG_ACPI_CUSTOM_DSDT 28#include CONFIG_ACPI_CUSTOM_DSDT_FILE 29#endif 30 31#define ACPI_MAX_TABLES 128 32 33static char *mps_inti_flags_polarity[] = { "dfl", "high", "res", "low" }; 34static char *mps_inti_flags_trigger[] = { "dfl", "edge", "res", "level" }; 35 36static struct acpi_table_desc initial_tables[ACPI_MAX_TABLES] __initdata; 37 38static int acpi_apic_instance __initdata_or_acpilib; 39 40enum acpi_subtable_type { 41 ACPI_SUBTABLE_COMMON, 42 ACPI_SUBTABLE_HMAT, 43 ACPI_SUBTABLE_PRMT, 44 ACPI_SUBTABLE_CEDT, 45}; 46 47struct acpi_subtable_entry { 48 union acpi_subtable_headers *hdr; 49 enum acpi_subtable_type type; 50}; 51 52/* 53 * Disable table checksum verification for the early stage due to the size 54 * limitation of the current x86 early mapping implementation. 55 */ 56static bool acpi_verify_table_checksum __initdata_or_acpilib = false; 57 58void acpi_table_print_madt_entry(struct acpi_subtable_header *header) 59{ 60 if (!header) 61 return; 62 63 switch (header->type) { 64 65 case ACPI_MADT_TYPE_LOCAL_APIC: 66 { 67 struct acpi_madt_local_apic *p = 68 (struct acpi_madt_local_apic *)header; 69 pr_debug("LAPIC (acpi_id[0x%02x] lapic_id[0x%02x] %s)\n", 70 p->processor_id, p->id, 71 (p->lapic_flags & ACPI_MADT_ENABLED) ? "enabled" : "disabled"); 72 } 73 break; 74 75 case ACPI_MADT_TYPE_LOCAL_X2APIC: 76 { 77 struct acpi_madt_local_x2apic *p = 78 (struct acpi_madt_local_x2apic *)header; 79 pr_debug("X2APIC (apic_id[0x%02x] uid[0x%02x] %s)\n", 80 p->local_apic_id, p->uid, 81 (p->lapic_flags & ACPI_MADT_ENABLED) ? "enabled" : "disabled"); 82 } 83 break; 84 85 case ACPI_MADT_TYPE_IO_APIC: 86 { 87 struct acpi_madt_io_apic *p = 88 (struct acpi_madt_io_apic *)header; 89 pr_debug("IOAPIC (id[0x%02x] address[0x%08x] gsi_base[%d])\n", 90 p->id, p->address, p->global_irq_base); 91 } 92 break; 93 94 case ACPI_MADT_TYPE_INTERRUPT_OVERRIDE: 95 { 96 struct acpi_madt_interrupt_override *p = 97 (struct acpi_madt_interrupt_override *)header; 98 pr_info("INT_SRC_OVR (bus %d bus_irq %d global_irq %d %s %s)\n", 99 p->bus, p->source_irq, p->global_irq, 100 mps_inti_flags_polarity[p->inti_flags & ACPI_MADT_POLARITY_MASK], 101 mps_inti_flags_trigger[(p->inti_flags & ACPI_MADT_TRIGGER_MASK) >> 2]); 102 if (p->inti_flags & 103 ~(ACPI_MADT_POLARITY_MASK | ACPI_MADT_TRIGGER_MASK)) 104 pr_info("INT_SRC_OVR unexpected reserved flags: 0x%x\n", 105 p->inti_flags & 106 ~(ACPI_MADT_POLARITY_MASK | ACPI_MADT_TRIGGER_MASK)); 107 } 108 break; 109 110 case ACPI_MADT_TYPE_NMI_SOURCE: 111 { 112 struct acpi_madt_nmi_source *p = 113 (struct acpi_madt_nmi_source *)header; 114 pr_info("NMI_SRC (%s %s global_irq %d)\n", 115 mps_inti_flags_polarity[p->inti_flags & ACPI_MADT_POLARITY_MASK], 116 mps_inti_flags_trigger[(p->inti_flags & ACPI_MADT_TRIGGER_MASK) >> 2], 117 p->global_irq); 118 } 119 break; 120 121 case ACPI_MADT_TYPE_LOCAL_APIC_NMI: 122 { 123 struct acpi_madt_local_apic_nmi *p = 124 (struct acpi_madt_local_apic_nmi *)header; 125 pr_info("LAPIC_NMI (acpi_id[0x%02x] %s %s lint[0x%x])\n", 126 p->processor_id, 127 mps_inti_flags_polarity[p->inti_flags & ACPI_MADT_POLARITY_MASK ], 128 mps_inti_flags_trigger[(p->inti_flags & ACPI_MADT_TRIGGER_MASK) >> 2], 129 p->lint); 130 } 131 break; 132 133 case ACPI_MADT_TYPE_LOCAL_X2APIC_NMI: 134 { 135 u16 polarity, trigger; 136 struct acpi_madt_local_x2apic_nmi *p = 137 (struct acpi_madt_local_x2apic_nmi *)header; 138 139 polarity = p->inti_flags & ACPI_MADT_POLARITY_MASK; 140 trigger = (p->inti_flags & ACPI_MADT_TRIGGER_MASK) >> 2; 141 142 pr_info("X2APIC_NMI (uid[0x%02x] %s %s lint[0x%x])\n", 143 p->uid, 144 mps_inti_flags_polarity[polarity], 145 mps_inti_flags_trigger[trigger], 146 p->lint); 147 } 148 break; 149 150 case ACPI_MADT_TYPE_LOCAL_APIC_OVERRIDE: 151 { 152 struct acpi_madt_local_apic_override *p = 153 (struct acpi_madt_local_apic_override *)header; 154 pr_info("LAPIC_ADDR_OVR (address[0x%llx])\n", 155 p->address); 156 } 157 break; 158 159 case ACPI_MADT_TYPE_IO_SAPIC: 160 { 161 struct acpi_madt_io_sapic *p = 162 (struct acpi_madt_io_sapic *)header; 163 pr_debug("IOSAPIC (id[0x%x] address[%p] gsi_base[%d])\n", 164 p->id, (void *)(unsigned long)p->address, 165 p->global_irq_base); 166 } 167 break; 168 169 case ACPI_MADT_TYPE_LOCAL_SAPIC: 170 { 171 struct acpi_madt_local_sapic *p = 172 (struct acpi_madt_local_sapic *)header; 173 pr_debug("LSAPIC (acpi_id[0x%02x] lsapic_id[0x%02x] lsapic_eid[0x%02x] %s)\n", 174 p->processor_id, p->id, p->eid, 175 (p->lapic_flags & ACPI_MADT_ENABLED) ? "enabled" : "disabled"); 176 } 177 break; 178 179 case ACPI_MADT_TYPE_INTERRUPT_SOURCE: 180 { 181 struct acpi_madt_interrupt_source *p = 182 (struct acpi_madt_interrupt_source *)header; 183 pr_info("PLAT_INT_SRC (%s %s type[0x%x] id[0x%04x] eid[0x%x] iosapic_vector[0x%x] global_irq[0x%x]\n", 184 mps_inti_flags_polarity[p->inti_flags & ACPI_MADT_POLARITY_MASK], 185 mps_inti_flags_trigger[(p->inti_flags & ACPI_MADT_TRIGGER_MASK) >> 2], 186 p->type, p->id, p->eid, p->io_sapic_vector, 187 p->global_irq); 188 } 189 break; 190 191 case ACPI_MADT_TYPE_GENERIC_INTERRUPT: 192 { 193 struct acpi_madt_generic_interrupt *p = 194 (struct acpi_madt_generic_interrupt *)header; 195 pr_debug("GICC (acpi_id[0x%04x] address[%llx] MPIDR[0x%llx] %s)\n", 196 p->uid, p->base_address, 197 p->arm_mpidr, 198 (p->flags & ACPI_MADT_ENABLED) ? "enabled" : "disabled"); 199 200 } 201 break; 202 203 case ACPI_MADT_TYPE_GENERIC_DISTRIBUTOR: 204 { 205 struct acpi_madt_generic_distributor *p = 206 (struct acpi_madt_generic_distributor *)header; 207 pr_debug("GIC Distributor (gic_id[0x%04x] address[%llx] gsi_base[%d])\n", 208 p->gic_id, p->base_address, 209 p->global_irq_base); 210 } 211 break; 212 213 case ACPI_MADT_TYPE_CORE_PIC: 214 { 215 struct acpi_madt_core_pic *p = (struct acpi_madt_core_pic *)header; 216 217 pr_debug("CORE PIC (processor_id[0x%02x] core_id[0x%02x] %s)\n", 218 p->processor_id, p->core_id, 219 (p->flags & ACPI_MADT_ENABLED) ? "enabled" : "disabled"); 220 } 221 break; 222 223 case ACPI_MADT_TYPE_RINTC: 224 { 225 struct acpi_madt_rintc *p = (struct acpi_madt_rintc *)header; 226 227 pr_debug("RISC-V INTC (acpi_uid[0x%04x] hart_id[0x%llx] %s)\n", 228 p->uid, p->hart_id, 229 (p->flags & ACPI_MADT_ENABLED) ? "enabled" : "disabled"); 230 } 231 break; 232 233 default: 234 pr_warn("Found unsupported MADT entry (type = 0x%x)\n", 235 header->type); 236 break; 237 } 238} 239 240static unsigned long __init_or_acpilib 241acpi_get_entry_type(struct acpi_subtable_entry *entry) 242{ 243 switch (entry->type) { 244 case ACPI_SUBTABLE_COMMON: 245 return entry->hdr->common.type; 246 case ACPI_SUBTABLE_HMAT: 247 return entry->hdr->hmat.type; 248 case ACPI_SUBTABLE_PRMT: 249 return 0; 250 case ACPI_SUBTABLE_CEDT: 251 return entry->hdr->cedt.type; 252 } 253 return 0; 254} 255 256static unsigned long __init_or_acpilib 257acpi_get_entry_length(struct acpi_subtable_entry *entry) 258{ 259 switch (entry->type) { 260 case ACPI_SUBTABLE_COMMON: 261 return entry->hdr->common.length; 262 case ACPI_SUBTABLE_HMAT: 263 return entry->hdr->hmat.length; 264 case ACPI_SUBTABLE_PRMT: 265 return entry->hdr->prmt.length; 266 case ACPI_SUBTABLE_CEDT: 267 return entry->hdr->cedt.length; 268 } 269 return 0; 270} 271 272static unsigned long __init_or_acpilib 273acpi_get_subtable_header_length(struct acpi_subtable_entry *entry) 274{ 275 switch (entry->type) { 276 case ACPI_SUBTABLE_COMMON: 277 return sizeof(entry->hdr->common); 278 case ACPI_SUBTABLE_HMAT: 279 return sizeof(entry->hdr->hmat); 280 case ACPI_SUBTABLE_PRMT: 281 return sizeof(entry->hdr->prmt); 282 case ACPI_SUBTABLE_CEDT: 283 return sizeof(entry->hdr->cedt); 284 } 285 return 0; 286} 287 288static enum acpi_subtable_type __init_or_acpilib 289acpi_get_subtable_type(char *id) 290{ 291 if (strncmp(id, ACPI_SIG_HMAT, 4) == 0) 292 return ACPI_SUBTABLE_HMAT; 293 if (strncmp(id, ACPI_SIG_PRMT, 4) == 0) 294 return ACPI_SUBTABLE_PRMT; 295 if (strncmp(id, ACPI_SIG_CEDT, 4) == 0) 296 return ACPI_SUBTABLE_CEDT; 297 return ACPI_SUBTABLE_COMMON; 298} 299 300static __init_or_acpilib bool has_handler(struct acpi_subtable_proc *proc) 301{ 302 return proc->handler || proc->handler_arg; 303} 304 305static __init_or_acpilib int call_handler(struct acpi_subtable_proc *proc, 306 union acpi_subtable_headers *hdr, 307 unsigned long end) 308{ 309 if (proc->handler) 310 return proc->handler(hdr, end); 311 if (proc->handler_arg) 312 return proc->handler_arg(hdr, proc->arg, end); 313 return -EINVAL; 314} 315 316/** 317 * acpi_parse_entries_array - for each proc_num find a suitable subtable 318 * 319 * @id: table id (for debugging purposes) 320 * @table_size: size of the root table 321 * @table_header: where does the table start? 322 * @proc: array of acpi_subtable_proc struct containing entry id 323 * and associated handler with it 324 * @proc_num: how big proc is? 325 * @max_entries: how many entries can we process? 326 * 327 * For each proc_num find a subtable with proc->id and run proc->handler 328 * on it. Assumption is that there's only single handler for particular 329 * entry id. 330 * 331 * The table_size is not the size of the complete ACPI table (the length 332 * field in the header struct), but only the size of the root table; i.e., 333 * the offset from the very first byte of the complete ACPI table, to the 334 * first byte of the very first subtable. 335 * 336 * On success returns sum of all matching entries for all proc handlers. 337 * Otherwise, -ENODEV or -EINVAL is returned. 338 */ 339static int __init_or_acpilib acpi_parse_entries_array( 340 char *id, unsigned long table_size, 341 struct acpi_table_header *table_header, struct acpi_subtable_proc *proc, 342 int proc_num, unsigned int max_entries) 343{ 344 struct acpi_subtable_entry entry; 345 unsigned long table_end, subtable_len, entry_len; 346 int count = 0; 347 int errs = 0; 348 int i; 349 350 table_end = (unsigned long)table_header + table_header->length; 351 352 /* Parse all entries looking for a match. */ 353 354 entry.type = acpi_get_subtable_type(id); 355 entry.hdr = (union acpi_subtable_headers *) 356 ((unsigned long)table_header + table_size); 357 subtable_len = acpi_get_subtable_header_length(&entry); 358 359 while (((unsigned long)entry.hdr) + subtable_len < table_end) { 360 if (max_entries && count >= max_entries) 361 break; 362 363 for (i = 0; i < proc_num; i++) { 364 if (acpi_get_entry_type(&entry) != proc[i].id) 365 continue; 366 if (!has_handler(&proc[i]) || 367 (!errs && 368 call_handler(&proc[i], entry.hdr, table_end))) { 369 errs++; 370 continue; 371 } 372 373 proc[i].count++; 374 break; 375 } 376 if (i != proc_num) 377 count++; 378 379 /* 380 * If entry->length is 0, break from this loop to avoid 381 * infinite loop. 382 */ 383 entry_len = acpi_get_entry_length(&entry); 384 if (entry_len == 0) { 385 pr_err("[%4.4s:0x%02x] Invalid zero length\n", id, proc->id); 386 return -EINVAL; 387 } 388 389 entry.hdr = (union acpi_subtable_headers *) 390 ((unsigned long)entry.hdr + entry_len); 391 } 392 393 if (max_entries && count > max_entries) { 394 pr_warn("[%4.4s:0x%02x] found the maximum %i entries\n", 395 id, proc->id, count); 396 } 397 398 return errs ? -EINVAL : count; 399} 400 401int __init_or_acpilib acpi_table_parse_entries_array( 402 char *id, unsigned long table_size, struct acpi_subtable_proc *proc, 403 int proc_num, unsigned int max_entries) 404{ 405 struct acpi_table_header *table_header = NULL; 406 int count; 407 u32 instance = 0; 408 409 if (acpi_disabled) 410 return -ENODEV; 411 412 if (!id) 413 return -EINVAL; 414 415 if (!table_size) 416 return -EINVAL; 417 418 if (!strncmp(id, ACPI_SIG_MADT, 4)) 419 instance = acpi_apic_instance; 420 421 acpi_get_table(id, instance, &table_header); 422 if (!table_header) { 423 pr_debug("%4.4s not present\n", id); 424 return -ENODEV; 425 } 426 427 count = acpi_parse_entries_array(id, table_size, table_header, 428 proc, proc_num, max_entries); 429 430 acpi_put_table(table_header); 431 return count; 432} 433 434static int __init_or_acpilib __acpi_table_parse_entries( 435 char *id, unsigned long table_size, int entry_id, 436 acpi_tbl_entry_handler handler, acpi_tbl_entry_handler_arg handler_arg, 437 void *arg, unsigned int max_entries) 438{ 439 struct acpi_subtable_proc proc = { 440 .id = entry_id, 441 .handler = handler, 442 .handler_arg = handler_arg, 443 .arg = arg, 444 }; 445 446 return acpi_table_parse_entries_array(id, table_size, &proc, 1, 447 max_entries); 448} 449 450int __init_or_acpilib 451acpi_table_parse_cedt(enum acpi_cedt_type id, 452 acpi_tbl_entry_handler_arg handler_arg, void *arg) 453{ 454 return __acpi_table_parse_entries(ACPI_SIG_CEDT, 455 sizeof(struct acpi_table_cedt), id, 456 NULL, handler_arg, arg, 0); 457} 458EXPORT_SYMBOL_ACPI_LIB(acpi_table_parse_cedt); 459 460int __init acpi_table_parse_entries(char *id, unsigned long table_size, 461 int entry_id, 462 acpi_tbl_entry_handler handler, 463 unsigned int max_entries) 464{ 465 return __acpi_table_parse_entries(id, table_size, entry_id, handler, 466 NULL, NULL, max_entries); 467} 468 469int __init acpi_table_parse_madt(enum acpi_madt_type id, 470 acpi_tbl_entry_handler handler, unsigned int max_entries) 471{ 472 return acpi_table_parse_entries(ACPI_SIG_MADT, 473 sizeof(struct acpi_table_madt), id, 474 handler, max_entries); 475} 476 477/** 478 * acpi_table_parse - find table with @id, run @handler on it 479 * @id: table id to find 480 * @handler: handler to run 481 * 482 * Scan the ACPI System Descriptor Table (STD) for a table matching @id, 483 * run @handler on it. 484 * 485 * Return 0 if table found, -errno if not. 486 */ 487int __init acpi_table_parse(char *id, acpi_tbl_table_handler handler) 488{ 489 struct acpi_table_header *table = NULL; 490 491 if (acpi_disabled) 492 return -ENODEV; 493 494 if (!id || !handler) 495 return -EINVAL; 496 497 if (strncmp(id, ACPI_SIG_MADT, 4) == 0) 498 acpi_get_table(id, acpi_apic_instance, &table); 499 else 500 acpi_get_table(id, 0, &table); 501 502 if (table) { 503 handler(table); 504 acpi_put_table(table); 505 return 0; 506 } else 507 return -ENODEV; 508} 509 510/* 511 * The BIOS is supposed to supply a single APIC/MADT, 512 * but some report two. Provide a knob to use either. 513 * (don't you wish instance 0 and 1 were not the same?) 514 */ 515static void __init check_multiple_madt(void) 516{ 517 struct acpi_table_header *table = NULL; 518 519 acpi_get_table(ACPI_SIG_MADT, 2, &table); 520 if (table) { 521 pr_warn("BIOS bug: multiple APIC/MADT found, using %d\n", 522 acpi_apic_instance); 523 pr_warn("If \"acpi_apic_instance=%d\" works better, " 524 "notify linux-acpi@vger.kernel.org\n", 525 acpi_apic_instance ? 0 : 2); 526 acpi_put_table(table); 527 528 } else 529 acpi_apic_instance = 0; 530 531 return; 532} 533 534static void acpi_table_taint(struct acpi_table_header *table) 535{ 536 pr_warn("Override [%4.4s-%8.8s], this is unsafe: tainting kernel\n", 537 table->signature, table->oem_table_id); 538 add_taint(TAINT_OVERRIDDEN_ACPI_TABLE, LOCKDEP_NOW_UNRELIABLE); 539} 540 541#ifdef CONFIG_ACPI_TABLE_UPGRADE 542static u64 acpi_tables_addr; 543static int all_tables_size; 544 545/* Copied from acpica/tbutils.c:acpi_tb_checksum() */ 546static u8 __init acpi_table_checksum(u8 *buffer, u32 length) 547{ 548 u8 sum = 0; 549 u8 *end = buffer + length; 550 551 while (buffer < end) 552 sum = (u8) (sum + *(buffer++)); 553 return sum; 554} 555 556/* All but ACPI_SIG_RSDP and ACPI_SIG_FACS: */ 557static const char table_sigs[][ACPI_NAMESEG_SIZE] __initconst = { 558 ACPI_SIG_BERT, ACPI_SIG_BGRT, ACPI_SIG_CPEP, ACPI_SIG_ECDT, 559 ACPI_SIG_EINJ, ACPI_SIG_ERST, ACPI_SIG_HEST, ACPI_SIG_MADT, 560 ACPI_SIG_MSCT, ACPI_SIG_SBST, ACPI_SIG_SLIT, ACPI_SIG_SRAT, 561 ACPI_SIG_ASF, ACPI_SIG_BOOT, ACPI_SIG_DBGP, ACPI_SIG_DMAR, 562 ACPI_SIG_HPET, ACPI_SIG_IBFT, ACPI_SIG_IVRS, ACPI_SIG_MCFG, 563 ACPI_SIG_MCHI, ACPI_SIG_SLIC, ACPI_SIG_SPCR, ACPI_SIG_SPMI, 564 ACPI_SIG_TCPA, ACPI_SIG_UEFI, ACPI_SIG_WAET, ACPI_SIG_WDAT, 565 ACPI_SIG_WDDT, ACPI_SIG_WDRT, ACPI_SIG_DSDT, ACPI_SIG_FADT, 566 ACPI_SIG_PSDT, ACPI_SIG_RSDT, ACPI_SIG_XSDT, ACPI_SIG_SSDT, 567 ACPI_SIG_IORT, ACPI_SIG_NFIT, ACPI_SIG_HMAT, ACPI_SIG_PPTT, 568 ACPI_SIG_NHLT, ACPI_SIG_AEST, ACPI_SIG_CEDT, ACPI_SIG_AGDI, 569 ACPI_SIG_NBFT }; 570 571#define ACPI_HEADER_SIZE sizeof(struct acpi_table_header) 572 573#define NR_ACPI_INITRD_TABLES 64 574static struct cpio_data __initdata acpi_initrd_files[NR_ACPI_INITRD_TABLES]; 575static DECLARE_BITMAP(acpi_initrd_installed, NR_ACPI_INITRD_TABLES); 576 577#define MAP_CHUNK_SIZE (NR_FIX_BTMAPS << PAGE_SHIFT) 578 579void __init acpi_table_upgrade(void) 580{ 581 void *data; 582 size_t size; 583 int sig, no, table_nr = 0, total_offset = 0; 584 long offset = 0; 585 struct acpi_table_header *table; 586 char cpio_path[32] = "kernel/firmware/acpi/"; 587 struct cpio_data file; 588 589 if (IS_ENABLED(CONFIG_ACPI_TABLE_OVERRIDE_VIA_BUILTIN_INITRD)) { 590 data = __initramfs_start; 591 size = __initramfs_size; 592 } else { 593 data = (void *)initrd_start; 594 size = initrd_end - initrd_start; 595 } 596 597 if (data == NULL || size == 0) 598 return; 599 600 for (no = 0; no < NR_ACPI_INITRD_TABLES; no++) { 601 file = find_cpio_data(cpio_path, data, size, &offset); 602 if (!file.data) 603 break; 604 605 data += offset; 606 size -= offset; 607 608 if (file.size < sizeof(struct acpi_table_header)) { 609 pr_err("ACPI OVERRIDE: Table smaller than ACPI header [%s%s]\n", 610 cpio_path, file.name); 611 continue; 612 } 613 614 table = file.data; 615 616 for (sig = 0; sig < ARRAY_SIZE(table_sigs); sig++) 617 if (!memcmp(table->signature, table_sigs[sig], 4)) 618 break; 619 620 if (sig >= ARRAY_SIZE(table_sigs)) { 621 pr_err("ACPI OVERRIDE: Unknown signature [%s%s]\n", 622 cpio_path, file.name); 623 continue; 624 } 625 if (file.size != table->length) { 626 pr_err("ACPI OVERRIDE: File length does not match table length [%s%s]\n", 627 cpio_path, file.name); 628 continue; 629 } 630 if (acpi_table_checksum(file.data, table->length)) { 631 pr_err("ACPI OVERRIDE: Bad table checksum [%s%s]\n", 632 cpio_path, file.name); 633 continue; 634 } 635 636 pr_info("%4.4s ACPI table found in initrd [%s%s][0x%x]\n", 637 table->signature, cpio_path, file.name, table->length); 638 639 all_tables_size += table->length; 640 acpi_initrd_files[table_nr].data = file.data; 641 acpi_initrd_files[table_nr].size = file.size; 642 table_nr++; 643 } 644 if (table_nr == 0) 645 return; 646 647 if (security_locked_down(LOCKDOWN_ACPI_TABLES)) { 648 pr_notice("kernel is locked down, ignoring table override\n"); 649 return; 650 } 651 652 acpi_tables_addr = 653 memblock_phys_alloc_range(all_tables_size, PAGE_SIZE, 654 0, ACPI_TABLE_UPGRADE_MAX_PHYS); 655 if (!acpi_tables_addr) { 656 WARN_ON(1); 657 return; 658 } 659 /* 660 * Only calling e820_add_reserve does not work and the 661 * tables are invalid (memory got used) later. 662 * memblock_reserve works as expected and the tables won't get modified. 663 * But it's not enough on X86 because ioremap will 664 * complain later (used by acpi_os_map_memory) that the pages 665 * that should get mapped are not marked "reserved". 666 * Both memblock_reserve and e820__range_add (via arch_reserve_mem_area) 667 * works fine. 668 */ 669 arch_reserve_mem_area(acpi_tables_addr, all_tables_size); 670 671 kmemleak_ignore_phys(acpi_tables_addr); 672 673 /* 674 * early_ioremap only can remap 256k one time. If we map all 675 * tables one time, we will hit the limit. Need to map chunks 676 * one by one during copying the same as that in relocate_initrd(). 677 */ 678 for (no = 0; no < table_nr; no++) { 679 unsigned char *src_p = acpi_initrd_files[no].data; 680 phys_addr_t size = acpi_initrd_files[no].size; 681 phys_addr_t dest_addr = acpi_tables_addr + total_offset; 682 phys_addr_t slop, clen; 683 char *dest_p; 684 685 total_offset += size; 686 687 while (size) { 688 slop = dest_addr & ~PAGE_MASK; 689 clen = size; 690 if (clen > MAP_CHUNK_SIZE - slop) 691 clen = MAP_CHUNK_SIZE - slop; 692 dest_p = early_memremap(dest_addr & PAGE_MASK, 693 clen + slop); 694 memcpy(dest_p + slop, src_p, clen); 695 early_memunmap(dest_p, clen + slop); 696 src_p += clen; 697 dest_addr += clen; 698 size -= clen; 699 } 700 } 701} 702 703static acpi_status 704acpi_table_initrd_override(struct acpi_table_header *existing_table, 705 acpi_physical_address *address, u32 *length) 706{ 707 int table_offset = 0; 708 int table_index = 0; 709 struct acpi_table_header *table; 710 u32 table_length; 711 712 *length = 0; 713 *address = 0; 714 if (!acpi_tables_addr) 715 return AE_OK; 716 717 while (table_offset + ACPI_HEADER_SIZE <= all_tables_size) { 718 table = acpi_os_map_memory(acpi_tables_addr + table_offset, 719 ACPI_HEADER_SIZE); 720 if (table_offset + table->length > all_tables_size) { 721 acpi_os_unmap_memory(table, ACPI_HEADER_SIZE); 722 WARN_ON(1); 723 return AE_OK; 724 } 725 726 table_length = table->length; 727 728 /* Only override tables matched */ 729 if (memcmp(existing_table->signature, table->signature, 4) || 730 memcmp(table->oem_id, existing_table->oem_id, 731 ACPI_OEM_ID_SIZE) || 732 memcmp(table->oem_table_id, existing_table->oem_table_id, 733 ACPI_OEM_TABLE_ID_SIZE)) { 734 acpi_os_unmap_memory(table, ACPI_HEADER_SIZE); 735 goto next_table; 736 } 737 /* 738 * Mark the table to avoid being used in 739 * acpi_table_initrd_scan() and check the revision. 740 */ 741 if (test_and_set_bit(table_index, acpi_initrd_installed) || 742 existing_table->oem_revision >= table->oem_revision) { 743 acpi_os_unmap_memory(table, ACPI_HEADER_SIZE); 744 goto next_table; 745 } 746 747 *length = table_length; 748 *address = acpi_tables_addr + table_offset; 749 pr_info("Table Upgrade: override [%4.4s-%6.6s-%8.8s]\n", 750 table->signature, table->oem_id, 751 table->oem_table_id); 752 acpi_os_unmap_memory(table, ACPI_HEADER_SIZE); 753 break; 754 755next_table: 756 table_offset += table_length; 757 table_index++; 758 } 759 return AE_OK; 760} 761 762static void __init acpi_table_initrd_scan(void) 763{ 764 int table_offset = 0; 765 int table_index = 0; 766 u32 table_length; 767 struct acpi_table_header *table; 768 769 if (!acpi_tables_addr) 770 return; 771 772 while (table_offset + ACPI_HEADER_SIZE <= all_tables_size) { 773 table = acpi_os_map_memory(acpi_tables_addr + table_offset, 774 ACPI_HEADER_SIZE); 775 if (table_offset + table->length > all_tables_size) { 776 acpi_os_unmap_memory(table, ACPI_HEADER_SIZE); 777 WARN_ON(1); 778 return; 779 } 780 781 table_length = table->length; 782 783 /* Skip RSDT/XSDT which should only be used for override */ 784 if (ACPI_COMPARE_NAMESEG(table->signature, ACPI_SIG_RSDT) || 785 ACPI_COMPARE_NAMESEG(table->signature, ACPI_SIG_XSDT)) { 786 acpi_os_unmap_memory(table, ACPI_HEADER_SIZE); 787 goto next_table; 788 } 789 /* 790 * Mark the table to avoid being used in 791 * acpi_table_initrd_override(). Though this is not possible 792 * because override is disabled in acpi_install_physical_table(). 793 */ 794 if (test_and_set_bit(table_index, acpi_initrd_installed)) { 795 acpi_os_unmap_memory(table, ACPI_HEADER_SIZE); 796 goto next_table; 797 } 798 799 pr_info("Table Upgrade: install [%4.4s-%6.6s-%8.8s]\n", 800 table->signature, table->oem_id, 801 table->oem_table_id); 802 acpi_os_unmap_memory(table, ACPI_HEADER_SIZE); 803 acpi_install_physical_table(acpi_tables_addr + table_offset); 804next_table: 805 table_offset += table_length; 806 table_index++; 807 } 808} 809#else 810static acpi_status 811acpi_table_initrd_override(struct acpi_table_header *existing_table, 812 acpi_physical_address *address, 813 u32 *table_length) 814{ 815 *table_length = 0; 816 *address = 0; 817 return AE_OK; 818} 819 820static void __init acpi_table_initrd_scan(void) 821{ 822} 823#endif /* CONFIG_ACPI_TABLE_UPGRADE */ 824 825acpi_status 826acpi_os_physical_table_override(struct acpi_table_header *existing_table, 827 acpi_physical_address *address, 828 u32 *table_length) 829{ 830 return acpi_table_initrd_override(existing_table, address, 831 table_length); 832} 833 834#ifdef CONFIG_ACPI_CUSTOM_DSDT 835static void *amlcode __attribute__ ((weakref("AmlCode"))); 836static void *dsdt_amlcode __attribute__ ((weakref("dsdt_aml_code"))); 837#endif 838 839acpi_status acpi_os_table_override(struct acpi_table_header *existing_table, 840 struct acpi_table_header **new_table) 841{ 842 if (!existing_table || !new_table) 843 return AE_BAD_PARAMETER; 844 845 *new_table = NULL; 846 847#ifdef CONFIG_ACPI_CUSTOM_DSDT 848 if (!strncmp(existing_table->signature, "DSDT", 4)) { 849 *new_table = (struct acpi_table_header *)&amlcode; 850 if (!(*new_table)) 851 *new_table = (struct acpi_table_header *)&dsdt_amlcode; 852 } 853#endif 854 if (*new_table != NULL) 855 acpi_table_taint(existing_table); 856 return AE_OK; 857} 858 859/* 860 * acpi_locate_initial_tables() 861 * 862 * Get the RSDP, then find and checksum all the ACPI tables. 863 * 864 * result: initial_tables[] is initialized, and points to 865 * a list of ACPI tables. 866 */ 867int __init acpi_locate_initial_tables(void) 868{ 869 acpi_status status; 870 871 if (acpi_verify_table_checksum) { 872 pr_info("Early table checksum verification enabled\n"); 873 acpi_gbl_enable_table_validation = TRUE; 874 } else { 875 pr_info("Early table checksum verification disabled\n"); 876 acpi_gbl_enable_table_validation = FALSE; 877 } 878 879 status = acpi_initialize_tables(initial_tables, ACPI_MAX_TABLES, 0); 880 if (ACPI_FAILURE(status)) 881 return -EINVAL; 882 883 return 0; 884} 885 886void __init acpi_reserve_initial_tables(void) 887{ 888 int i; 889 890 for (i = 0; i < ACPI_MAX_TABLES; i++) { 891 struct acpi_table_desc *table_desc = &initial_tables[i]; 892 u64 start = table_desc->address; 893 u64 size = table_desc->length; 894 895 if (!start || !size) 896 break; 897 898 pr_info("Reserving %4s table memory at [mem 0x%llx-0x%llx]\n", 899 table_desc->signature.ascii, start, start + size - 1); 900 901 memblock_reserve(start, size); 902 } 903} 904 905void __init acpi_table_init_complete(void) 906{ 907 acpi_table_initrd_scan(); 908 check_multiple_madt(); 909} 910 911int __init acpi_table_init(void) 912{ 913 int ret; 914 915 ret = acpi_locate_initial_tables(); 916 if (ret) 917 return ret; 918 919 acpi_table_init_complete(); 920 921 return 0; 922} 923 924static int __init acpi_parse_apic_instance(char *str) 925{ 926 if (!str) 927 return -EINVAL; 928 929 if (kstrtoint(str, 0, &acpi_apic_instance)) 930 return -EINVAL; 931 932 pr_notice("Shall use APIC/MADT table %d\n", acpi_apic_instance); 933 934 return 0; 935} 936early_param("acpi_apic_instance", acpi_parse_apic_instance); 937 938static int __init acpi_force_table_verification_setup(char *s) 939{ 940 acpi_verify_table_checksum = true; 941 942 return 0; 943} 944early_param("acpi_force_table_verification", acpi_force_table_verification_setup); 945 946static int __init acpi_force_32bit_fadt_addr(char *s) 947{ 948 pr_info("Forcing 32 Bit FADT addresses\n"); 949 acpi_gbl_use32_bit_fadt_addresses = TRUE; 950 951 return 0; 952} 953early_param("acpi_force_32bit_fadt_addr", acpi_force_32bit_fadt_addr); 954