drivers/acpi/acpica/tbinstal.c

   1 /******************************************************************************
   2  *
   3  * Module Name: tbinstal - ACPI table installation and removal
   4  *
   5  *****************************************************************************/
   6
   7 /*
   8  * Copyright (C) 2000 - 2015, 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("tbinstal")
  50
  51 /* Local prototypes */
  52 static u8
  53 acpi_tb_compare_tables(struct acpi_table_desc *table_desc, u32 table_index);
  54
  55 /*******************************************************************************
  56  *
  57  * FUNCTION:    acpi_tb_compare_tables
  58  *
  59  * PARAMETERS:  table_desc          - Table 1 descriptor to be compared
  60  *              table_index         - Index of table 2 to be compared
  61  *
  62  * RETURN:      TRUE if both tables are identical.
  63  *
  64  * DESCRIPTION: This function compares a table with another table that has
  65  *              already been installed in the root table list.
  66  *
  67  ******************************************************************************/
  68
  69 static u8
  70 acpi_tb_compare_tables(struct acpi_table_desc *table_desc, u32 table_index)
  71 {
  72         acpi_status status = AE_OK;
  73         u8 is_identical;
  74         struct acpi_table_header *table;
  75         u32 table_length;
  76         u8 table_flags;
  77
  78         status =
  79             acpi_tb_acquire_table(&acpi_gbl_root_table_list.tables[table_index],
  80                                   &table, &table_length, &table_flags);
  81         if (ACPI_FAILURE(status)) {
  82                 return (FALSE);
  83         }
  84
  85         /*
  86          * Check for a table match on the entire table length,
  87          * not just the header.
  88          */
  89         is_identical = (u8)((table_desc->length != table_length ||
  90                              ACPI_MEMCMP(table_desc->pointer, table,
  91                                          table_length)) ? FALSE : TRUE);
  92
  93         /* Release the acquired table */
  94
  95         acpi_tb_release_table(table, table_length, table_flags);
  96         return (is_identical);
  97 }
  98
  99 /*******************************************************************************
 100  *
 101  * FUNCTION:    acpi_tb_install_table_with_override
 102  *
 103  * PARAMETERS:  table_index             - Index into root table array
 104  *              new_table_desc          - New table descriptor to install
 105  *              override                - Whether override should be performed
 106  *
 107  * RETURN:      None
 108  *
 109  * DESCRIPTION: Install an ACPI table into the global data structure. The
 110  *              table override mechanism is called to allow the host
 111  *              OS to replace any table before it is installed in the root
 112  *              table array.
 113  *
 114  ******************************************************************************/
 115
 116 void
 117 acpi_tb_install_table_with_override(u32 table_index,
 118                                     struct acpi_table_desc *new_table_desc,
 119                                     u8 override)
 120 {
 121
 122         if (table_index >= acpi_gbl_root_table_list.current_table_count) {
 123                 return;
 124         }
 125
 126         /*
 127          * ACPI Table Override:
 128          *
 129          * Before we install the table, let the host OS override it with a new
 130          * one if desired. Any table within the RSDT/XSDT can be replaced,
 131          * including the DSDT which is pointed to by the FADT.
 132          */
 133         if (override) {
 134                 acpi_tb_override_table(new_table_desc);
 135         }
 136
 137         acpi_tb_init_table_descriptor(&acpi_gbl_root_table_list.
 138                                       tables[table_index],
 139                                       new_table_desc->address,
 140                                       new_table_desc->flags,
 141                                       new_table_desc->pointer);
 142
 143         acpi_tb_print_table_header(new_table_desc->address,
 144                                    new_table_desc->pointer);
 145
 146         /* Set the global integer width (based upon revision of the DSDT) */
 147
 148         if (table_index == ACPI_TABLE_INDEX_DSDT) {
 149                 acpi_ut_set_integer_width(new_table_desc->pointer->revision);
 150         }
 151 }
 152
 153 /*******************************************************************************
 154  *
 155  * FUNCTION:    acpi_tb_install_fixed_table
 156  *
 157  * PARAMETERS:  address                 - Physical address of DSDT or FACS
 158  *              signature               - Table signature, NULL if no need to
 159  *                                        match
 160  *              table_index             - Index into root table array
 161  *
 162  * RETURN:      Status
 163  *
 164  * DESCRIPTION: Install a fixed ACPI table (DSDT/FACS) into the global data
 165  *              structure.
 166  *
 167  ******************************************************************************/
 168
 169 acpi_status
 170 acpi_tb_install_fixed_table(acpi_physical_address address,
 171                             char *signature, u32 table_index)
 172 {
 173         struct acpi_table_desc new_table_desc;
 174         acpi_status status;
 175
 176         ACPI_FUNCTION_TRACE(tb_install_fixed_table);
 177
 178         if (!address) {
 179                 ACPI_ERROR((AE_INFO,
 180                             "Null physical address for ACPI table [%s]",
 181                             signature));
 182                 return (AE_NO_MEMORY);
 183         }
 184
 185         /* Fill a table descriptor for validation */
 186
 187         status = acpi_tb_acquire_temp_table(&new_table_desc, address,
 188                                             ACPI_TABLE_ORIGIN_INTERNAL_PHYSICAL);
 189         if (ACPI_FAILURE(status)) {
 190                 ACPI_ERROR((AE_INFO, "Could not acquire table length at %p",
 191                             ACPI_PHYSADDR_TO_PTR(address)));
 192                 return_ACPI_STATUS(status);
 193         }
 194
 195         /* Validate and verify a table before installation */
 196
 197         status = acpi_tb_verify_temp_table(&new_table_desc, signature);
 198         if (ACPI_FAILURE(status)) {
 199                 goto release_and_exit;
 200         }
 201
 202         acpi_tb_install_table_with_override(table_index, &new_table_desc, TRUE);
 203
 204 release_and_exit:
 205
 206         /* Release the temporary table descriptor */
 207
 208         acpi_tb_release_temp_table(&new_table_desc);
 209         return_ACPI_STATUS(status);
 210 }
 211
 212 /*******************************************************************************
 213  *
 214  * FUNCTION:    acpi_tb_install_standard_table
 215  *
 216  * PARAMETERS:  address             - Address of the table (might be a virtual
 217  *                                    address depending on the table_flags)
 218  *              flags               - Flags for the table
 219  *              reload              - Whether reload should be performed
 220  *              override            - Whether override should be performed
 221  *              table_index         - Where the table index is returned
 222  *
 223  * RETURN:      Status
 224  *
 225  * DESCRIPTION: This function is called to install an ACPI table that is
 226  *              neither DSDT nor FACS (a "standard" table.)
 227  *              When this function is called by "Load" or "LoadTable" opcodes,
 228  *              or by acpi_load_table() API, the "Reload" parameter is set.
 229  *              After sucessfully returning from this function, table is
 230  *              "INSTALLED" but not "VALIDATED".
 231  *
 232  ******************************************************************************/
 233
 234 acpi_status
 235 acpi_tb_install_standard_table(acpi_physical_address address,
 236                                u8 flags,
 237                                u8 reload, u8 override, u32 *table_index)
 238 {
 239         u32 i;
 240         acpi_status status = AE_OK;
 241         struct acpi_table_desc new_table_desc;
 242
 243         ACPI_FUNCTION_TRACE(tb_install_standard_table);
 244
 245         /* Acquire a temporary table descriptor for validation */
 246
 247         status = acpi_tb_acquire_temp_table(&new_table_desc, address, flags);
 248         if (ACPI_FAILURE(status)) {
 249                 ACPI_ERROR((AE_INFO, "Could not acquire table length at %p",
 250                             ACPI_PHYSADDR_TO_PTR(address)));
 251                 return_ACPI_STATUS(status);
 252         }
 253
 254         /*
 255          * Optionally do not load any SSDTs from the RSDT/XSDT. This can
 256          * be useful for debugging ACPI problems on some machines.
 257          */
 258         if (!reload &&
 259             acpi_gbl_disable_ssdt_table_install &&
 260             ACPI_COMPARE_NAME(&new_table_desc.signature, ACPI_SIG_SSDT)) {
 261                 ACPI_INFO((AE_INFO, "Ignoring installation of %4.4s at %p",
 262                            new_table_desc.signature.ascii,
 263                            ACPI_PHYSADDR_TO_PTR(address)));
 264                 goto release_and_exit;
 265         }
 266
 267         /* Validate and verify a table before installation */
 268
 269         status = acpi_tb_verify_temp_table(&new_table_desc, NULL);
 270         if (ACPI_FAILURE(status)) {
 271                 goto release_and_exit;
 272         }
 273
 274         if (reload) {
 275                 /*
 276                  * Validate the incoming table signature.
 277                  *
 278                  * 1) Originally, we checked the table signature for "SSDT" or "PSDT".
 279                  * 2) We added support for OEMx tables, signature "OEM".
 280                  * 3) Valid tables were encountered with a null signature, so we just
 281                  *    gave up on validating the signature, (05/2008).
 282                  * 4) We encountered non-AML tables such as the MADT, which caused
 283                  *    interpreter errors and kernel faults. So now, we once again allow
 284                  *    only "SSDT", "OEMx", and now, also a null signature. (05/2011).
 285                  */
 286                 if ((new_table_desc.signature.ascii[0] != 0x00) &&
 287                     (!ACPI_COMPARE_NAME
 288                      (&new_table_desc.signature, ACPI_SIG_SSDT))
 289                     && (ACPI_STRNCMP(new_table_desc.signature.ascii, "OEM", 3)))
 290                 {
 291                         ACPI_BIOS_ERROR((AE_INFO,
 292                                          "Table has invalid signature [%4.4s] (0x%8.8X), "
 293                                          "must be SSDT or OEMx",
 294                                          acpi_ut_valid_acpi_name(new_table_desc.
 295                                                                  signature.
 296                                                                  ascii) ?
 297                                          new_table_desc.signature.
 298                                          ascii : "????",
 299                                          new_table_desc.signature.integer));
 300
 301                         status = AE_BAD_SIGNATURE;
 302                         goto release_and_exit;
 303                 }
 304
 305                 /* Check if table is already registered */
 306
 307                 for (i = 0; i < acpi_gbl_root_table_list.current_table_count;
 308                      ++i) {
 309                         /*
 310                          * Check for a table match on the entire table length,
 311                          * not just the header.
 312                          */
 313                         if (!acpi_tb_compare_tables(&new_table_desc, i)) {
 314                                 continue;
 315                         }
 316
 317                         /*
 318                          * Note: the current mechanism does not unregister a table if it is
 319                          * dynamically unloaded. The related namespace entries are deleted,
 320                          * but the table remains in the root table list.
 321                          *
 322                          * The assumption here is that the number of different tables that
 323                          * will be loaded is actually small, and there is minimal overhead
 324                          * in just keeping the table in case it is needed again.
 325                          *
 326                          * If this assumption changes in the future (perhaps on large
 327                          * machines with many table load/unload operations), tables will
 328                          * need to be unregistered when they are unloaded, and slots in the
 329                          * root table list should be reused when empty.
 330                          */
 331                         if (acpi_gbl_root_table_list.tables[i].
 332                             flags & ACPI_TABLE_IS_LOADED) {
 333
 334                                 /* Table is still loaded, this is an error */
 335
 336                                 status = AE_ALREADY_EXISTS;
 337                                 goto release_and_exit;
 338                         } else {
 339                                 /*
 340                                  * Table was unloaded, allow it to be reloaded.
 341                                  * As we are going to return AE_OK to the caller, we should
 342                                  * take the responsibility of freeing the input descriptor.
 343                                  * Refill the input descriptor to ensure
 344                                  * acpi_tb_install_table_with_override() can be called again to
 345                                  * indicate the re-installation.
 346                                  */
 347                                 acpi_tb_uninstall_table(&new_table_desc);
 348                                 *table_index = i;
 349                                 (void)acpi_ut_release_mutex(ACPI_MTX_TABLES);
 350                                 return_ACPI_STATUS(AE_OK);
 351                         }
 352                 }
 353         }
 354
 355         /* Add the table to the global root table list */
 356
 357         status = acpi_tb_get_next_root_index(&i);
 358         if (ACPI_FAILURE(status)) {
 359                 goto release_and_exit;
 360         }
 361
 362         *table_index = i;
 363         acpi_tb_install_table_with_override(i, &new_table_desc, override);
 364
 365 release_and_exit:
 366
 367         /* Release the temporary table descriptor */
 368
 369         acpi_tb_release_temp_table(&new_table_desc);
 370         return_ACPI_STATUS(status);
 371 }
 372
 373 /*******************************************************************************
 374  *
 375  * FUNCTION:    acpi_tb_override_table
 376  *
 377  * PARAMETERS:  old_table_desc      - Validated table descriptor to be
 378  *                                    overridden
 379  *
 380  * RETURN:      None
 381  *
 382  * DESCRIPTION: Attempt table override by calling the OSL override functions.
 383  *              Note: If the table is overridden, then the entire new table
 384  *              is acquired and returned by this function.
 385  *              Before/after invocation, the table descriptor is in a state
 386  *              that is "VALIDATED".
 387  *
 388  ******************************************************************************/
 389
 390 void acpi_tb_override_table(struct acpi_table_desc *old_table_desc)
 391 {
 392         acpi_status status;
 393         char *override_type;
 394         struct acpi_table_desc new_table_desc;
 395         struct acpi_table_header *table;
 396         acpi_physical_address address;
 397         u32 length;
 398
 399         /* (1) Attempt logical override (returns a logical address) */
 400
 401         status = acpi_os_table_override(old_table_desc->pointer, &table);
 402         if (ACPI_SUCCESS(status) && table) {
 403                 acpi_tb_acquire_temp_table(&new_table_desc,
 404                                            ACPI_PTR_TO_PHYSADDR(table),
 405                                            ACPI_TABLE_ORIGIN_EXTERNAL_VIRTUAL);
 406                 override_type = "Logical";
 407                 goto finish_override;
 408         }
 409
 410         /* (2) Attempt physical override (returns a physical address) */
 411
 412         status = acpi_os_physical_table_override(old_table_desc->pointer,
 413                                                  &address, &length);
 414         if (ACPI_SUCCESS(status) && address && length) {
 415                 acpi_tb_acquire_temp_table(&new_table_desc, address,
 416                                            ACPI_TABLE_ORIGIN_INTERNAL_PHYSICAL);
 417                 override_type = "Physical";
 418                 goto finish_override;
 419         }
 420
 421         return;                 /* There was no override */
 422
 423 finish_override:
 424
 425         /* Validate and verify a table before overriding */
 426
 427         status = acpi_tb_verify_temp_table(&new_table_desc, NULL);
 428         if (ACPI_FAILURE(status)) {
 429                 return;
 430         }
 431
 432         ACPI_INFO((AE_INFO, "%4.4s " ACPI_PRINTF_UINT
 433                    " %s table override, new table: " ACPI_PRINTF_UINT,
 434                    old_table_desc->signature.ascii,
 435                    ACPI_FORMAT_TO_UINT(old_table_desc->address),
 436                    override_type, ACPI_FORMAT_TO_UINT(new_table_desc.address)));
 437
 438         /* We can now uninstall the original table */
 439
 440         acpi_tb_uninstall_table(old_table_desc);
 441
 442         /*
 443          * Replace the original table descriptor and keep its state as
 444          * "VALIDATED".
 445          */
 446         acpi_tb_init_table_descriptor(old_table_desc, new_table_desc.address,
 447                                       new_table_desc.flags,
 448                                       new_table_desc.pointer);
 449         acpi_tb_validate_temp_table(old_table_desc);
 450
 451         /* Release the temporary table descriptor */
 452
 453         acpi_tb_release_temp_table(&new_table_desc);
 454 }
 455
 456 /*******************************************************************************
 457  *
 458  * FUNCTION:    acpi_tb_store_table
 459  *
 460  * PARAMETERS:  address             - Table address
 461  *              table               - Table header
 462  *              length              - Table length
 463  *              flags               - Install flags
 464  *              table_index         - Where the table index is returned
 465  *
 466  * RETURN:      Status and table index.
 467  *
 468  * DESCRIPTION: Add an ACPI table to the global table list
 469  *
 470  ******************************************************************************/
 471
 472 acpi_status
 473 acpi_tb_store_table(acpi_physical_address address,
 474                     struct acpi_table_header * table,
 475                     u32 length, u8 flags, u32 *table_index)
 476 {
 477         acpi_status status;
 478         struct acpi_table_desc *table_desc;
 479
 480         status = acpi_tb_get_next_root_index(table_index);
 481         if (ACPI_FAILURE(status)) {
 482                 return (status);
 483         }
 484
 485         /* Initialize added table */
 486
 487         table_desc = &acpi_gbl_root_table_list.tables[*table_index];
 488         acpi_tb_init_table_descriptor(table_desc, address, flags, table);
 489         table_desc->pointer = table;
 490         return (AE_OK);
 491 }
 492
 493 /*******************************************************************************
 494  *
 495  * FUNCTION:    acpi_tb_uninstall_table
 496  *
 497  * PARAMETERS:  table_desc          - Table descriptor
 498  *
 499  * RETURN:      None
 500  *
 501  * DESCRIPTION: Delete one internal ACPI table
 502  *
 503  ******************************************************************************/
 504
 505 void acpi_tb_uninstall_table(struct acpi_table_desc *table_desc)
 506 {
 507
 508         ACPI_FUNCTION_TRACE(tb_uninstall_table);
 509
 510         /* Table must be installed */
 511
 512         if (!table_desc->address) {
 513                 return_VOID;
 514         }
 515
 516         acpi_tb_invalidate_table(table_desc);
 517
 518         if ((table_desc->flags & ACPI_TABLE_ORIGIN_MASK) ==
 519             ACPI_TABLE_ORIGIN_INTERNAL_VIRTUAL) {
 520                 ACPI_FREE(ACPI_PHYSADDR_TO_PTR(table_desc->address));
 521         }
 522
 523         table_desc->address = ACPI_PTR_TO_PHYSADDR(NULL);
 524         return_VOID;
 525 }