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