drivers/acpi/acpica/tbdata.c

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