1 /* 2 * acpi_tables.c - ACPI Boot-Time Table Parsing 3 * 4 * Copyright (C) 2001 Paul Diefenbaugh <paul.s.diefenbaugh@intel.com> 5 * 6 * ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ 7 * 8 * This program is free software; you can redistribute it and/or modify 9 * it under the terms of the GNU General Public License as published by 10 * the Free Software Foundation; either version 2 of the License, or 11 * (at your option) any later version. 12 * 13 * This program is distributed in the hope that it will be useful, 14 * but WITHOUT ANY WARRANTY; without even the implied warranty of 15 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 16 * GNU General Public License for more details. 17 * 18 * ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ 19 * 20 */ 21 22 /* Uncomment next line to get verbose printout */ 23 /* #define DEBUG */ 24 #define pr_fmt(fmt) "ACPI: " fmt 25 26 #include <linux/init.h> 27 #include <linux/kernel.h> 28 #include <linux/smp.h> 29 #include <linux/string.h> 30 #include <linux/types.h> 31 #include <linux/irq.h> 32 #include <linux/errno.h> 33 #include <linux/acpi.h> 34 #include <linux/memblock.h> 35 #include <linux/earlycpio.h> 36 #include <linux/initrd.h> 37 #include "internal.h" 38 39 #ifdef CONFIG_ACPI_CUSTOM_DSDT 40 #include CONFIG_ACPI_CUSTOM_DSDT_FILE 41 #endif 42 43 #define ACPI_MAX_TABLES 128 44 45 static char *mps_inti_flags_polarity[] = { "dfl", "high", "res", "low" }; 46 static char *mps_inti_flags_trigger[] = { "dfl", "edge", "res", "level" }; 47 48 static struct acpi_table_desc initial_tables[ACPI_MAX_TABLES] __initdata; 49 50 static int acpi_apic_instance __initdata; 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 */ 56 static bool acpi_verify_table_checksum __initdata = false; 57 58 void 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[%p])\n", 155 (void *)(unsigned long)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 default: 214 pr_warn("Found unsupported MADT entry (type = 0x%x)\n", 215 header->type); 216 break; 217 } 218 } 219 220 /** 221 * acpi_parse_entries_array - for each proc_num find a suitable subtable 222 * 223 * @id: table id (for debugging purposes) 224 * @table_size: size of the root table 225 * @table_header: where does the table start? 226 * @proc: array of acpi_subtable_proc struct containing entry id 227 * and associated handler with it 228 * @proc_num: how big proc is? 229 * @max_entries: how many entries can we process? 230 * 231 * For each proc_num find a subtable with proc->id and run proc->handler 232 * on it. Assumption is that there's only single handler for particular 233 * entry id. 234 * 235 * The table_size is not the size of the complete ACPI table (the length 236 * field in the header struct), but only the size of the root table; i.e., 237 * the offset from the very first byte of the complete ACPI table, to the 238 * first byte of the very first subtable. 239 * 240 * On success returns sum of all matching entries for all proc handlers. 241 * Otherwise, -ENODEV or -EINVAL is returned. 242 */ 243 static int __init 244 acpi_parse_entries_array(char *id, unsigned long table_size, 245 struct acpi_table_header *table_header, 246 struct acpi_subtable_proc *proc, int proc_num, 247 unsigned int max_entries) 248 { 249 struct acpi_subtable_header *entry; 250 unsigned long table_end; 251 int count = 0; 252 int errs = 0; 253 int i; 254 255 if (acpi_disabled) 256 return -ENODEV; 257 258 if (!id) 259 return -EINVAL; 260 261 if (!table_size) 262 return -EINVAL; 263 264 if (!table_header) { 265 pr_warn("%4.4s not present\n", id); 266 return -ENODEV; 267 } 268 269 table_end = (unsigned long)table_header + table_header->length; 270 271 /* Parse all entries looking for a match. */ 272 273 entry = (struct acpi_subtable_header *) 274 ((unsigned long)table_header + table_size); 275 276 while (((unsigned long)entry) + sizeof(struct acpi_subtable_header) < 277 table_end) { 278 if (max_entries && count >= max_entries) 279 break; 280 281 for (i = 0; i < proc_num; i++) { 282 if (entry->type != proc[i].id) 283 continue; 284 if (!proc[i].handler || 285 (!errs && proc[i].handler(entry, table_end))) { 286 errs++; 287 continue; 288 } 289 290 proc[i].count++; 291 break; 292 } 293 if (i != proc_num) 294 count++; 295 296 /* 297 * If entry->length is 0, break from this loop to avoid 298 * infinite loop. 299 */ 300 if (entry->length == 0) { 301 pr_err("[%4.4s:0x%02x] Invalid zero length\n", id, proc->id); 302 return -EINVAL; 303 } 304 305 entry = (struct acpi_subtable_header *) 306 ((unsigned long)entry + entry->length); 307 } 308 309 if (max_entries && count > max_entries) { 310 pr_warn("[%4.4s:0x%02x] found the maximum %i entries\n", 311 id, proc->id, count); 312 } 313 314 return errs ? -EINVAL : count; 315 } 316 317 int __init 318 acpi_table_parse_entries_array(char *id, 319 unsigned long table_size, 320 struct acpi_subtable_proc *proc, int proc_num, 321 unsigned int max_entries) 322 { 323 struct acpi_table_header *table_header = NULL; 324 int count; 325 u32 instance = 0; 326 327 if (acpi_disabled) 328 return -ENODEV; 329 330 if (!id) 331 return -EINVAL; 332 333 if (!strncmp(id, ACPI_SIG_MADT, 4)) 334 instance = acpi_apic_instance; 335 336 acpi_get_table(id, instance, &table_header); 337 if (!table_header) { 338 pr_warn("%4.4s not present\n", id); 339 return -ENODEV; 340 } 341 342 count = acpi_parse_entries_array(id, table_size, table_header, 343 proc, proc_num, max_entries); 344 345 acpi_put_table(table_header); 346 return count; 347 } 348 349 int __init 350 acpi_table_parse_entries(char *id, 351 unsigned long table_size, 352 int entry_id, 353 acpi_tbl_entry_handler handler, 354 unsigned int max_entries) 355 { 356 struct acpi_subtable_proc proc = { 357 .id = entry_id, 358 .handler = handler, 359 }; 360 361 return acpi_table_parse_entries_array(id, table_size, &proc, 1, 362 max_entries); 363 } 364 365 int __init 366 acpi_table_parse_madt(enum acpi_madt_type id, 367 acpi_tbl_entry_handler handler, unsigned int max_entries) 368 { 369 return acpi_table_parse_entries(ACPI_SIG_MADT, 370 sizeof(struct acpi_table_madt), id, 371 handler, max_entries); 372 } 373 374 /** 375 * acpi_table_parse - find table with @id, run @handler on it 376 * @id: table id to find 377 * @handler: handler to run 378 * 379 * Scan the ACPI System Descriptor Table (STD) for a table matching @id, 380 * run @handler on it. 381 * 382 * Return 0 if table found, -errno if not. 383 */ 384 int __init acpi_table_parse(char *id, acpi_tbl_table_handler handler) 385 { 386 struct acpi_table_header *table = NULL; 387 388 if (acpi_disabled) 389 return -ENODEV; 390 391 if (!id || !handler) 392 return -EINVAL; 393 394 if (strncmp(id, ACPI_SIG_MADT, 4) == 0) 395 acpi_get_table(id, acpi_apic_instance, &table); 396 else 397 acpi_get_table(id, 0, &table); 398 399 if (table) { 400 handler(table); 401 acpi_put_table(table); 402 return 0; 403 } else 404 return -ENODEV; 405 } 406 407 /* 408 * The BIOS is supposed to supply a single APIC/MADT, 409 * but some report two. Provide a knob to use either. 410 * (don't you wish instance 0 and 1 were not the same?) 411 */ 412 static void __init check_multiple_madt(void) 413 { 414 struct acpi_table_header *table = NULL; 415 416 acpi_get_table(ACPI_SIG_MADT, 2, &table); 417 if (table) { 418 pr_warn("BIOS bug: multiple APIC/MADT found, using %d\n", 419 acpi_apic_instance); 420 pr_warn("If \"acpi_apic_instance=%d\" works better, " 421 "notify linux-acpi@vger.kernel.org\n", 422 acpi_apic_instance ? 0 : 2); 423 acpi_put_table(table); 424 425 } else 426 acpi_apic_instance = 0; 427 428 return; 429 } 430 431 static void acpi_table_taint(struct acpi_table_header *table) 432 { 433 pr_warn("Override [%4.4s-%8.8s], this is unsafe: tainting kernel\n", 434 table->signature, table->oem_table_id); 435 add_taint(TAINT_OVERRIDDEN_ACPI_TABLE, LOCKDEP_NOW_UNRELIABLE); 436 } 437 438 #ifdef CONFIG_ACPI_TABLE_UPGRADE 439 static u64 acpi_tables_addr; 440 static int all_tables_size; 441 442 /* Copied from acpica/tbutils.c:acpi_tb_checksum() */ 443 static u8 __init acpi_table_checksum(u8 *buffer, u32 length) 444 { 445 u8 sum = 0; 446 u8 *end = buffer + length; 447 448 while (buffer < end) 449 sum = (u8) (sum + *(buffer++)); 450 return sum; 451 } 452 453 /* All but ACPI_SIG_RSDP and ACPI_SIG_FACS: */ 454 static const char * const table_sigs[] = { 455 ACPI_SIG_BERT, ACPI_SIG_CPEP, ACPI_SIG_ECDT, ACPI_SIG_EINJ, 456 ACPI_SIG_ERST, ACPI_SIG_HEST, ACPI_SIG_MADT, ACPI_SIG_MSCT, 457 ACPI_SIG_SBST, ACPI_SIG_SLIT, ACPI_SIG_SRAT, ACPI_SIG_ASF, 458 ACPI_SIG_BOOT, ACPI_SIG_DBGP, ACPI_SIG_DMAR, ACPI_SIG_HPET, 459 ACPI_SIG_IBFT, ACPI_SIG_IVRS, ACPI_SIG_MCFG, ACPI_SIG_MCHI, 460 ACPI_SIG_SLIC, ACPI_SIG_SPCR, ACPI_SIG_SPMI, ACPI_SIG_TCPA, 461 ACPI_SIG_UEFI, ACPI_SIG_WAET, ACPI_SIG_WDAT, ACPI_SIG_WDDT, 462 ACPI_SIG_WDRT, ACPI_SIG_DSDT, ACPI_SIG_FADT, ACPI_SIG_PSDT, 463 ACPI_SIG_RSDT, ACPI_SIG_XSDT, ACPI_SIG_SSDT, ACPI_SIG_IORT, 464 ACPI_SIG_NFIT, ACPI_SIG_HMAT, ACPI_SIG_PPTT, NULL }; 465 466 #define ACPI_HEADER_SIZE sizeof(struct acpi_table_header) 467 468 #define NR_ACPI_INITRD_TABLES 64 469 static struct cpio_data __initdata acpi_initrd_files[NR_ACPI_INITRD_TABLES]; 470 static DECLARE_BITMAP(acpi_initrd_installed, NR_ACPI_INITRD_TABLES); 471 472 #define MAP_CHUNK_SIZE (NR_FIX_BTMAPS << PAGE_SHIFT) 473 474 void __init acpi_table_upgrade(void) 475 { 476 void *data; 477 size_t size; 478 int sig, no, table_nr = 0, total_offset = 0; 479 long offset = 0; 480 struct acpi_table_header *table; 481 char cpio_path[32] = "kernel/firmware/acpi/"; 482 struct cpio_data file; 483 484 if (IS_ENABLED(CONFIG_ACPI_TABLE_OVERRIDE_VIA_BUILTIN_INITRD)) { 485 data = __initramfs_start; 486 size = __initramfs_size; 487 } else { 488 data = (void *)initrd_start; 489 size = initrd_end - initrd_start; 490 } 491 492 if (data == NULL || size == 0) 493 return; 494 495 for (no = 0; no < NR_ACPI_INITRD_TABLES; no++) { 496 file = find_cpio_data(cpio_path, data, size, &offset); 497 if (!file.data) 498 break; 499 500 data += offset; 501 size -= offset; 502 503 if (file.size < sizeof(struct acpi_table_header)) { 504 pr_err("ACPI OVERRIDE: Table smaller than ACPI header [%s%s]\n", 505 cpio_path, file.name); 506 continue; 507 } 508 509 table = file.data; 510 511 for (sig = 0; table_sigs[sig]; sig++) 512 if (!memcmp(table->signature, table_sigs[sig], 4)) 513 break; 514 515 if (!table_sigs[sig]) { 516 pr_err("ACPI OVERRIDE: Unknown signature [%s%s]\n", 517 cpio_path, file.name); 518 continue; 519 } 520 if (file.size != table->length) { 521 pr_err("ACPI OVERRIDE: File length does not match table length [%s%s]\n", 522 cpio_path, file.name); 523 continue; 524 } 525 if (acpi_table_checksum(file.data, table->length)) { 526 pr_err("ACPI OVERRIDE: Bad table checksum [%s%s]\n", 527 cpio_path, file.name); 528 continue; 529 } 530 531 pr_info("%4.4s ACPI table found in initrd [%s%s][0x%x]\n", 532 table->signature, cpio_path, file.name, table->length); 533 534 all_tables_size += table->length; 535 acpi_initrd_files[table_nr].data = file.data; 536 acpi_initrd_files[table_nr].size = file.size; 537 table_nr++; 538 } 539 if (table_nr == 0) 540 return; 541 542 acpi_tables_addr = 543 memblock_find_in_range(0, ACPI_TABLE_UPGRADE_MAX_PHYS, 544 all_tables_size, PAGE_SIZE); 545 if (!acpi_tables_addr) { 546 WARN_ON(1); 547 return; 548 } 549 /* 550 * Only calling e820_add_reserve does not work and the 551 * tables are invalid (memory got used) later. 552 * memblock_reserve works as expected and the tables won't get modified. 553 * But it's not enough on X86 because ioremap will 554 * complain later (used by acpi_os_map_memory) that the pages 555 * that should get mapped are not marked "reserved". 556 * Both memblock_reserve and e820__range_add (via arch_reserve_mem_area) 557 * works fine. 558 */ 559 memblock_reserve(acpi_tables_addr, all_tables_size); 560 arch_reserve_mem_area(acpi_tables_addr, all_tables_size); 561 562 /* 563 * early_ioremap only can remap 256k one time. If we map all 564 * tables one time, we will hit the limit. Need to map chunks 565 * one by one during copying the same as that in relocate_initrd(). 566 */ 567 for (no = 0; no < table_nr; no++) { 568 unsigned char *src_p = acpi_initrd_files[no].data; 569 phys_addr_t size = acpi_initrd_files[no].size; 570 phys_addr_t dest_addr = acpi_tables_addr + total_offset; 571 phys_addr_t slop, clen; 572 char *dest_p; 573 574 total_offset += size; 575 576 while (size) { 577 slop = dest_addr & ~PAGE_MASK; 578 clen = size; 579 if (clen > MAP_CHUNK_SIZE - slop) 580 clen = MAP_CHUNK_SIZE - slop; 581 dest_p = early_memremap(dest_addr & PAGE_MASK, 582 clen + slop); 583 memcpy(dest_p + slop, src_p, clen); 584 early_memunmap(dest_p, clen + slop); 585 src_p += clen; 586 dest_addr += clen; 587 size -= clen; 588 } 589 } 590 } 591 592 static acpi_status 593 acpi_table_initrd_override(struct acpi_table_header *existing_table, 594 acpi_physical_address *address, u32 *length) 595 { 596 int table_offset = 0; 597 int table_index = 0; 598 struct acpi_table_header *table; 599 u32 table_length; 600 601 *length = 0; 602 *address = 0; 603 if (!acpi_tables_addr) 604 return AE_OK; 605 606 while (table_offset + ACPI_HEADER_SIZE <= all_tables_size) { 607 table = acpi_os_map_memory(acpi_tables_addr + table_offset, 608 ACPI_HEADER_SIZE); 609 if (table_offset + table->length > all_tables_size) { 610 acpi_os_unmap_memory(table, ACPI_HEADER_SIZE); 611 WARN_ON(1); 612 return AE_OK; 613 } 614 615 table_length = table->length; 616 617 /* Only override tables matched */ 618 if (memcmp(existing_table->signature, table->signature, 4) || 619 memcmp(table->oem_id, existing_table->oem_id, 620 ACPI_OEM_ID_SIZE) || 621 memcmp(table->oem_table_id, existing_table->oem_table_id, 622 ACPI_OEM_TABLE_ID_SIZE)) { 623 acpi_os_unmap_memory(table, ACPI_HEADER_SIZE); 624 goto next_table; 625 } 626 /* 627 * Mark the table to avoid being used in 628 * acpi_table_initrd_scan() and check the revision. 629 */ 630 if (test_and_set_bit(table_index, acpi_initrd_installed) || 631 existing_table->oem_revision >= table->oem_revision) { 632 acpi_os_unmap_memory(table, ACPI_HEADER_SIZE); 633 goto next_table; 634 } 635 636 *length = table_length; 637 *address = acpi_tables_addr + table_offset; 638 pr_info("Table Upgrade: override [%4.4s-%6.6s-%8.8s]\n", 639 table->signature, table->oem_id, 640 table->oem_table_id); 641 acpi_os_unmap_memory(table, ACPI_HEADER_SIZE); 642 break; 643 644 next_table: 645 table_offset += table_length; 646 table_index++; 647 } 648 return AE_OK; 649 } 650 651 static void __init acpi_table_initrd_scan(void) 652 { 653 int table_offset = 0; 654 int table_index = 0; 655 u32 table_length; 656 struct acpi_table_header *table; 657 658 if (!acpi_tables_addr) 659 return; 660 661 while (table_offset + ACPI_HEADER_SIZE <= all_tables_size) { 662 table = acpi_os_map_memory(acpi_tables_addr + table_offset, 663 ACPI_HEADER_SIZE); 664 if (table_offset + table->length > all_tables_size) { 665 acpi_os_unmap_memory(table, ACPI_HEADER_SIZE); 666 WARN_ON(1); 667 return; 668 } 669 670 table_length = table->length; 671 672 /* Skip RSDT/XSDT which should only be used for override */ 673 if (ACPI_COMPARE_NAME(table->signature, ACPI_SIG_RSDT) || 674 ACPI_COMPARE_NAME(table->signature, ACPI_SIG_XSDT)) { 675 acpi_os_unmap_memory(table, ACPI_HEADER_SIZE); 676 goto next_table; 677 } 678 /* 679 * Mark the table to avoid being used in 680 * acpi_table_initrd_override(). Though this is not possible 681 * because override is disabled in acpi_install_table(). 682 */ 683 if (test_and_set_bit(table_index, acpi_initrd_installed)) { 684 acpi_os_unmap_memory(table, ACPI_HEADER_SIZE); 685 goto next_table; 686 } 687 688 pr_info("Table Upgrade: install [%4.4s-%6.6s-%8.8s]\n", 689 table->signature, table->oem_id, 690 table->oem_table_id); 691 acpi_os_unmap_memory(table, ACPI_HEADER_SIZE); 692 acpi_install_table(acpi_tables_addr + table_offset, TRUE); 693 next_table: 694 table_offset += table_length; 695 table_index++; 696 } 697 } 698 #else 699 static acpi_status 700 acpi_table_initrd_override(struct acpi_table_header *existing_table, 701 acpi_physical_address *address, 702 u32 *table_length) 703 { 704 *table_length = 0; 705 *address = 0; 706 return AE_OK; 707 } 708 709 static void __init acpi_table_initrd_scan(void) 710 { 711 } 712 #endif /* CONFIG_ACPI_TABLE_UPGRADE */ 713 714 acpi_status 715 acpi_os_physical_table_override(struct acpi_table_header *existing_table, 716 acpi_physical_address *address, 717 u32 *table_length) 718 { 719 return acpi_table_initrd_override(existing_table, address, 720 table_length); 721 } 722 723 #ifdef CONFIG_ACPI_CUSTOM_DSDT 724 static void *amlcode __attribute__ ((weakref("AmlCode"))); 725 static void *dsdt_amlcode __attribute__ ((weakref("dsdt_aml_code"))); 726 #endif 727 728 acpi_status 729 acpi_os_table_override(struct acpi_table_header *existing_table, 730 struct acpi_table_header **new_table) 731 { 732 if (!existing_table || !new_table) 733 return AE_BAD_PARAMETER; 734 735 *new_table = NULL; 736 737 #ifdef CONFIG_ACPI_CUSTOM_DSDT 738 if (!strncmp(existing_table->signature, "DSDT", 4)) { 739 *new_table = (struct acpi_table_header *)&amlcode; 740 if (!(*new_table)) 741 *new_table = (struct acpi_table_header *)&dsdt_amlcode; 742 } 743 #endif 744 if (*new_table != NULL) 745 acpi_table_taint(existing_table); 746 return AE_OK; 747 } 748 749 /* 750 * acpi_table_init() 751 * 752 * find RSDP, find and checksum SDT/XSDT. 753 * checksum all tables, print SDT/XSDT 754 * 755 * result: sdt_entry[] is initialized 756 */ 757 758 int __init acpi_table_init(void) 759 { 760 acpi_status status; 761 762 if (acpi_verify_table_checksum) { 763 pr_info("Early table checksum verification enabled\n"); 764 acpi_gbl_enable_table_validation = TRUE; 765 } else { 766 pr_info("Early table checksum verification disabled\n"); 767 acpi_gbl_enable_table_validation = FALSE; 768 } 769 770 status = acpi_initialize_tables(initial_tables, ACPI_MAX_TABLES, 0); 771 if (ACPI_FAILURE(status)) 772 return -EINVAL; 773 acpi_table_initrd_scan(); 774 775 check_multiple_madt(); 776 return 0; 777 } 778 779 static int __init acpi_parse_apic_instance(char *str) 780 { 781 if (!str) 782 return -EINVAL; 783 784 if (kstrtoint(str, 0, &acpi_apic_instance)) 785 return -EINVAL; 786 787 pr_notice("Shall use APIC/MADT table %d\n", acpi_apic_instance); 788 789 return 0; 790 } 791 792 early_param("acpi_apic_instance", acpi_parse_apic_instance); 793 794 static int __init acpi_force_table_verification_setup(char *s) 795 { 796 acpi_verify_table_checksum = true; 797 798 return 0; 799 } 800 801 early_param("acpi_force_table_verification", acpi_force_table_verification_setup); 802 803 static int __init acpi_force_32bit_fadt_addr(char *s) 804 { 805 pr_info("Forcing 32 Bit FADT addresses\n"); 806 acpi_gbl_use32_bit_fadt_addresses = TRUE; 807 808 return 0; 809 } 810 811 early_param("acpi_force_32bit_fadt_addr", acpi_force_32bit_fadt_addr); 812