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