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