drivers/acpi/tables.c

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