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 <linux/kmemleak.h> 25 #include "internal.h" 26 27 #ifdef CONFIG_ACPI_CUSTOM_DSDT 28 #include CONFIG_ACPI_CUSTOM_DSDT_FILE 29 #endif 30 31 #define ACPI_MAX_TABLES 128 32 33 static char *mps_inti_flags_polarity[] = { "dfl", "high", "res", "low" }; 34 static char *mps_inti_flags_trigger[] = { "dfl", "edge", "res", "level" }; 35 36 static struct acpi_table_desc initial_tables[ACPI_MAX_TABLES] __initdata; 37 38 static int acpi_apic_instance __initdata_or_acpilib; 39 40 enum acpi_subtable_type { 41 ACPI_SUBTABLE_COMMON, 42 ACPI_SUBTABLE_HMAT, 43 ACPI_SUBTABLE_PRMT, 44 ACPI_SUBTABLE_CEDT, 45 }; 46 47 struct acpi_subtable_entry { 48 union acpi_subtable_headers *hdr; 49 enum acpi_subtable_type type; 50 }; 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_or_acpilib = 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[0x%llx])\n", 155 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 static unsigned long __init_or_acpilib 221 acpi_get_entry_type(struct acpi_subtable_entry *entry) 222 { 223 switch (entry->type) { 224 case ACPI_SUBTABLE_COMMON: 225 return entry->hdr->common.type; 226 case ACPI_SUBTABLE_HMAT: 227 return entry->hdr->hmat.type; 228 case ACPI_SUBTABLE_PRMT: 229 return 0; 230 case ACPI_SUBTABLE_CEDT: 231 return entry->hdr->cedt.type; 232 } 233 return 0; 234 } 235 236 static unsigned long __init_or_acpilib 237 acpi_get_entry_length(struct acpi_subtable_entry *entry) 238 { 239 switch (entry->type) { 240 case ACPI_SUBTABLE_COMMON: 241 return entry->hdr->common.length; 242 case ACPI_SUBTABLE_HMAT: 243 return entry->hdr->hmat.length; 244 case ACPI_SUBTABLE_PRMT: 245 return entry->hdr->prmt.length; 246 case ACPI_SUBTABLE_CEDT: 247 return entry->hdr->cedt.length; 248 } 249 return 0; 250 } 251 252 static unsigned long __init_or_acpilib 253 acpi_get_subtable_header_length(struct acpi_subtable_entry *entry) 254 { 255 switch (entry->type) { 256 case ACPI_SUBTABLE_COMMON: 257 return sizeof(entry->hdr->common); 258 case ACPI_SUBTABLE_HMAT: 259 return sizeof(entry->hdr->hmat); 260 case ACPI_SUBTABLE_PRMT: 261 return sizeof(entry->hdr->prmt); 262 case ACPI_SUBTABLE_CEDT: 263 return sizeof(entry->hdr->cedt); 264 } 265 return 0; 266 } 267 268 static enum acpi_subtable_type __init_or_acpilib 269 acpi_get_subtable_type(char *id) 270 { 271 if (strncmp(id, ACPI_SIG_HMAT, 4) == 0) 272 return ACPI_SUBTABLE_HMAT; 273 if (strncmp(id, ACPI_SIG_PRMT, 4) == 0) 274 return ACPI_SUBTABLE_PRMT; 275 if (strncmp(id, ACPI_SIG_CEDT, 4) == 0) 276 return ACPI_SUBTABLE_CEDT; 277 return ACPI_SUBTABLE_COMMON; 278 } 279 280 static __init_or_acpilib bool has_handler(struct acpi_subtable_proc *proc) 281 { 282 return proc->handler || proc->handler_arg; 283 } 284 285 static __init_or_acpilib int call_handler(struct acpi_subtable_proc *proc, 286 union acpi_subtable_headers *hdr, 287 unsigned long end) 288 { 289 if (proc->handler) 290 return proc->handler(hdr, end); 291 if (proc->handler_arg) 292 return proc->handler_arg(hdr, proc->arg, end); 293 return -EINVAL; 294 } 295 296 /** 297 * acpi_parse_entries_array - for each proc_num find a suitable subtable 298 * 299 * @id: table id (for debugging purposes) 300 * @table_size: size of the root table 301 * @table_header: where does the table start? 302 * @proc: array of acpi_subtable_proc struct containing entry id 303 * and associated handler with it 304 * @proc_num: how big proc is? 305 * @max_entries: how many entries can we process? 306 * 307 * For each proc_num find a subtable with proc->id and run proc->handler 308 * on it. Assumption is that there's only single handler for particular 309 * entry id. 310 * 311 * The table_size is not the size of the complete ACPI table (the length 312 * field in the header struct), but only the size of the root table; i.e., 313 * the offset from the very first byte of the complete ACPI table, to the 314 * first byte of the very first subtable. 315 * 316 * On success returns sum of all matching entries for all proc handlers. 317 * Otherwise, -ENODEV or -EINVAL is returned. 318 */ 319 static int __init_or_acpilib acpi_parse_entries_array( 320 char *id, unsigned long table_size, 321 struct acpi_table_header *table_header, struct acpi_subtable_proc *proc, 322 int proc_num, unsigned int max_entries) 323 { 324 struct acpi_subtable_entry entry; 325 unsigned long table_end, subtable_len, entry_len; 326 int count = 0; 327 int errs = 0; 328 int i; 329 330 table_end = (unsigned long)table_header + table_header->length; 331 332 /* Parse all entries looking for a match. */ 333 334 entry.type = acpi_get_subtable_type(id); 335 entry.hdr = (union acpi_subtable_headers *) 336 ((unsigned long)table_header + table_size); 337 subtable_len = acpi_get_subtable_header_length(&entry); 338 339 while (((unsigned long)entry.hdr) + subtable_len < table_end) { 340 if (max_entries && count >= max_entries) 341 break; 342 343 for (i = 0; i < proc_num; i++) { 344 if (acpi_get_entry_type(&entry) != proc[i].id) 345 continue; 346 if (!has_handler(&proc[i]) || 347 (!errs && 348 call_handler(&proc[i], entry.hdr, table_end))) { 349 errs++; 350 continue; 351 } 352 353 proc[i].count++; 354 break; 355 } 356 if (i != proc_num) 357 count++; 358 359 /* 360 * If entry->length is 0, break from this loop to avoid 361 * infinite loop. 362 */ 363 entry_len = acpi_get_entry_length(&entry); 364 if (entry_len == 0) { 365 pr_err("[%4.4s:0x%02x] Invalid zero length\n", id, proc->id); 366 return -EINVAL; 367 } 368 369 entry.hdr = (union acpi_subtable_headers *) 370 ((unsigned long)entry.hdr + entry_len); 371 } 372 373 if (max_entries && count > max_entries) { 374 pr_warn("[%4.4s:0x%02x] found the maximum %i entries\n", 375 id, proc->id, count); 376 } 377 378 return errs ? -EINVAL : count; 379 } 380 381 int __init_or_acpilib acpi_table_parse_entries_array( 382 char *id, unsigned long table_size, struct acpi_subtable_proc *proc, 383 int proc_num, unsigned int max_entries) 384 { 385 struct acpi_table_header *table_header = NULL; 386 int count; 387 u32 instance = 0; 388 389 if (acpi_disabled) 390 return -ENODEV; 391 392 if (!id) 393 return -EINVAL; 394 395 if (!table_size) 396 return -EINVAL; 397 398 if (!strncmp(id, ACPI_SIG_MADT, 4)) 399 instance = acpi_apic_instance; 400 401 acpi_get_table(id, instance, &table_header); 402 if (!table_header) { 403 pr_debug("%4.4s not present\n", id); 404 return -ENODEV; 405 } 406 407 count = acpi_parse_entries_array(id, table_size, table_header, 408 proc, proc_num, max_entries); 409 410 acpi_put_table(table_header); 411 return count; 412 } 413 414 static int __init_or_acpilib __acpi_table_parse_entries( 415 char *id, unsigned long table_size, int entry_id, 416 acpi_tbl_entry_handler handler, acpi_tbl_entry_handler_arg handler_arg, 417 void *arg, unsigned int max_entries) 418 { 419 struct acpi_subtable_proc proc = { 420 .id = entry_id, 421 .handler = handler, 422 .handler_arg = handler_arg, 423 .arg = arg, 424 }; 425 426 return acpi_table_parse_entries_array(id, table_size, &proc, 1, 427 max_entries); 428 } 429 430 int __init_or_acpilib 431 acpi_table_parse_cedt(enum acpi_cedt_type id, 432 acpi_tbl_entry_handler_arg handler_arg, void *arg) 433 { 434 return __acpi_table_parse_entries(ACPI_SIG_CEDT, 435 sizeof(struct acpi_table_cedt), id, 436 NULL, handler_arg, arg, 0); 437 } 438 EXPORT_SYMBOL_ACPI_LIB(acpi_table_parse_cedt); 439 440 int __init acpi_table_parse_entries(char *id, unsigned long table_size, 441 int entry_id, 442 acpi_tbl_entry_handler handler, 443 unsigned int max_entries) 444 { 445 return __acpi_table_parse_entries(id, table_size, entry_id, handler, 446 NULL, NULL, max_entries); 447 } 448 449 int __init acpi_table_parse_madt(enum acpi_madt_type id, 450 acpi_tbl_entry_handler handler, unsigned int max_entries) 451 { 452 return acpi_table_parse_entries(ACPI_SIG_MADT, 453 sizeof(struct acpi_table_madt), id, 454 handler, max_entries); 455 } 456 457 /** 458 * acpi_table_parse - find table with @id, run @handler on it 459 * @id: table id to find 460 * @handler: handler to run 461 * 462 * Scan the ACPI System Descriptor Table (STD) for a table matching @id, 463 * run @handler on it. 464 * 465 * Return 0 if table found, -errno if not. 466 */ 467 int __init acpi_table_parse(char *id, acpi_tbl_table_handler handler) 468 { 469 struct acpi_table_header *table = NULL; 470 471 if (acpi_disabled) 472 return -ENODEV; 473 474 if (!id || !handler) 475 return -EINVAL; 476 477 if (strncmp(id, ACPI_SIG_MADT, 4) == 0) 478 acpi_get_table(id, acpi_apic_instance, &table); 479 else 480 acpi_get_table(id, 0, &table); 481 482 if (table) { 483 handler(table); 484 acpi_put_table(table); 485 return 0; 486 } else 487 return -ENODEV; 488 } 489 490 /* 491 * The BIOS is supposed to supply a single APIC/MADT, 492 * but some report two. Provide a knob to use either. 493 * (don't you wish instance 0 and 1 were not the same?) 494 */ 495 static void __init check_multiple_madt(void) 496 { 497 struct acpi_table_header *table = NULL; 498 499 acpi_get_table(ACPI_SIG_MADT, 2, &table); 500 if (table) { 501 pr_warn("BIOS bug: multiple APIC/MADT found, using %d\n", 502 acpi_apic_instance); 503 pr_warn("If \"acpi_apic_instance=%d\" works better, " 504 "notify linux-acpi@vger.kernel.org\n", 505 acpi_apic_instance ? 0 : 2); 506 acpi_put_table(table); 507 508 } else 509 acpi_apic_instance = 0; 510 511 return; 512 } 513 514 static void acpi_table_taint(struct acpi_table_header *table) 515 { 516 pr_warn("Override [%4.4s-%8.8s], this is unsafe: tainting kernel\n", 517 table->signature, table->oem_table_id); 518 add_taint(TAINT_OVERRIDDEN_ACPI_TABLE, LOCKDEP_NOW_UNRELIABLE); 519 } 520 521 #ifdef CONFIG_ACPI_TABLE_UPGRADE 522 static u64 acpi_tables_addr; 523 static int all_tables_size; 524 525 /* Copied from acpica/tbutils.c:acpi_tb_checksum() */ 526 static u8 __init acpi_table_checksum(u8 *buffer, u32 length) 527 { 528 u8 sum = 0; 529 u8 *end = buffer + length; 530 531 while (buffer < end) 532 sum = (u8) (sum + *(buffer++)); 533 return sum; 534 } 535 536 /* All but ACPI_SIG_RSDP and ACPI_SIG_FACS: */ 537 static const char table_sigs[][ACPI_NAMESEG_SIZE] __initconst = { 538 ACPI_SIG_BERT, ACPI_SIG_BGRT, ACPI_SIG_CPEP, ACPI_SIG_ECDT, 539 ACPI_SIG_EINJ, ACPI_SIG_ERST, ACPI_SIG_HEST, ACPI_SIG_MADT, 540 ACPI_SIG_MSCT, ACPI_SIG_SBST, ACPI_SIG_SLIT, ACPI_SIG_SRAT, 541 ACPI_SIG_ASF, ACPI_SIG_BOOT, ACPI_SIG_DBGP, ACPI_SIG_DMAR, 542 ACPI_SIG_HPET, ACPI_SIG_IBFT, ACPI_SIG_IVRS, ACPI_SIG_MCFG, 543 ACPI_SIG_MCHI, ACPI_SIG_SLIC, ACPI_SIG_SPCR, ACPI_SIG_SPMI, 544 ACPI_SIG_TCPA, ACPI_SIG_UEFI, ACPI_SIG_WAET, ACPI_SIG_WDAT, 545 ACPI_SIG_WDDT, ACPI_SIG_WDRT, ACPI_SIG_DSDT, ACPI_SIG_FADT, 546 ACPI_SIG_PSDT, ACPI_SIG_RSDT, ACPI_SIG_XSDT, ACPI_SIG_SSDT, 547 ACPI_SIG_IORT, ACPI_SIG_NFIT, ACPI_SIG_HMAT, ACPI_SIG_PPTT, 548 ACPI_SIG_NHLT, ACPI_SIG_AEST, ACPI_SIG_CEDT, ACPI_SIG_AGDI }; 549 550 #define ACPI_HEADER_SIZE sizeof(struct acpi_table_header) 551 552 #define NR_ACPI_INITRD_TABLES 64 553 static struct cpio_data __initdata acpi_initrd_files[NR_ACPI_INITRD_TABLES]; 554 static DECLARE_BITMAP(acpi_initrd_installed, NR_ACPI_INITRD_TABLES); 555 556 #define MAP_CHUNK_SIZE (NR_FIX_BTMAPS << PAGE_SHIFT) 557 558 void __init acpi_table_upgrade(void) 559 { 560 void *data; 561 size_t size; 562 int sig, no, table_nr = 0, total_offset = 0; 563 long offset = 0; 564 struct acpi_table_header *table; 565 char cpio_path[32] = "kernel/firmware/acpi/"; 566 struct cpio_data file; 567 568 if (IS_ENABLED(CONFIG_ACPI_TABLE_OVERRIDE_VIA_BUILTIN_INITRD)) { 569 data = __initramfs_start; 570 size = __initramfs_size; 571 } else { 572 data = (void *)initrd_start; 573 size = initrd_end - initrd_start; 574 } 575 576 if (data == NULL || size == 0) 577 return; 578 579 for (no = 0; no < NR_ACPI_INITRD_TABLES; no++) { 580 file = find_cpio_data(cpio_path, data, size, &offset); 581 if (!file.data) 582 break; 583 584 data += offset; 585 size -= offset; 586 587 if (file.size < sizeof(struct acpi_table_header)) { 588 pr_err("ACPI OVERRIDE: Table smaller than ACPI header [%s%s]\n", 589 cpio_path, file.name); 590 continue; 591 } 592 593 table = file.data; 594 595 for (sig = 0; sig < ARRAY_SIZE(table_sigs); sig++) 596 if (!memcmp(table->signature, table_sigs[sig], 4)) 597 break; 598 599 if (sig >= ARRAY_SIZE(table_sigs)) { 600 pr_err("ACPI OVERRIDE: Unknown signature [%s%s]\n", 601 cpio_path, file.name); 602 continue; 603 } 604 if (file.size != table->length) { 605 pr_err("ACPI OVERRIDE: File length does not match table length [%s%s]\n", 606 cpio_path, file.name); 607 continue; 608 } 609 if (acpi_table_checksum(file.data, table->length)) { 610 pr_err("ACPI OVERRIDE: Bad table checksum [%s%s]\n", 611 cpio_path, file.name); 612 continue; 613 } 614 615 pr_info("%4.4s ACPI table found in initrd [%s%s][0x%x]\n", 616 table->signature, cpio_path, file.name, table->length); 617 618 all_tables_size += table->length; 619 acpi_initrd_files[table_nr].data = file.data; 620 acpi_initrd_files[table_nr].size = file.size; 621 table_nr++; 622 } 623 if (table_nr == 0) 624 return; 625 626 if (security_locked_down(LOCKDOWN_ACPI_TABLES)) { 627 pr_notice("kernel is locked down, ignoring table override\n"); 628 return; 629 } 630 631 acpi_tables_addr = 632 memblock_phys_alloc_range(all_tables_size, PAGE_SIZE, 633 0, ACPI_TABLE_UPGRADE_MAX_PHYS); 634 if (!acpi_tables_addr) { 635 WARN_ON(1); 636 return; 637 } 638 /* 639 * Only calling e820_add_reserve does not work and the 640 * tables are invalid (memory got used) later. 641 * memblock_reserve works as expected and the tables won't get modified. 642 * But it's not enough on X86 because ioremap will 643 * complain later (used by acpi_os_map_memory) that the pages 644 * that should get mapped are not marked "reserved". 645 * Both memblock_reserve and e820__range_add (via arch_reserve_mem_area) 646 * works fine. 647 */ 648 arch_reserve_mem_area(acpi_tables_addr, all_tables_size); 649 650 kmemleak_ignore_phys(acpi_tables_addr); 651 652 /* 653 * early_ioremap only can remap 256k one time. If we map all 654 * tables one time, we will hit the limit. Need to map chunks 655 * one by one during copying the same as that in relocate_initrd(). 656 */ 657 for (no = 0; no < table_nr; no++) { 658 unsigned char *src_p = acpi_initrd_files[no].data; 659 phys_addr_t size = acpi_initrd_files[no].size; 660 phys_addr_t dest_addr = acpi_tables_addr + total_offset; 661 phys_addr_t slop, clen; 662 char *dest_p; 663 664 total_offset += size; 665 666 while (size) { 667 slop = dest_addr & ~PAGE_MASK; 668 clen = size; 669 if (clen > MAP_CHUNK_SIZE - slop) 670 clen = MAP_CHUNK_SIZE - slop; 671 dest_p = early_memremap(dest_addr & PAGE_MASK, 672 clen + slop); 673 memcpy(dest_p + slop, src_p, clen); 674 early_memunmap(dest_p, clen + slop); 675 src_p += clen; 676 dest_addr += clen; 677 size -= clen; 678 } 679 } 680 } 681 682 static acpi_status 683 acpi_table_initrd_override(struct acpi_table_header *existing_table, 684 acpi_physical_address *address, u32 *length) 685 { 686 int table_offset = 0; 687 int table_index = 0; 688 struct acpi_table_header *table; 689 u32 table_length; 690 691 *length = 0; 692 *address = 0; 693 if (!acpi_tables_addr) 694 return AE_OK; 695 696 while (table_offset + ACPI_HEADER_SIZE <= all_tables_size) { 697 table = acpi_os_map_memory(acpi_tables_addr + table_offset, 698 ACPI_HEADER_SIZE); 699 if (table_offset + table->length > all_tables_size) { 700 acpi_os_unmap_memory(table, ACPI_HEADER_SIZE); 701 WARN_ON(1); 702 return AE_OK; 703 } 704 705 table_length = table->length; 706 707 /* Only override tables matched */ 708 if (memcmp(existing_table->signature, table->signature, 4) || 709 memcmp(table->oem_id, existing_table->oem_id, 710 ACPI_OEM_ID_SIZE) || 711 memcmp(table->oem_table_id, existing_table->oem_table_id, 712 ACPI_OEM_TABLE_ID_SIZE)) { 713 acpi_os_unmap_memory(table, ACPI_HEADER_SIZE); 714 goto next_table; 715 } 716 /* 717 * Mark the table to avoid being used in 718 * acpi_table_initrd_scan() and check the revision. 719 */ 720 if (test_and_set_bit(table_index, acpi_initrd_installed) || 721 existing_table->oem_revision >= table->oem_revision) { 722 acpi_os_unmap_memory(table, ACPI_HEADER_SIZE); 723 goto next_table; 724 } 725 726 *length = table_length; 727 *address = acpi_tables_addr + table_offset; 728 pr_info("Table Upgrade: override [%4.4s-%6.6s-%8.8s]\n", 729 table->signature, table->oem_id, 730 table->oem_table_id); 731 acpi_os_unmap_memory(table, ACPI_HEADER_SIZE); 732 break; 733 734 next_table: 735 table_offset += table_length; 736 table_index++; 737 } 738 return AE_OK; 739 } 740 741 static void __init acpi_table_initrd_scan(void) 742 { 743 int table_offset = 0; 744 int table_index = 0; 745 u32 table_length; 746 struct acpi_table_header *table; 747 748 if (!acpi_tables_addr) 749 return; 750 751 while (table_offset + ACPI_HEADER_SIZE <= all_tables_size) { 752 table = acpi_os_map_memory(acpi_tables_addr + table_offset, 753 ACPI_HEADER_SIZE); 754 if (table_offset + table->length > all_tables_size) { 755 acpi_os_unmap_memory(table, ACPI_HEADER_SIZE); 756 WARN_ON(1); 757 return; 758 } 759 760 table_length = table->length; 761 762 /* Skip RSDT/XSDT which should only be used for override */ 763 if (ACPI_COMPARE_NAMESEG(table->signature, ACPI_SIG_RSDT) || 764 ACPI_COMPARE_NAMESEG(table->signature, ACPI_SIG_XSDT)) { 765 acpi_os_unmap_memory(table, ACPI_HEADER_SIZE); 766 goto next_table; 767 } 768 /* 769 * Mark the table to avoid being used in 770 * acpi_table_initrd_override(). Though this is not possible 771 * because override is disabled in acpi_install_physical_table(). 772 */ 773 if (test_and_set_bit(table_index, acpi_initrd_installed)) { 774 acpi_os_unmap_memory(table, ACPI_HEADER_SIZE); 775 goto next_table; 776 } 777 778 pr_info("Table Upgrade: install [%4.4s-%6.6s-%8.8s]\n", 779 table->signature, table->oem_id, 780 table->oem_table_id); 781 acpi_os_unmap_memory(table, ACPI_HEADER_SIZE); 782 acpi_install_physical_table(acpi_tables_addr + table_offset); 783 next_table: 784 table_offset += table_length; 785 table_index++; 786 } 787 } 788 #else 789 static acpi_status 790 acpi_table_initrd_override(struct acpi_table_header *existing_table, 791 acpi_physical_address *address, 792 u32 *table_length) 793 { 794 *table_length = 0; 795 *address = 0; 796 return AE_OK; 797 } 798 799 static void __init acpi_table_initrd_scan(void) 800 { 801 } 802 #endif /* CONFIG_ACPI_TABLE_UPGRADE */ 803 804 acpi_status 805 acpi_os_physical_table_override(struct acpi_table_header *existing_table, 806 acpi_physical_address *address, 807 u32 *table_length) 808 { 809 return acpi_table_initrd_override(existing_table, address, 810 table_length); 811 } 812 813 #ifdef CONFIG_ACPI_CUSTOM_DSDT 814 static void *amlcode __attribute__ ((weakref("AmlCode"))); 815 static void *dsdt_amlcode __attribute__ ((weakref("dsdt_aml_code"))); 816 #endif 817 818 acpi_status acpi_os_table_override(struct acpi_table_header *existing_table, 819 struct acpi_table_header **new_table) 820 { 821 if (!existing_table || !new_table) 822 return AE_BAD_PARAMETER; 823 824 *new_table = NULL; 825 826 #ifdef CONFIG_ACPI_CUSTOM_DSDT 827 if (!strncmp(existing_table->signature, "DSDT", 4)) { 828 *new_table = (struct acpi_table_header *)&amlcode; 829 if (!(*new_table)) 830 *new_table = (struct acpi_table_header *)&dsdt_amlcode; 831 } 832 #endif 833 if (*new_table != NULL) 834 acpi_table_taint(existing_table); 835 return AE_OK; 836 } 837 838 /* 839 * acpi_locate_initial_tables() 840 * 841 * find RSDP, find and checksum SDT/XSDT. 842 * checksum all tables, print SDT/XSDT 843 * 844 * result: sdt_entry[] is initialized 845 */ 846 847 int __init acpi_locate_initial_tables(void) 848 { 849 acpi_status status; 850 851 if (acpi_verify_table_checksum) { 852 pr_info("Early table checksum verification enabled\n"); 853 acpi_gbl_enable_table_validation = TRUE; 854 } else { 855 pr_info("Early table checksum verification disabled\n"); 856 acpi_gbl_enable_table_validation = FALSE; 857 } 858 859 status = acpi_initialize_tables(initial_tables, ACPI_MAX_TABLES, 0); 860 if (ACPI_FAILURE(status)) 861 return -EINVAL; 862 863 return 0; 864 } 865 866 void __init acpi_reserve_initial_tables(void) 867 { 868 int i; 869 870 for (i = 0; i < ACPI_MAX_TABLES; i++) { 871 struct acpi_table_desc *table_desc = &initial_tables[i]; 872 u64 start = table_desc->address; 873 u64 size = table_desc->length; 874 875 if (!start || !size) 876 break; 877 878 pr_info("Reserving %4s table memory at [mem 0x%llx-0x%llx]\n", 879 table_desc->signature.ascii, start, start + size - 1); 880 881 memblock_reserve(start, size); 882 } 883 } 884 885 void __init acpi_table_init_complete(void) 886 { 887 acpi_table_initrd_scan(); 888 check_multiple_madt(); 889 } 890 891 int __init acpi_table_init(void) 892 { 893 int ret; 894 895 ret = acpi_locate_initial_tables(); 896 if (ret) 897 return ret; 898 899 acpi_table_init_complete(); 900 901 return 0; 902 } 903 904 static int __init acpi_parse_apic_instance(char *str) 905 { 906 if (!str) 907 return -EINVAL; 908 909 if (kstrtoint(str, 0, &acpi_apic_instance)) 910 return -EINVAL; 911 912 pr_notice("Shall use APIC/MADT table %d\n", acpi_apic_instance); 913 914 return 0; 915 } 916 early_param("acpi_apic_instance", acpi_parse_apic_instance); 917 918 static int __init acpi_force_table_verification_setup(char *s) 919 { 920 acpi_verify_table_checksum = true; 921 922 return 0; 923 } 924 early_param("acpi_force_table_verification", acpi_force_table_verification_setup); 925 926 static int __init acpi_force_32bit_fadt_addr(char *s) 927 { 928 pr_info("Forcing 32 Bit FADT addresses\n"); 929 acpi_gbl_use32_bit_fadt_addresses = TRUE; 930 931 return 0; 932 } 933 early_param("acpi_force_32bit_fadt_addr", acpi_force_32bit_fadt_addr); 934