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_phys_alloc_range(all_tables_size, PAGE_SIZE, 587 0, ACPI_TABLE_UPGRADE_MAX_PHYS); 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 arch_reserve_mem_area(acpi_tables_addr, all_tables_size); 603 604 /* 605 * early_ioremap only can remap 256k one time. If we map all 606 * tables one time, we will hit the limit. Need to map chunks 607 * one by one during copying the same as that in relocate_initrd(). 608 */ 609 for (no = 0; no < table_nr; no++) { 610 unsigned char *src_p = acpi_initrd_files[no].data; 611 phys_addr_t size = acpi_initrd_files[no].size; 612 phys_addr_t dest_addr = acpi_tables_addr + total_offset; 613 phys_addr_t slop, clen; 614 char *dest_p; 615 616 total_offset += size; 617 618 while (size) { 619 slop = dest_addr & ~PAGE_MASK; 620 clen = size; 621 if (clen > MAP_CHUNK_SIZE - slop) 622 clen = MAP_CHUNK_SIZE - slop; 623 dest_p = early_memremap(dest_addr & PAGE_MASK, 624 clen + slop); 625 memcpy(dest_p + slop, src_p, clen); 626 early_memunmap(dest_p, clen + slop); 627 src_p += clen; 628 dest_addr += clen; 629 size -= clen; 630 } 631 } 632 } 633 634 static acpi_status 635 acpi_table_initrd_override(struct acpi_table_header *existing_table, 636 acpi_physical_address *address, u32 *length) 637 { 638 int table_offset = 0; 639 int table_index = 0; 640 struct acpi_table_header *table; 641 u32 table_length; 642 643 *length = 0; 644 *address = 0; 645 if (!acpi_tables_addr) 646 return AE_OK; 647 648 while (table_offset + ACPI_HEADER_SIZE <= all_tables_size) { 649 table = acpi_os_map_memory(acpi_tables_addr + table_offset, 650 ACPI_HEADER_SIZE); 651 if (table_offset + table->length > all_tables_size) { 652 acpi_os_unmap_memory(table, ACPI_HEADER_SIZE); 653 WARN_ON(1); 654 return AE_OK; 655 } 656 657 table_length = table->length; 658 659 /* Only override tables matched */ 660 if (memcmp(existing_table->signature, table->signature, 4) || 661 memcmp(table->oem_id, existing_table->oem_id, 662 ACPI_OEM_ID_SIZE) || 663 memcmp(table->oem_table_id, existing_table->oem_table_id, 664 ACPI_OEM_TABLE_ID_SIZE)) { 665 acpi_os_unmap_memory(table, ACPI_HEADER_SIZE); 666 goto next_table; 667 } 668 /* 669 * Mark the table to avoid being used in 670 * acpi_table_initrd_scan() and check the revision. 671 */ 672 if (test_and_set_bit(table_index, acpi_initrd_installed) || 673 existing_table->oem_revision >= table->oem_revision) { 674 acpi_os_unmap_memory(table, ACPI_HEADER_SIZE); 675 goto next_table; 676 } 677 678 *length = table_length; 679 *address = acpi_tables_addr + table_offset; 680 pr_info("Table Upgrade: override [%4.4s-%6.6s-%8.8s]\n", 681 table->signature, table->oem_id, 682 table->oem_table_id); 683 acpi_os_unmap_memory(table, ACPI_HEADER_SIZE); 684 break; 685 686 next_table: 687 table_offset += table_length; 688 table_index++; 689 } 690 return AE_OK; 691 } 692 693 static void __init acpi_table_initrd_scan(void) 694 { 695 int table_offset = 0; 696 int table_index = 0; 697 u32 table_length; 698 struct acpi_table_header *table; 699 700 if (!acpi_tables_addr) 701 return; 702 703 while (table_offset + ACPI_HEADER_SIZE <= all_tables_size) { 704 table = acpi_os_map_memory(acpi_tables_addr + table_offset, 705 ACPI_HEADER_SIZE); 706 if (table_offset + table->length > all_tables_size) { 707 acpi_os_unmap_memory(table, ACPI_HEADER_SIZE); 708 WARN_ON(1); 709 return; 710 } 711 712 table_length = table->length; 713 714 /* Skip RSDT/XSDT which should only be used for override */ 715 if (ACPI_COMPARE_NAMESEG(table->signature, ACPI_SIG_RSDT) || 716 ACPI_COMPARE_NAMESEG(table->signature, ACPI_SIG_XSDT)) { 717 acpi_os_unmap_memory(table, ACPI_HEADER_SIZE); 718 goto next_table; 719 } 720 /* 721 * Mark the table to avoid being used in 722 * acpi_table_initrd_override(). Though this is not possible 723 * because override is disabled in acpi_install_table(). 724 */ 725 if (test_and_set_bit(table_index, acpi_initrd_installed)) { 726 acpi_os_unmap_memory(table, ACPI_HEADER_SIZE); 727 goto next_table; 728 } 729 730 pr_info("Table Upgrade: install [%4.4s-%6.6s-%8.8s]\n", 731 table->signature, table->oem_id, 732 table->oem_table_id); 733 acpi_os_unmap_memory(table, ACPI_HEADER_SIZE); 734 acpi_install_table(acpi_tables_addr + table_offset, TRUE); 735 next_table: 736 table_offset += table_length; 737 table_index++; 738 } 739 } 740 #else 741 static acpi_status 742 acpi_table_initrd_override(struct acpi_table_header *existing_table, 743 acpi_physical_address *address, 744 u32 *table_length) 745 { 746 *table_length = 0; 747 *address = 0; 748 return AE_OK; 749 } 750 751 static void __init acpi_table_initrd_scan(void) 752 { 753 } 754 #endif /* CONFIG_ACPI_TABLE_UPGRADE */ 755 756 acpi_status 757 acpi_os_physical_table_override(struct acpi_table_header *existing_table, 758 acpi_physical_address *address, 759 u32 *table_length) 760 { 761 return acpi_table_initrd_override(existing_table, address, 762 table_length); 763 } 764 765 #ifdef CONFIG_ACPI_CUSTOM_DSDT 766 static void *amlcode __attribute__ ((weakref("AmlCode"))); 767 static void *dsdt_amlcode __attribute__ ((weakref("dsdt_aml_code"))); 768 #endif 769 770 acpi_status acpi_os_table_override(struct acpi_table_header *existing_table, 771 struct acpi_table_header **new_table) 772 { 773 if (!existing_table || !new_table) 774 return AE_BAD_PARAMETER; 775 776 *new_table = NULL; 777 778 #ifdef CONFIG_ACPI_CUSTOM_DSDT 779 if (!strncmp(existing_table->signature, "DSDT", 4)) { 780 *new_table = (struct acpi_table_header *)&amlcode; 781 if (!(*new_table)) 782 *new_table = (struct acpi_table_header *)&dsdt_amlcode; 783 } 784 #endif 785 if (*new_table != NULL) 786 acpi_table_taint(existing_table); 787 return AE_OK; 788 } 789 790 /* 791 * acpi_locate_initial_tables() 792 * 793 * find RSDP, find and checksum SDT/XSDT. 794 * checksum all tables, print SDT/XSDT 795 * 796 * result: sdt_entry[] is initialized 797 */ 798 799 int __init acpi_locate_initial_tables(void) 800 { 801 acpi_status status; 802 803 if (acpi_verify_table_checksum) { 804 pr_info("Early table checksum verification enabled\n"); 805 acpi_gbl_enable_table_validation = TRUE; 806 } else { 807 pr_info("Early table checksum verification disabled\n"); 808 acpi_gbl_enable_table_validation = FALSE; 809 } 810 811 status = acpi_initialize_tables(initial_tables, ACPI_MAX_TABLES, 0); 812 if (ACPI_FAILURE(status)) 813 return -EINVAL; 814 815 return 0; 816 } 817 818 void __init acpi_reserve_initial_tables(void) 819 { 820 int i; 821 822 for (i = 0; i < ACPI_MAX_TABLES; i++) { 823 struct acpi_table_desc *table_desc = &initial_tables[i]; 824 u64 start = table_desc->address; 825 u64 size = table_desc->length; 826 827 if (!start || !size) 828 break; 829 830 pr_info("Reserving %4s table memory at [mem 0x%llx-0x%llx]\n", 831 table_desc->signature.ascii, start, start + size - 1); 832 833 memblock_reserve(start, size); 834 } 835 } 836 837 void __init acpi_table_init_complete(void) 838 { 839 acpi_table_initrd_scan(); 840 check_multiple_madt(); 841 } 842 843 int __init acpi_table_init(void) 844 { 845 int ret; 846 847 ret = acpi_locate_initial_tables(); 848 if (ret) 849 return ret; 850 851 acpi_table_init_complete(); 852 853 return 0; 854 } 855 856 static int __init acpi_parse_apic_instance(char *str) 857 { 858 if (!str) 859 return -EINVAL; 860 861 if (kstrtoint(str, 0, &acpi_apic_instance)) 862 return -EINVAL; 863 864 pr_notice("Shall use APIC/MADT table %d\n", acpi_apic_instance); 865 866 return 0; 867 } 868 early_param("acpi_apic_instance", acpi_parse_apic_instance); 869 870 static int __init acpi_force_table_verification_setup(char *s) 871 { 872 acpi_verify_table_checksum = true; 873 874 return 0; 875 } 876 early_param("acpi_force_table_verification", acpi_force_table_verification_setup); 877 878 static int __init acpi_force_32bit_fadt_addr(char *s) 879 { 880 pr_info("Forcing 32 Bit FADT addresses\n"); 881 acpi_gbl_use32_bit_fadt_addresses = TRUE; 882 883 return 0; 884 } 885 early_param("acpi_force_32bit_fadt_addr", acpi_force_32bit_fadt_addr); 886