drivers/acpi/acpica/tbutils.c

   1 /******************************************************************************
   2  *
   3  * Module Name: tbutils - ACPI Table utilities
   4  *
   5  *****************************************************************************/
   6
   7 /*
   8  * Copyright (C) 2000 - 2013, Intel Corp.
   9  * All rights reserved.
  10  *
  11  * Redistribution and use in source and binary forms, with or without
  12  * modification, are permitted provided that the following conditions
  13  * are met:
  14  * 1. Redistributions of source code must retain the above copyright
  15  *    notice, this list of conditions, and the following disclaimer,
  16  *    without modification.
  17  * 2. Redistributions in binary form must reproduce at minimum a disclaimer
  18  *    substantially similar to the "NO WARRANTY" disclaimer below
  19  *    ("Disclaimer") and any redistribution must be conditioned upon
  20  *    including a substantially similar Disclaimer requirement for further
  21  *    binary redistribution.
  22  * 3. Neither the names of the above-listed copyright holders nor the names
  23  *    of any contributors may be used to endorse or promote products derived
  24  *    from this software without specific prior written permission.
  25  *
  26  * Alternatively, this software may be distributed under the terms of the
  27  * GNU General Public License ("GPL") version 2 as published by the Free
  28  * Software Foundation.
  29  *
  30  * NO WARRANTY
  31  * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
  32  * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
  33  * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTIBILITY AND FITNESS FOR
  34  * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
  35  * HOLDERS OR CONTRIBUTORS BE LIABLE FOR SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
  36  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
  37  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
  38  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
  39  * STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING
  40  * IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
  41  * POSSIBILITY OF SUCH DAMAGES.
  42  */
  43
  44 #include <acpi/acpi.h>
  45 #include "accommon.h"
  46 #include "actables.h"
  47
  48 #define _COMPONENT          ACPI_TABLES
  49 ACPI_MODULE_NAME("tbutils")
  50
  51 /* Local prototypes */
  52 static acpi_physical_address
  53 acpi_tb_get_root_table_entry(u8 *table_entry, u32 table_entry_size);
  54
  55 /*******************************************************************************
  56  *
  57  * FUNCTION:    acpi_tb_check_xsdt
  58  *
  59  * PARAMETERS:  address                    - Pointer to the XSDT
  60  *
  61  * RETURN:      status
  62  *              AE_OK - XSDT is okay
  63  *              AE_NO_MEMORY - can't map XSDT
  64  *              AE_INVALID_TABLE_LENGTH - invalid table length
  65  *              AE_NULL_ENTRY - XSDT has NULL entry
  66  *
  67  * DESCRIPTION: validate XSDT
  68 ******************************************************************************/
  69
  70 static acpi_status
  71 acpi_tb_check_xsdt(acpi_physical_address address)
  72 {
  73         struct acpi_table_header *table;
  74         u32 length;
  75         u64 xsdt_entry_address;
  76         u8 *table_entry;
  77         u32 table_count;
  78         int i;
  79
  80         table = acpi_os_map_memory(address, sizeof(struct acpi_table_header));
  81         if (!table)
  82                 return AE_NO_MEMORY;
  83
  84         length = table->length;
  85         acpi_os_unmap_memory(table, sizeof(struct acpi_table_header));
  86         if (length < sizeof(struct acpi_table_header))
  87                 return AE_INVALID_TABLE_LENGTH;
  88
  89         table = acpi_os_map_memory(address, length);
  90         if (!table)
  91                 return AE_NO_MEMORY;
  92
  93         /* Calculate the number of tables described in XSDT */
  94         table_count =
  95                 (u32) ((table->length -
  96                 sizeof(struct acpi_table_header)) / sizeof(u64));
  97         table_entry =
  98                 ACPI_CAST_PTR(u8, table) + sizeof(struct acpi_table_header);
  99         for (i = 0; i < table_count; i++) {
 100                 ACPI_MOVE_64_TO_64(&xsdt_entry_address, table_entry);
 101                 if (!xsdt_entry_address) {
 102                         /* XSDT has NULL entry */
 103                         break;
 104                 }
 105                 table_entry += sizeof(u64);
 106         }
 107         acpi_os_unmap_memory(table, length);
 108
 109         if (i < table_count)
 110                 return AE_NULL_ENTRY;
 111         else
 112                 return AE_OK;
 113 }
 114
 115 #if (!ACPI_REDUCED_HARDWARE)
 116 /*******************************************************************************
 117  *
 118  * FUNCTION:    acpi_tb_initialize_facs
 119  *
 120  * PARAMETERS:  None
 121  *
 122  * RETURN:      Status
 123  *
 124  * DESCRIPTION: Create a permanent mapping for the FADT and save it in a global
 125  *              for accessing the Global Lock and Firmware Waking Vector
 126  *
 127  ******************************************************************************/
 128
 129 acpi_status acpi_tb_initialize_facs(void)
 130 {
 131         acpi_status status;
 132
 133         /* If Hardware Reduced flag is set, there is no FACS */
 134
 135         if (acpi_gbl_reduced_hardware) {
 136                 acpi_gbl_FACS = NULL;
 137                 return (AE_OK);
 138         }
 139
 140         status = acpi_get_table_by_index(ACPI_TABLE_INDEX_FACS,
 141                                          ACPI_CAST_INDIRECT_PTR(struct
 142                                                                 acpi_table_header,
 143                                                                 &acpi_gbl_FACS));
 144         return (status);
 145 }
 146 #endif                          /* !ACPI_REDUCED_HARDWARE */
 147
 148 /*******************************************************************************
 149  *
 150  * FUNCTION:    acpi_tb_tables_loaded
 151  *
 152  * PARAMETERS:  None
 153  *
 154  * RETURN:      TRUE if required ACPI tables are loaded
 155  *
 156  * DESCRIPTION: Determine if the minimum required ACPI tables are present
 157  *              (FADT, FACS, DSDT)
 158  *
 159  ******************************************************************************/
 160
 161 u8 acpi_tb_tables_loaded(void)
 162 {
 163
 164         if (acpi_gbl_root_table_list.current_table_count >= 3) {
 165                 return (TRUE);
 166         }
 167
 168         return (FALSE);
 169 }
 170
 171 /*******************************************************************************
 172  *
 173  * FUNCTION:    acpi_tb_check_dsdt_header
 174  *
 175  * PARAMETERS:  None
 176  *
 177  * RETURN:      None
 178  *
 179  * DESCRIPTION: Quick compare to check validity of the DSDT. This will detect
 180  *              if the DSDT has been replaced from outside the OS and/or if
 181  *              the DSDT header has been corrupted.
 182  *
 183  ******************************************************************************/
 184
 185 void acpi_tb_check_dsdt_header(void)
 186 {
 187
 188         /* Compare original length and checksum to current values */
 189
 190         if (acpi_gbl_original_dsdt_header.length != acpi_gbl_DSDT->length ||
 191             acpi_gbl_original_dsdt_header.checksum != acpi_gbl_DSDT->checksum) {
 192                 ACPI_BIOS_ERROR((AE_INFO,
 193                                  "The DSDT has been corrupted or replaced - "
 194                                  "old, new headers below"));
 195                 acpi_tb_print_table_header(0, &acpi_gbl_original_dsdt_header);
 196                 acpi_tb_print_table_header(0, acpi_gbl_DSDT);
 197
 198                 ACPI_ERROR((AE_INFO,
 199                             "Please send DMI info to linux-acpi@vger.kernel.org\n"
 200                             "If system does not work as expected, please boot with acpi=copy_dsdt"));
 201
 202                 /* Disable further error messages */
 203
 204                 acpi_gbl_original_dsdt_header.length = acpi_gbl_DSDT->length;
 205                 acpi_gbl_original_dsdt_header.checksum =
 206                     acpi_gbl_DSDT->checksum;
 207         }
 208 }
 209
 210 /*******************************************************************************
 211  *
 212  * FUNCTION:    acpi_tb_copy_dsdt
 213  *
 214  * PARAMETERS:  table_desc          - Installed table to copy
 215  *
 216  * RETURN:      None
 217  *
 218  * DESCRIPTION: Implements a subsystem option to copy the DSDT to local memory.
 219  *              Some very bad BIOSs are known to either corrupt the DSDT or
 220  *              install a new, bad DSDT. This copy works around the problem.
 221  *
 222  ******************************************************************************/
 223
 224 struct acpi_table_header *acpi_tb_copy_dsdt(u32 table_index)
 225 {
 226         struct acpi_table_header *new_table;
 227         struct acpi_table_desc *table_desc;
 228
 229         table_desc = &acpi_gbl_root_table_list.tables[table_index];
 230
 231         new_table = ACPI_ALLOCATE(table_desc->length);
 232         if (!new_table) {
 233                 ACPI_ERROR((AE_INFO, "Could not copy DSDT of length 0x%X",
 234                             table_desc->length));
 235                 return (NULL);
 236         }
 237
 238         ACPI_MEMCPY(new_table, table_desc->pointer, table_desc->length);
 239         acpi_tb_delete_table(table_desc);
 240         table_desc->pointer = new_table;
 241         table_desc->flags = ACPI_TABLE_ORIGIN_ALLOCATED;
 242
 243         ACPI_INFO((AE_INFO,
 244                    "Forced DSDT copy: length 0x%05X copied locally, original unmapped",
 245                    new_table->length));
 246
 247         return (new_table);
 248 }
 249
 250 /*******************************************************************************
 251  *
 252  * FUNCTION:    acpi_tb_install_table
 253  *
 254  * PARAMETERS:  address                 - Physical address of DSDT or FACS
 255  *              signature               - Table signature, NULL if no need to
 256  *                                        match
 257  *              table_index             - Index into root table array
 258  *
 259  * RETURN:      None
 260  *
 261  * DESCRIPTION: Install an ACPI table into the global data structure. The
 262  *              table override mechanism is called to allow the host
 263  *              OS to replace any table before it is installed in the root
 264  *              table array.
 265  *
 266  ******************************************************************************/
 267
 268 void
 269 acpi_tb_install_table(acpi_physical_address address,
 270                       char *signature, u32 table_index)
 271 {
 272         struct acpi_table_header *table;
 273         struct acpi_table_header *final_table;
 274         struct acpi_table_desc *table_desc;
 275
 276         if (!address) {
 277                 ACPI_ERROR((AE_INFO,
 278                             "Null physical address for ACPI table [%s]",
 279                             signature));
 280                 return;
 281         }
 282
 283         /* Map just the table header */
 284
 285         table = acpi_os_map_memory(address, sizeof(struct acpi_table_header));
 286         if (!table) {
 287                 ACPI_ERROR((AE_INFO,
 288                             "Could not map memory for table [%s] at %p",
 289                             signature, ACPI_CAST_PTR(void, address)));
 290                 return;
 291         }
 292
 293         /* If a particular signature is expected (DSDT/FACS), it must match */
 294
 295         if (signature && !ACPI_COMPARE_NAME(table->signature, signature)) {
 296                 ACPI_BIOS_ERROR((AE_INFO,
 297                                  "Invalid signature 0x%X for ACPI table, expected [%s]",
 298                                  *ACPI_CAST_PTR(u32, table->signature),
 299                                  signature));
 300                 goto unmap_and_exit;
 301         }
 302
 303         /*
 304          * Initialize the table entry. Set the pointer to NULL, since the
 305          * table is not fully mapped at this time.
 306          */
 307         table_desc = &acpi_gbl_root_table_list.tables[table_index];
 308
 309         table_desc->address = address;
 310         table_desc->pointer = NULL;
 311         table_desc->length = table->length;
 312         table_desc->flags = ACPI_TABLE_ORIGIN_MAPPED;
 313         ACPI_MOVE_32_TO_32(table_desc->signature.ascii, table->signature);
 314
 315         /*
 316          * ACPI Table Override:
 317          *
 318          * Before we install the table, let the host OS override it with a new
 319          * one if desired. Any table within the RSDT/XSDT can be replaced,
 320          * including the DSDT which is pointed to by the FADT.
 321          *
 322          * NOTE: If the table is overridden, then final_table will contain a
 323          * mapped pointer to the full new table. If the table is not overridden,
 324          * or if there has been a physical override, then the table will be
 325          * fully mapped later (in verify table). In any case, we must
 326          * unmap the header that was mapped above.
 327          */
 328         final_table = acpi_tb_table_override(table, table_desc);
 329         if (!final_table) {
 330                 final_table = table;    /* There was no override */
 331         }
 332
 333         acpi_tb_print_table_header(table_desc->address, final_table);
 334
 335         /* Set the global integer width (based upon revision of the DSDT) */
 336
 337         if (table_index == ACPI_TABLE_INDEX_DSDT) {
 338                 acpi_ut_set_integer_width(final_table->revision);
 339         }
 340
 341         /*
 342          * If we have a physical override during this early loading of the ACPI
 343          * tables, unmap the table for now. It will be mapped again later when
 344          * it is actually used. This supports very early loading of ACPI tables,
 345          * before virtual memory is fully initialized and running within the
 346          * host OS. Note: A logical override has the ACPI_TABLE_ORIGIN_OVERRIDE
 347          * flag set and will not be deleted below.
 348          */
 349         if (final_table != table) {
 350                 acpi_tb_delete_table(table_desc);
 351         }
 352
 353       unmap_and_exit:
 354
 355         /* Always unmap the table header that we mapped above */
 356
 357         acpi_os_unmap_memory(table, sizeof(struct acpi_table_header));
 358 }
 359
 360 /*******************************************************************************
 361  *
 362  * FUNCTION:    acpi_tb_get_root_table_entry
 363  *
 364  * PARAMETERS:  table_entry         - Pointer to the RSDT/XSDT table entry
 365  *              table_entry_size    - sizeof 32 or 64 (RSDT or XSDT)
 366  *
 367  * RETURN:      Physical address extracted from the root table
 368  *
 369  * DESCRIPTION: Get one root table entry. Handles 32-bit and 64-bit cases on
 370  *              both 32-bit and 64-bit platforms
 371  *
 372  * NOTE:        acpi_physical_address is 32-bit on 32-bit platforms, 64-bit on
 373  *              64-bit platforms.
 374  *
 375  ******************************************************************************/
 376
 377 static acpi_physical_address
 378 acpi_tb_get_root_table_entry(u8 *table_entry, u32 table_entry_size)
 379 {
 380         u64 address64;
 381
 382         /*
 383          * Get the table physical address (32-bit for RSDT, 64-bit for XSDT):
 384          * Note: Addresses are 32-bit aligned (not 64) in both RSDT and XSDT
 385          */
 386         if (table_entry_size == sizeof(u32)) {
 387                 /*
 388                  * 32-bit platform, RSDT: Return 32-bit table entry
 389                  * 64-bit platform, RSDT: Expand 32-bit to 64-bit and return
 390                  */
 391                 return ((acpi_physical_address)
 392                         (*ACPI_CAST_PTR(u32, table_entry)));
 393         } else {
 394                 /*
 395                  * 32-bit platform, XSDT: Truncate 64-bit to 32-bit and return
 396                  * 64-bit platform, XSDT: Move (unaligned) 64-bit to local,
 397                  *  return 64-bit
 398                  */
 399                 ACPI_MOVE_64_TO_64(&address64, table_entry);
 400
 401 #if ACPI_MACHINE_WIDTH == 32
 402                 if (address64 > ACPI_UINT32_MAX) {
 403
 404                         /* Will truncate 64-bit address to 32 bits, issue warning */
 405
 406                         ACPI_BIOS_WARNING((AE_INFO,
 407                                            "64-bit Physical Address in XSDT is too large (0x%8.8X%8.8X),"
 408                                            " truncating",
 409                                            ACPI_FORMAT_UINT64(address64)));
 410                 }
 411 #endif
 412                 return ((acpi_physical_address) (address64));
 413         }
 414 }
 415
 416 /*******************************************************************************
 417  *
 418  * FUNCTION:    acpi_tb_parse_root_table
 419  *
 420  * PARAMETERS:  rsdp                    - Pointer to the RSDP
 421  *
 422  * RETURN:      Status
 423  *
 424  * DESCRIPTION: This function is called to parse the Root System Description
 425  *              Table (RSDT or XSDT)
 426  *
 427  * NOTE:        Tables are mapped (not copied) for efficiency. The FACS must
 428  *              be mapped and cannot be copied because it contains the actual
 429  *              memory location of the ACPI Global Lock.
 430  *
 431  ******************************************************************************/
 432
 433 acpi_status __init
 434 acpi_tb_parse_root_table(acpi_physical_address rsdp_address)
 435 {
 436         struct acpi_table_rsdp *rsdp;
 437         u32 table_entry_size;
 438         u32 i;
 439         u32 table_count;
 440         struct acpi_table_header *table;
 441         acpi_physical_address address;
 442         acpi_physical_address uninitialized_var(rsdt_address);
 443         u32 length;
 444         u8 *table_entry;
 445         acpi_status status;
 446
 447         ACPI_FUNCTION_TRACE(tb_parse_root_table);
 448
 449         /*
 450          * Map the entire RSDP and extract the address of the RSDT or XSDT
 451          */
 452         rsdp = acpi_os_map_memory(rsdp_address, sizeof(struct acpi_table_rsdp));
 453         if (!rsdp) {
 454                 return_ACPI_STATUS(AE_NO_MEMORY);
 455         }
 456
 457         acpi_tb_print_table_header(rsdp_address,
 458                                    ACPI_CAST_PTR(struct acpi_table_header,
 459                                                  rsdp));
 460
 461         /* Differentiate between RSDT and XSDT root tables */
 462
 463         if (rsdp->revision > 1 && rsdp->xsdt_physical_address
 464                         && !acpi_rsdt_forced) {
 465                 /*
 466                  * Root table is an XSDT (64-bit physical addresses). We must use the
 467                  * XSDT if the revision is > 1 and the XSDT pointer is present, as per
 468                  * the ACPI specification.
 469                  */
 470                 address = (acpi_physical_address) rsdp->xsdt_physical_address;
 471                 table_entry_size = sizeof(u64);
 472                 rsdt_address = (acpi_physical_address)
 473                                         rsdp->rsdt_physical_address;
 474         } else {
 475                 /* Root table is an RSDT (32-bit physical addresses) */
 476
 477                 address = (acpi_physical_address) rsdp->rsdt_physical_address;
 478                 table_entry_size = sizeof(u32);
 479         }
 480
 481         /*
 482          * It is not possible to map more than one entry in some environments,
 483          * so unmap the RSDP here before mapping other tables
 484          */
 485         acpi_os_unmap_memory(rsdp, sizeof(struct acpi_table_rsdp));
 486
 487         if (table_entry_size == sizeof(u64)) {
 488                 if (acpi_tb_check_xsdt(address) == AE_NULL_ENTRY) {
 489                         /* XSDT has NULL entry, RSDT is used */
 490                         address = rsdt_address;
 491                         table_entry_size = sizeof(u32);
 492                         ACPI_WARNING((AE_INFO, "BIOS XSDT has NULL entry, "
 493                                         "using RSDT"));
 494                 }
 495         }
 496         /* Map the RSDT/XSDT table header to get the full table length */
 497
 498         table = acpi_os_map_memory(address, sizeof(struct acpi_table_header));
 499         if (!table) {
 500                 return_ACPI_STATUS(AE_NO_MEMORY);
 501         }
 502
 503         acpi_tb_print_table_header(address, table);
 504
 505         /* Get the length of the full table, verify length and map entire table */
 506
 507         length = table->length;
 508         acpi_os_unmap_memory(table, sizeof(struct acpi_table_header));
 509
 510         if (length < sizeof(struct acpi_table_header)) {
 511                 ACPI_BIOS_ERROR((AE_INFO,
 512                                  "Invalid table length 0x%X in RSDT/XSDT",
 513                                  length));
 514                 return_ACPI_STATUS(AE_INVALID_TABLE_LENGTH);
 515         }
 516
 517         table = acpi_os_map_memory(address, length);
 518         if (!table) {
 519                 return_ACPI_STATUS(AE_NO_MEMORY);
 520         }
 521
 522         /* Validate the root table checksum */
 523
 524         status = acpi_tb_verify_checksum(table, length);
 525         if (ACPI_FAILURE(status)) {
 526                 acpi_os_unmap_memory(table, length);
 527                 return_ACPI_STATUS(status);
 528         }
 529
 530         /* Calculate the number of tables described in the root table */
 531
 532         table_count = (u32)((table->length - sizeof(struct acpi_table_header)) /
 533                             table_entry_size);
 534         /*
 535          * First two entries in the table array are reserved for the DSDT
 536          * and FACS, which are not actually present in the RSDT/XSDT - they
 537          * come from the FADT
 538          */
 539         table_entry =
 540             ACPI_CAST_PTR(u8, table) + sizeof(struct acpi_table_header);
 541         acpi_gbl_root_table_list.current_table_count = 2;
 542
 543         /*
 544          * Initialize the root table array from the RSDT/XSDT
 545          */
 546         for (i = 0; i < table_count; i++) {
 547                 if (acpi_gbl_root_table_list.current_table_count >=
 548                     acpi_gbl_root_table_list.max_table_count) {
 549
 550                         /* There is no more room in the root table array, attempt resize */
 551
 552                         status = acpi_tb_resize_root_table_list();
 553                         if (ACPI_FAILURE(status)) {
 554                                 ACPI_WARNING((AE_INFO,
 555                                               "Truncating %u table entries!",
 556                                               (unsigned) (table_count -
 557                                                (acpi_gbl_root_table_list.
 558                                                           current_table_count -
 559                                                           2))));
 560                                 break;
 561                         }
 562                 }
 563
 564                 /* Get the table physical address (32-bit for RSDT, 64-bit for XSDT) */
 565
 566                 acpi_gbl_root_table_list.tables[acpi_gbl_root_table_list.
 567                                                 current_table_count].address =
 568                     acpi_tb_get_root_table_entry(table_entry, table_entry_size);
 569
 570                 table_entry += table_entry_size;
 571                 acpi_gbl_root_table_list.current_table_count++;
 572         }
 573
 574         /*
 575          * It is not possible to map more than one entry in some environments,
 576          * so unmap the root table here before mapping other tables
 577          */
 578         acpi_os_unmap_memory(table, length);
 579
 580         /*
 581          * Complete the initialization of the root table array by examining
 582          * the header of each table
 583          */
 584         for (i = 2; i < acpi_gbl_root_table_list.current_table_count; i++) {
 585                 acpi_tb_install_table(acpi_gbl_root_table_list.tables[i].
 586                                       address, NULL, i);
 587
 588                 /* Special case for FADT - get the DSDT and FACS */
 589
 590                 if (ACPI_COMPARE_NAME
 591                     (&acpi_gbl_root_table_list.tables[i].signature,
 592                      ACPI_SIG_FADT)) {
 593                         acpi_tb_parse_fadt(i);
 594                 }
 595         }
 596
 597         return_ACPI_STATUS(AE_OK);
 598 }