drivers/acpi/acpica/tbdata.c

   1 /******************************************************************************
   2  *
   3  * Module Name: tbdata - Table manager data structure functions
   4  *
   5  *****************************************************************************/
   6
   7 /*
   8  * Copyright (C) 2000 - 2017, 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 "acnamesp.h"
  47 #include "actables.h"
  48 #include "acevents.h"
  49
  50 #define _COMPONENT          ACPI_TABLES
  51 ACPI_MODULE_NAME("tbdata")
  52
  53 /* Local prototypes */
  54 static acpi_status
  55 acpi_tb_check_duplication(struct acpi_table_desc *table_desc, u32 *table_index);
  56
  57 static u8
  58 acpi_tb_compare_tables(struct acpi_table_desc *table_desc, u32 table_index);
  59
  60 /*******************************************************************************
  61  *
  62  * FUNCTION:    acpi_tb_compare_tables
  63  *
  64  * PARAMETERS:  table_desc          - Table 1 descriptor to be compared
  65  *              table_index         - Index of table 2 to be compared
  66  *
  67  * RETURN:      TRUE if both tables are identical.
  68  *
  69  * DESCRIPTION: This function compares a table with another table that has
  70  *              already been installed in the root table list.
  71  *
  72  ******************************************************************************/
  73
  74 static u8
  75 acpi_tb_compare_tables(struct acpi_table_desc *table_desc, u32 table_index)
  76 {
  77         acpi_status status = AE_OK;
  78         u8 is_identical;
  79         struct acpi_table_header *table;
  80         u32 table_length;
  81         u8 table_flags;
  82
  83         status =
  84             acpi_tb_acquire_table(&acpi_gbl_root_table_list.tables[table_index],
  85                                   &table, &table_length, &table_flags);
  86         if (ACPI_FAILURE(status)) {
  87                 return (FALSE);
  88         }
  89
  90         /*
  91          * Check for a table match on the entire table length,
  92          * not just the header.
  93          */
  94         is_identical = (u8)((table_desc->length != table_length ||
  95                              memcmp(table_desc->pointer, table, table_length)) ?
  96                             FALSE : TRUE);
  97
  98         /* Release the acquired table */
  99
 100         acpi_tb_release_table(table, table_length, table_flags);
 101         return (is_identical);
 102 }
 103
 104 /*******************************************************************************
 105  *
 106  * FUNCTION:    acpi_tb_init_table_descriptor
 107  *
 108  * PARAMETERS:  table_desc              - Table descriptor
 109  *              address                 - Physical address of the table
 110  *              flags                   - Allocation flags of the table
 111  *              table                   - Pointer to the table
 112  *
 113  * RETURN:      None
 114  *
 115  * DESCRIPTION: Initialize a new table descriptor
 116  *
 117  ******************************************************************************/
 118
 119 void
 120 acpi_tb_init_table_descriptor(struct acpi_table_desc *table_desc,
 121                               acpi_physical_address address,
 122                               u8 flags, struct acpi_table_header *table)
 123 {
 124
 125         /*
 126          * Initialize the table descriptor. Set the pointer to NULL, since the
 127          * table is not fully mapped at this time.
 128          */
 129         memset(table_desc, 0, sizeof(struct acpi_table_desc));
 130         table_desc->address = address;
 131         table_desc->length = table->length;
 132         table_desc->flags = flags;
 133         ACPI_MOVE_32_TO_32(table_desc->signature.ascii, table->signature);
 134 }
 135
 136 /*******************************************************************************
 137  *
 138  * FUNCTION:    acpi_tb_acquire_table
 139  *
 140  * PARAMETERS:  table_desc          - Table descriptor
 141  *              table_ptr           - Where table is returned
 142  *              table_length        - Where table length is returned
 143  *              table_flags         - Where table allocation flags are returned
 144  *
 145  * RETURN:      Status
 146  *
 147  * DESCRIPTION: Acquire an ACPI table. It can be used for tables not
 148  *              maintained in the acpi_gbl_root_table_list.
 149  *
 150  ******************************************************************************/
 151
 152 acpi_status
 153 acpi_tb_acquire_table(struct acpi_table_desc *table_desc,
 154                       struct acpi_table_header **table_ptr,
 155                       u32 *table_length, u8 *table_flags)
 156 {
 157         struct acpi_table_header *table = NULL;
 158
 159         switch (table_desc->flags & ACPI_TABLE_ORIGIN_MASK) {
 160         case ACPI_TABLE_ORIGIN_INTERNAL_PHYSICAL:
 161
 162                 table =
 163                     acpi_os_map_memory(table_desc->address, table_desc->length);
 164                 break;
 165
 166         case ACPI_TABLE_ORIGIN_INTERNAL_VIRTUAL:
 167         case ACPI_TABLE_ORIGIN_EXTERNAL_VIRTUAL:
 168
 169                 table = ACPI_CAST_PTR(struct acpi_table_header,
 170                                       ACPI_PHYSADDR_TO_PTR(table_desc->
 171                                                            address));
 172                 break;
 173
 174         default:
 175
 176                 break;
 177         }
 178
 179         /* Table is not valid yet */
 180
 181         if (!table) {
 182                 return (AE_NO_MEMORY);
 183         }
 184
 185         /* Fill the return values */
 186
 187         *table_ptr = table;
 188         *table_length = table_desc->length;
 189         *table_flags = table_desc->flags;
 190         return (AE_OK);
 191 }
 192
 193 /*******************************************************************************
 194  *
 195  * FUNCTION:    acpi_tb_release_table
 196  *
 197  * PARAMETERS:  table               - Pointer for the table
 198  *              table_length        - Length for the table
 199  *              table_flags         - Allocation flags for the table
 200  *
 201  * RETURN:      None
 202  *
 203  * DESCRIPTION: Release a table. The inverse of acpi_tb_acquire_table().
 204  *
 205  ******************************************************************************/
 206
 207 void
 208 acpi_tb_release_table(struct acpi_table_header *table,
 209                       u32 table_length, u8 table_flags)
 210 {
 211
 212         switch (table_flags & ACPI_TABLE_ORIGIN_MASK) {
 213         case ACPI_TABLE_ORIGIN_INTERNAL_PHYSICAL:
 214
 215                 acpi_os_unmap_memory(table, table_length);
 216                 break;
 217
 218         case ACPI_TABLE_ORIGIN_INTERNAL_VIRTUAL:
 219         case ACPI_TABLE_ORIGIN_EXTERNAL_VIRTUAL:
 220         default:
 221
 222                 break;
 223         }
 224 }
 225
 226 /*******************************************************************************
 227  *
 228  * FUNCTION:    acpi_tb_acquire_temp_table
 229  *
 230  * PARAMETERS:  table_desc          - Table descriptor to be acquired
 231  *              address             - Address of the table
 232  *              flags               - Allocation flags of the table
 233  *
 234  * RETURN:      Status
 235  *
 236  * DESCRIPTION: This function validates the table header to obtain the length
 237  *              of a table and fills the table descriptor to make its state as
 238  *              "INSTALLED". Such a table descriptor is only used for verified
 239  *              installation.
 240  *
 241  ******************************************************************************/
 242
 243 acpi_status
 244 acpi_tb_acquire_temp_table(struct acpi_table_desc *table_desc,
 245                            acpi_physical_address address, u8 flags)
 246 {
 247         struct acpi_table_header *table_header;
 248
 249         switch (flags & ACPI_TABLE_ORIGIN_MASK) {
 250         case ACPI_TABLE_ORIGIN_INTERNAL_PHYSICAL:
 251
 252                 /* Get the length of the full table from the header */
 253
 254                 table_header =
 255                     acpi_os_map_memory(address,
 256                                        sizeof(struct acpi_table_header));
 257                 if (!table_header) {
 258                         return (AE_NO_MEMORY);
 259                 }
 260
 261                 acpi_tb_init_table_descriptor(table_desc, address, flags,
 262                                               table_header);
 263                 acpi_os_unmap_memory(table_header,
 264                                      sizeof(struct acpi_table_header));
 265                 return (AE_OK);
 266
 267         case ACPI_TABLE_ORIGIN_INTERNAL_VIRTUAL:
 268         case ACPI_TABLE_ORIGIN_EXTERNAL_VIRTUAL:
 269
 270                 table_header = ACPI_CAST_PTR(struct acpi_table_header,
 271                                              ACPI_PHYSADDR_TO_PTR(address));
 272                 if (!table_header) {
 273                         return (AE_NO_MEMORY);
 274                 }
 275
 276                 acpi_tb_init_table_descriptor(table_desc, address, flags,
 277                                               table_header);
 278                 return (AE_OK);
 279
 280         default:
 281
 282                 break;
 283         }
 284
 285         /* Table is not valid yet */
 286
 287         return (AE_NO_MEMORY);
 288 }
 289
 290 /*******************************************************************************
 291  *
 292  * FUNCTION:    acpi_tb_release_temp_table
 293  *
 294  * PARAMETERS:  table_desc          - Table descriptor to be released
 295  *
 296  * RETURN:      Status
 297  *
 298  * DESCRIPTION: The inverse of acpi_tb_acquire_temp_table().
 299  *
 300  *****************************************************************************/
 301
 302 void acpi_tb_release_temp_table(struct acpi_table_desc *table_desc)
 303 {
 304
 305         /*
 306          * Note that the .Address is maintained by the callers of
 307          * acpi_tb_acquire_temp_table(), thus do not invoke acpi_tb_uninstall_table()
 308          * where .Address will be freed.
 309          */
 310         acpi_tb_invalidate_table(table_desc);
 311 }
 312
 313 /******************************************************************************
 314  *
 315  * FUNCTION:    acpi_tb_validate_table
 316  *
 317  * PARAMETERS:  table_desc          - Table descriptor
 318  *
 319  * RETURN:      Status
 320  *
 321  * DESCRIPTION: This function is called to validate the table, the returned
 322  *              table descriptor is in "VALIDATED" state.
 323  *
 324  *****************************************************************************/
 325
 326 acpi_status acpi_tb_validate_table(struct acpi_table_desc *table_desc)
 327 {
 328         acpi_status status = AE_OK;
 329
 330         ACPI_FUNCTION_TRACE(tb_validate_table);
 331
 332         /* Validate the table if necessary */
 333
 334         if (!table_desc->pointer) {
 335                 status = acpi_tb_acquire_table(table_desc, &table_desc->pointer,
 336                                                &table_desc->length,
 337                                                &table_desc->flags);
 338                 if (!table_desc->pointer) {
 339                         status = AE_NO_MEMORY;
 340                 }
 341         }
 342
 343         return_ACPI_STATUS(status);
 344 }
 345
 346 /*******************************************************************************
 347  *
 348  * FUNCTION:    acpi_tb_invalidate_table
 349  *
 350  * PARAMETERS:  table_desc          - Table descriptor
 351  *
 352  * RETURN:      None
 353  *
 354  * DESCRIPTION: Invalidate one internal ACPI table, this is the inverse of
 355  *              acpi_tb_validate_table().
 356  *
 357  ******************************************************************************/
 358
 359 void acpi_tb_invalidate_table(struct acpi_table_desc *table_desc)
 360 {
 361
 362         ACPI_FUNCTION_TRACE(tb_invalidate_table);
 363
 364         /* Table must be validated */
 365
 366         if (!table_desc->pointer) {
 367                 return_VOID;
 368         }
 369
 370         acpi_tb_release_table(table_desc->pointer, table_desc->length,
 371                               table_desc->flags);
 372         table_desc->pointer = NULL;
 373
 374         return_VOID;
 375 }
 376
 377 /******************************************************************************
 378  *
 379  * FUNCTION:    acpi_tb_validate_temp_table
 380  *
 381  * PARAMETERS:  table_desc          - Table descriptor
 382  *
 383  * RETURN:      Status
 384  *
 385  * DESCRIPTION: This function is called to validate the table, the returned
 386  *              table descriptor is in "VALIDATED" state.
 387  *
 388  *****************************************************************************/
 389
 390 acpi_status acpi_tb_validate_temp_table(struct acpi_table_desc *table_desc)
 391 {
 392
 393         if (!table_desc->pointer && !acpi_gbl_enable_table_validation) {
 394                 /*
 395                  * Only validates the header of the table.
 396                  * Note that Length contains the size of the mapping after invoking
 397                  * this work around, this value is required by
 398                  * acpi_tb_release_temp_table().
 399                  * We can do this because in acpi_init_table_descriptor(), the Length
 400                  * field of the installed descriptor is filled with the actual
 401                  * table length obtaining from the table header.
 402                  */
 403                 table_desc->length = sizeof(struct acpi_table_header);
 404         }
 405
 406         return (acpi_tb_validate_table(table_desc));
 407 }
 408
 409 /*******************************************************************************
 410  *
 411  * FUNCTION:    acpi_tb_check_duplication
 412  *
 413  * PARAMETERS:  table_desc          - Table descriptor
 414  *              table_index         - Where the table index is returned
 415  *
 416  * RETURN:      Status
 417  *
 418  * DESCRIPTION: Avoid installing duplicated tables. However table override and
 419  *              user aided dynamic table load is allowed, thus comparing the
 420  *              address of the table is not sufficient, and checking the entire
 421  *              table content is required.
 422  *
 423  ******************************************************************************/
 424
 425 static acpi_status
 426 acpi_tb_check_duplication(struct acpi_table_desc *table_desc, u32 *table_index)
 427 {
 428         u32 i;
 429
 430         ACPI_FUNCTION_TRACE(tb_check_duplication);
 431
 432         /* Check if table is already registered */
 433
 434         for (i = 0; i < acpi_gbl_root_table_list.current_table_count; ++i) {
 435
 436                 /* Do not compare with unverified tables */
 437
 438                 if (!
 439                     (acpi_gbl_root_table_list.tables[i].
 440                      flags & ACPI_TABLE_IS_VERIFIED)) {
 441                         continue;
 442                 }
 443
 444                 /*
 445                  * Check for a table match on the entire table length,
 446                  * not just the header.
 447                  */
 448                 if (!acpi_tb_compare_tables(table_desc, i)) {
 449                         continue;
 450                 }
 451
 452                 /*
 453                  * Note: the current mechanism does not unregister a table if it is
 454                  * dynamically unloaded. The related namespace entries are deleted,
 455                  * but the table remains in the root table list.
 456                  *
 457                  * The assumption here is that the number of different tables that
 458                  * will be loaded is actually small, and there is minimal overhead
 459                  * in just keeping the table in case it is needed again.
 460                  *
 461                  * If this assumption changes in the future (perhaps on large
 462                  * machines with many table load/unload operations), tables will
 463                  * need to be unregistered when they are unloaded, and slots in the
 464                  * root table list should be reused when empty.
 465                  */
 466                 if (acpi_gbl_root_table_list.tables[i].flags &
 467                     ACPI_TABLE_IS_LOADED) {
 468
 469                         /* Table is still loaded, this is an error */
 470
 471                         return_ACPI_STATUS(AE_ALREADY_EXISTS);
 472                 } else {
 473                         *table_index = i;
 474                         return_ACPI_STATUS(AE_CTRL_TERMINATE);
 475                 }
 476         }
 477
 478         /* Indicate no duplication to the caller */
 479
 480         return_ACPI_STATUS(AE_OK);
 481 }
 482
 483 /******************************************************************************
 484  *
 485  * FUNCTION:    acpi_tb_verify_temp_table
 486  *
 487  * PARAMETERS:  table_desc          - Table descriptor
 488  *              signature           - Table signature to verify
 489  *              table_index         - Where the table index is returned
 490  *
 491  * RETURN:      Status
 492  *
 493  * DESCRIPTION: This function is called to validate and verify the table, the
 494  *              returned table descriptor is in "VALIDATED" state.
 495  *              Note that 'TableIndex' is required to be set to !NULL to
 496  *              enable duplication check.
 497  *
 498  *****************************************************************************/
 499
 500 acpi_status
 501 acpi_tb_verify_temp_table(struct acpi_table_desc *table_desc,
 502                           char *signature, u32 *table_index)
 503 {
 504         acpi_status status = AE_OK;
 505
 506         ACPI_FUNCTION_TRACE(tb_verify_temp_table);
 507
 508         /* Validate the table */
 509
 510         status = acpi_tb_validate_temp_table(table_desc);
 511         if (ACPI_FAILURE(status)) {
 512                 return_ACPI_STATUS(AE_NO_MEMORY);
 513         }
 514
 515         /* If a particular signature is expected (DSDT/FACS), it must match */
 516
 517         if (signature && !ACPI_COMPARE_NAME(&table_desc->signature, signature)) {
 518                 ACPI_BIOS_ERROR((AE_INFO,
 519                                  "Invalid signature 0x%X for ACPI table, expected [%s]",
 520                                  table_desc->signature.integer, signature));
 521                 status = AE_BAD_SIGNATURE;
 522                 goto invalidate_and_exit;
 523         }
 524
 525         if (acpi_gbl_enable_table_validation) {
 526
 527                 /* Verify the checksum */
 528
 529                 status =
 530                     acpi_tb_verify_checksum(table_desc->pointer,
 531                                             table_desc->length);
 532                 if (ACPI_FAILURE(status)) {
 533                         ACPI_EXCEPTION((AE_INFO, AE_NO_MEMORY,
 534                                         "%4.4s 0x%8.8X%8.8X"
 535                                         " Attempted table install failed",
 536                                         acpi_ut_valid_nameseg(table_desc->
 537                                                               signature.
 538                                                               ascii) ?
 539                                         table_desc->signature.ascii : "????",
 540                                         ACPI_FORMAT_UINT64(table_desc->
 541                                                            address)));
 542
 543                         goto invalidate_and_exit;
 544                 }
 545
 546                 /* Avoid duplications */
 547
 548                 if (table_index) {
 549                         status =
 550                             acpi_tb_check_duplication(table_desc, table_index);
 551                         if (ACPI_FAILURE(status)) {
 552                                 if (status != AE_CTRL_TERMINATE) {
 553                                         ACPI_EXCEPTION((AE_INFO, AE_NO_MEMORY,
 554                                                         "%4.4s 0x%8.8X%8.8X"
 555                                                         " Table is duplicated",
 556                                                         acpi_ut_valid_nameseg
 557                                                         (table_desc->signature.
 558                                                          ascii) ? table_desc->
 559                                                         signature.
 560                                                         ascii : "????",
 561                                                         ACPI_FORMAT_UINT64
 562                                                         (table_desc->address)));
 563                                 }
 564
 565                                 goto invalidate_and_exit;
 566                         }
 567                 }
 568
 569                 table_desc->flags |= ACPI_TABLE_IS_VERIFIED;
 570         }
 571
 572         return_ACPI_STATUS(status);
 573
 574 invalidate_and_exit:
 575         acpi_tb_invalidate_table(table_desc);
 576         return_ACPI_STATUS(status);
 577 }
 578
 579 /*******************************************************************************
 580  *
 581  * FUNCTION:    acpi_tb_resize_root_table_list
 582  *
 583  * PARAMETERS:  None
 584  *
 585  * RETURN:      Status
 586  *
 587  * DESCRIPTION: Expand the size of global table array
 588  *
 589  ******************************************************************************/
 590
 591 acpi_status acpi_tb_resize_root_table_list(void)
 592 {
 593         struct acpi_table_desc *tables;
 594         u32 table_count;
 595         u32 current_table_count, max_table_count;
 596         u32 i;
 597
 598         ACPI_FUNCTION_TRACE(tb_resize_root_table_list);
 599
 600         /* allow_resize flag is a parameter to acpi_initialize_tables */
 601
 602         if (!(acpi_gbl_root_table_list.flags & ACPI_ROOT_ALLOW_RESIZE)) {
 603                 ACPI_ERROR((AE_INFO,
 604                             "Resize of Root Table Array is not allowed"));
 605                 return_ACPI_STATUS(AE_SUPPORT);
 606         }
 607
 608         /* Increase the Table Array size */
 609
 610         if (acpi_gbl_root_table_list.flags & ACPI_ROOT_ORIGIN_ALLOCATED) {
 611                 table_count = acpi_gbl_root_table_list.max_table_count;
 612         } else {
 613                 table_count = acpi_gbl_root_table_list.current_table_count;
 614         }
 615
 616         max_table_count = table_count + ACPI_ROOT_TABLE_SIZE_INCREMENT;
 617         tables = ACPI_ALLOCATE_ZEROED(((acpi_size)max_table_count) *
 618                                       sizeof(struct acpi_table_desc));
 619         if (!tables) {
 620                 ACPI_ERROR((AE_INFO,
 621                             "Could not allocate new root table array"));
 622                 return_ACPI_STATUS(AE_NO_MEMORY);
 623         }
 624
 625         /* Copy and free the previous table array */
 626
 627         current_table_count = 0;
 628         if (acpi_gbl_root_table_list.tables) {
 629                 for (i = 0; i < table_count; i++) {
 630                         if (acpi_gbl_root_table_list.tables[i].address) {
 631                                 memcpy(tables + current_table_count,
 632                                        acpi_gbl_root_table_list.tables + i,
 633                                        sizeof(struct acpi_table_desc));
 634                                 current_table_count++;
 635                         }
 636                 }
 637
 638                 if (acpi_gbl_root_table_list.flags & ACPI_ROOT_ORIGIN_ALLOCATED) {
 639                         ACPI_FREE(acpi_gbl_root_table_list.tables);
 640                 }
 641         }
 642
 643         acpi_gbl_root_table_list.tables = tables;
 644         acpi_gbl_root_table_list.max_table_count = max_table_count;
 645         acpi_gbl_root_table_list.current_table_count = current_table_count;
 646         acpi_gbl_root_table_list.flags |= ACPI_ROOT_ORIGIN_ALLOCATED;
 647
 648         return_ACPI_STATUS(AE_OK);
 649 }
 650
 651 /*******************************************************************************
 652  *
 653  * FUNCTION:    acpi_tb_get_next_table_descriptor
 654  *
 655  * PARAMETERS:  table_index         - Where table index is returned
 656  *              table_desc          - Where table descriptor is returned
 657  *
 658  * RETURN:      Status and table index/descriptor.
 659  *
 660  * DESCRIPTION: Allocate a new ACPI table entry to the global table list
 661  *
 662  ******************************************************************************/
 663
 664 acpi_status
 665 acpi_tb_get_next_table_descriptor(u32 *table_index,
 666                                   struct acpi_table_desc **table_desc)
 667 {
 668         acpi_status status;
 669         u32 i;
 670
 671         /* Ensure that there is room for the table in the Root Table List */
 672
 673         if (acpi_gbl_root_table_list.current_table_count >=
 674             acpi_gbl_root_table_list.max_table_count) {
 675                 status = acpi_tb_resize_root_table_list();
 676                 if (ACPI_FAILURE(status)) {
 677                         return (status);
 678                 }
 679         }
 680
 681         i = acpi_gbl_root_table_list.current_table_count;
 682         acpi_gbl_root_table_list.current_table_count++;
 683
 684         if (table_index) {
 685                 *table_index = i;
 686         }
 687         if (table_desc) {
 688                 *table_desc = &acpi_gbl_root_table_list.tables[i];
 689         }
 690
 691         return (AE_OK);
 692 }
 693
 694 /*******************************************************************************
 695  *
 696  * FUNCTION:    acpi_tb_terminate
 697  *
 698  * PARAMETERS:  None
 699  *
 700  * RETURN:      None
 701  *
 702  * DESCRIPTION: Delete all internal ACPI tables
 703  *
 704  ******************************************************************************/
 705
 706 void acpi_tb_terminate(void)
 707 {
 708         u32 i;
 709
 710         ACPI_FUNCTION_TRACE(tb_terminate);
 711
 712         (void)acpi_ut_acquire_mutex(ACPI_MTX_TABLES);
 713
 714         /* Delete the individual tables */
 715
 716         for (i = 0; i < acpi_gbl_root_table_list.current_table_count; i++) {
 717                 acpi_tb_uninstall_table(&acpi_gbl_root_table_list.tables[i]);
 718         }
 719
 720         /*
 721          * Delete the root table array if allocated locally. Array cannot be
 722          * mapped, so we don't need to check for that flag.
 723          */
 724         if (acpi_gbl_root_table_list.flags & ACPI_ROOT_ORIGIN_ALLOCATED) {
 725                 ACPI_FREE(acpi_gbl_root_table_list.tables);
 726         }
 727
 728         acpi_gbl_root_table_list.tables = NULL;
 729         acpi_gbl_root_table_list.flags = 0;
 730         acpi_gbl_root_table_list.current_table_count = 0;
 731
 732         ACPI_DEBUG_PRINT((ACPI_DB_INFO, "ACPI Tables freed\n"));
 733
 734         (void)acpi_ut_release_mutex(ACPI_MTX_TABLES);
 735         return_VOID;
 736 }
 737
 738 /*******************************************************************************
 739  *
 740  * FUNCTION:    acpi_tb_delete_namespace_by_owner
 741  *
 742  * PARAMETERS:  table_index         - Table index
 743  *
 744  * RETURN:      Status
 745  *
 746  * DESCRIPTION: Delete all namespace objects created when this table was loaded.
 747  *
 748  ******************************************************************************/
 749
 750 acpi_status acpi_tb_delete_namespace_by_owner(u32 table_index)
 751 {
 752         acpi_owner_id owner_id;
 753         acpi_status status;
 754
 755         ACPI_FUNCTION_TRACE(tb_delete_namespace_by_owner);
 756
 757         status = acpi_ut_acquire_mutex(ACPI_MTX_TABLES);
 758         if (ACPI_FAILURE(status)) {
 759                 return_ACPI_STATUS(status);
 760         }
 761
 762         if (table_index >= acpi_gbl_root_table_list.current_table_count) {
 763
 764                 /* The table index does not exist */
 765
 766                 (void)acpi_ut_release_mutex(ACPI_MTX_TABLES);
 767                 return_ACPI_STATUS(AE_NOT_EXIST);
 768         }
 769
 770         /* Get the owner ID for this table, used to delete namespace nodes */
 771
 772         owner_id = acpi_gbl_root_table_list.tables[table_index].owner_id;
 773         (void)acpi_ut_release_mutex(ACPI_MTX_TABLES);
 774
 775         /*
 776          * Need to acquire the namespace writer lock to prevent interference
 777          * with any concurrent namespace walks. The interpreter must be
 778          * released during the deletion since the acquisition of the deletion
 779          * lock may block, and also since the execution of a namespace walk
 780          * must be allowed to use the interpreter.
 781          */
 782         status = acpi_ut_acquire_write_lock(&acpi_gbl_namespace_rw_lock);
 783         if (ACPI_FAILURE(status)) {
 784                 return_ACPI_STATUS(status);
 785         }
 786         acpi_ns_delete_namespace_by_owner(owner_id);
 787         acpi_ut_release_write_lock(&acpi_gbl_namespace_rw_lock);
 788         return_ACPI_STATUS(status);
 789 }
 790
 791 /*******************************************************************************
 792  *
 793  * FUNCTION:    acpi_tb_allocate_owner_id
 794  *
 795  * PARAMETERS:  table_index         - Table index
 796  *
 797  * RETURN:      Status
 798  *
 799  * DESCRIPTION: Allocates owner_id in table_desc
 800  *
 801  ******************************************************************************/
 802
 803 acpi_status acpi_tb_allocate_owner_id(u32 table_index)
 804 {
 805         acpi_status status = AE_BAD_PARAMETER;
 806
 807         ACPI_FUNCTION_TRACE(tb_allocate_owner_id);
 808
 809         (void)acpi_ut_acquire_mutex(ACPI_MTX_TABLES);
 810         if (table_index < acpi_gbl_root_table_list.current_table_count) {
 811                 status =
 812                     acpi_ut_allocate_owner_id(&
 813                                               (acpi_gbl_root_table_list.
 814                                                tables[table_index].owner_id));
 815         }
 816
 817         (void)acpi_ut_release_mutex(ACPI_MTX_TABLES);
 818         return_ACPI_STATUS(status);
 819 }
 820
 821 /*******************************************************************************
 822  *
 823  * FUNCTION:    acpi_tb_release_owner_id
 824  *
 825  * PARAMETERS:  table_index         - Table index
 826  *
 827  * RETURN:      Status
 828  *
 829  * DESCRIPTION: Releases owner_id in table_desc
 830  *
 831  ******************************************************************************/
 832
 833 acpi_status acpi_tb_release_owner_id(u32 table_index)
 834 {
 835         acpi_status status = AE_BAD_PARAMETER;
 836
 837         ACPI_FUNCTION_TRACE(tb_release_owner_id);
 838
 839         (void)acpi_ut_acquire_mutex(ACPI_MTX_TABLES);
 840         if (table_index < acpi_gbl_root_table_list.current_table_count) {
 841                 acpi_ut_release_owner_id(&
 842                                          (acpi_gbl_root_table_list.
 843                                           tables[table_index].owner_id));
 844                 status = AE_OK;
 845         }
 846
 847         (void)acpi_ut_release_mutex(ACPI_MTX_TABLES);
 848         return_ACPI_STATUS(status);
 849 }
 850
 851 /*******************************************************************************
 852  *
 853  * FUNCTION:    acpi_tb_get_owner_id
 854  *
 855  * PARAMETERS:  table_index         - Table index
 856  *              owner_id            - Where the table owner_id is returned
 857  *
 858  * RETURN:      Status
 859  *
 860  * DESCRIPTION: returns owner_id for the ACPI table
 861  *
 862  ******************************************************************************/
 863
 864 acpi_status acpi_tb_get_owner_id(u32 table_index, acpi_owner_id *owner_id)
 865 {
 866         acpi_status status = AE_BAD_PARAMETER;
 867
 868         ACPI_FUNCTION_TRACE(tb_get_owner_id);
 869
 870         (void)acpi_ut_acquire_mutex(ACPI_MTX_TABLES);
 871         if (table_index < acpi_gbl_root_table_list.current_table_count) {
 872                 *owner_id =
 873                     acpi_gbl_root_table_list.tables[table_index].owner_id;
 874                 status = AE_OK;
 875         }
 876
 877         (void)acpi_ut_release_mutex(ACPI_MTX_TABLES);
 878         return_ACPI_STATUS(status);
 879 }
 880
 881 /*******************************************************************************
 882  *
 883  * FUNCTION:    acpi_tb_is_table_loaded
 884  *
 885  * PARAMETERS:  table_index         - Index into the root table
 886  *
 887  * RETURN:      Table Loaded Flag
 888  *
 889  ******************************************************************************/
 890
 891 u8 acpi_tb_is_table_loaded(u32 table_index)
 892 {
 893         u8 is_loaded = FALSE;
 894
 895         (void)acpi_ut_acquire_mutex(ACPI_MTX_TABLES);
 896         if (table_index < acpi_gbl_root_table_list.current_table_count) {
 897                 is_loaded = (u8)
 898                     (acpi_gbl_root_table_list.tables[table_index].flags &
 899                      ACPI_TABLE_IS_LOADED);
 900         }
 901
 902         (void)acpi_ut_release_mutex(ACPI_MTX_TABLES);
 903         return (is_loaded);
 904 }
 905
 906 /*******************************************************************************
 907  *
 908  * FUNCTION:    acpi_tb_set_table_loaded_flag
 909  *
 910  * PARAMETERS:  table_index         - Table index
 911  *              is_loaded           - TRUE if table is loaded, FALSE otherwise
 912  *
 913  * RETURN:      None
 914  *
 915  * DESCRIPTION: Sets the table loaded flag to either TRUE or FALSE.
 916  *
 917  ******************************************************************************/
 918
 919 void acpi_tb_set_table_loaded_flag(u32 table_index, u8 is_loaded)
 920 {
 921
 922         (void)acpi_ut_acquire_mutex(ACPI_MTX_TABLES);
 923         if (table_index < acpi_gbl_root_table_list.current_table_count) {
 924                 if (is_loaded) {
 925                         acpi_gbl_root_table_list.tables[table_index].flags |=
 926                             ACPI_TABLE_IS_LOADED;
 927                 } else {
 928                         acpi_gbl_root_table_list.tables[table_index].flags &=
 929                             ~ACPI_TABLE_IS_LOADED;
 930                 }
 931         }
 932
 933         (void)acpi_ut_release_mutex(ACPI_MTX_TABLES);
 934 }
 935
 936 /*******************************************************************************
 937  *
 938  * FUNCTION:    acpi_tb_load_table
 939  *
 940  * PARAMETERS:  table_index             - Table index
 941  *              parent_node             - Where table index is returned
 942  *
 943  * RETURN:      Status
 944  *
 945  * DESCRIPTION: Load an ACPI table
 946  *
 947  ******************************************************************************/
 948
 949 acpi_status
 950 acpi_tb_load_table(u32 table_index, struct acpi_namespace_node *parent_node)
 951 {
 952         struct acpi_table_header *table;
 953         acpi_status status;
 954         acpi_owner_id owner_id;
 955
 956         ACPI_FUNCTION_TRACE(tb_load_table);
 957
 958         /*
 959          * Note: Now table is "INSTALLED", it must be validated before
 960          * using.
 961          */
 962         status = acpi_get_table_by_index(table_index, &table);
 963         if (ACPI_FAILURE(status)) {
 964                 return_ACPI_STATUS(status);
 965         }
 966
 967         status = acpi_ns_load_table(table_index, parent_node);
 968
 969         /* Execute any module-level code that was found in the table */
 970
 971         if (!acpi_gbl_parse_table_as_term_list
 972             && acpi_gbl_group_module_level_code) {
 973                 acpi_ns_exec_module_code_list();
 974         }
 975
 976         /*
 977          * Update GPEs for any new _Lxx/_Exx methods. Ignore errors. The host is
 978          * responsible for discovering any new wake GPEs by running _PRW methods
 979          * that may have been loaded by this table.
 980          */
 981         status = acpi_tb_get_owner_id(table_index, &owner_id);
 982         if (ACPI_SUCCESS(status)) {
 983                 acpi_ev_update_gpes(owner_id);
 984         }
 985
 986         /* Invoke table handler */
 987
 988         acpi_tb_notify_table(ACPI_TABLE_EVENT_LOAD, table);
 989         return_ACPI_STATUS(status);
 990 }
 991
 992 /*******************************************************************************
 993  *
 994  * FUNCTION:    acpi_tb_install_and_load_table
 995  *
 996  * PARAMETERS:  address                 - Physical address of the table
 997  *              flags                   - Allocation flags of the table
 998  *              override                - Whether override should be performed
 999  *              table_index             - Where table index is returned
1000  *
1001  * RETURN:      Status
1002  *
1003  * DESCRIPTION: Install and load an ACPI table
1004  *
1005  ******************************************************************************/
1006
1007 acpi_status
1008 acpi_tb_install_and_load_table(acpi_physical_address address,
1009                                u8 flags, u8 override, u32 *table_index)
1010 {
1011         acpi_status status;
1012         u32 i;
1013
1014         ACPI_FUNCTION_TRACE(tb_install_and_load_table);
1015
1016         /* Install the table and load it into the namespace */
1017
1018         status = acpi_tb_install_standard_table(address, flags, TRUE,
1019                                                 override, &i);
1020         if (ACPI_FAILURE(status)) {
1021                 goto exit;
1022         }
1023
1024         status = acpi_tb_load_table(i, acpi_gbl_root_node);
1025
1026 exit:
1027         *table_index = i;
1028         return_ACPI_STATUS(status);
1029 }
1030
1031 ACPI_EXPORT_SYMBOL(acpi_tb_install_and_load_table)
1032
1033 /*******************************************************************************
1034  *
1035  * FUNCTION:    acpi_tb_unload_table
1036  *
1037  * PARAMETERS:  table_index             - Table index
1038  *
1039  * RETURN:      Status
1040  *
1041  * DESCRIPTION: Unload an ACPI table
1042  *
1043  ******************************************************************************/
1044
1045 acpi_status acpi_tb_unload_table(u32 table_index)
1046 {
1047         acpi_status status = AE_OK;
1048         struct acpi_table_header *table;
1049
1050         ACPI_FUNCTION_TRACE(tb_unload_table);
1051
1052         /* Ensure the table is still loaded */
1053
1054         if (!acpi_tb_is_table_loaded(table_index)) {
1055                 return_ACPI_STATUS(AE_NOT_EXIST);
1056         }
1057
1058         /* Invoke table handler */
1059
1060         status = acpi_get_table_by_index(table_index, &table);
1061         if (ACPI_SUCCESS(status)) {
1062                 acpi_tb_notify_table(ACPI_TABLE_EVENT_UNLOAD, table);
1063         }
1064
1065         /* Delete the portion of the namespace owned by this table */
1066
1067         status = acpi_tb_delete_namespace_by_owner(table_index);
1068         if (ACPI_FAILURE(status)) {
1069                 return_ACPI_STATUS(status);
1070         }
1071
1072         (void)acpi_tb_release_owner_id(table_index);
1073         acpi_tb_set_table_loaded_flag(table_index, FALSE);
1074         return_ACPI_STATUS(status);
1075 }
1076
1077 ACPI_EXPORT_SYMBOL(acpi_tb_unload_table)
1078
1079 /*******************************************************************************
1080  *
1081  * FUNCTION:    acpi_tb_notify_table
1082  *
1083  * PARAMETERS:  event               - Table event
1084  *              table               - Validated table pointer
1085  *
1086  * RETURN:      None
1087  *
1088  * DESCRIPTION: Notify a table event to the users.
1089  *
1090  ******************************************************************************/
1091
1092 void acpi_tb_notify_table(u32 event, void *table)
1093 {
1094         /* Invoke table handler if present */
1095
1096         if (acpi_gbl_table_handler) {
1097                 (void)acpi_gbl_table_handler(event, table,
1098                                              acpi_gbl_table_handler_context);
1099         }
1100 }