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 - 2020, 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 &&
 484             !ACPI_COMPARE_NAMESEG(&table_desc->signature, signature)) {
 485                 ACPI_BIOS_ERROR((AE_INFO,
 486                                  "Invalid signature 0x%X for ACPI table, expected [%s]",
 487                                  table_desc->signature.integer, signature));
 488                 status = AE_BAD_SIGNATURE;
 489                 goto invalidate_and_exit;
 490         }
 491
 492         if (acpi_gbl_enable_table_validation) {
 493
 494                 /* Verify the checksum */
 495
 496                 status =
 497                     acpi_tb_verify_checksum(table_desc->pointer,
 498                                             table_desc->length);
 499                 if (ACPI_FAILURE(status)) {
 500                         ACPI_EXCEPTION((AE_INFO, AE_NO_MEMORY,
 501                                         "%4.4s 0x%8.8X%8.8X"
 502                                         " Attempted table install failed",
 503                                         acpi_ut_valid_nameseg(table_desc->
 504                                                               signature.
 505                                                               ascii) ?
 506                                         table_desc->signature.ascii : "????",
 507                                         ACPI_FORMAT_UINT64(table_desc->
 508                                                            address)));
 509
 510                         goto invalidate_and_exit;
 511                 }
 512
 513                 /* Avoid duplications */
 514
 515                 if (table_index) {
 516                         status =
 517                             acpi_tb_check_duplication(table_desc, table_index);
 518                         if (ACPI_FAILURE(status)) {
 519                                 if (status != AE_CTRL_TERMINATE) {
 520                                         ACPI_EXCEPTION((AE_INFO, status,
 521                                                         "%4.4s 0x%8.8X%8.8X"
 522                                                         " Table is already loaded",
 523                                                         acpi_ut_valid_nameseg
 524                                                         (table_desc->signature.
 525                                                          ascii) ? table_desc->
 526                                                         signature.
 527                                                         ascii : "????",
 528                                                         ACPI_FORMAT_UINT64
 529                                                         (table_desc->address)));
 530                                 }
 531
 532                                 goto invalidate_and_exit;
 533                         }
 534                 }
 535
 536                 table_desc->flags |= ACPI_TABLE_IS_VERIFIED;
 537         }
 538
 539         return_ACPI_STATUS(status);
 540
 541 invalidate_and_exit:
 542         acpi_tb_invalidate_table(table_desc);
 543         return_ACPI_STATUS(status);
 544 }
 545
 546 /*******************************************************************************
 547  *
 548  * FUNCTION:    acpi_tb_resize_root_table_list
 549  *
 550  * PARAMETERS:  None
 551  *
 552  * RETURN:      Status
 553  *
 554  * DESCRIPTION: Expand the size of global table array
 555  *
 556  ******************************************************************************/
 557
 558 acpi_status acpi_tb_resize_root_table_list(void)
 559 {
 560         struct acpi_table_desc *tables;
 561         u32 table_count;
 562         u32 current_table_count, max_table_count;
 563         u32 i;
 564
 565         ACPI_FUNCTION_TRACE(tb_resize_root_table_list);
 566
 567         /* allow_resize flag is a parameter to acpi_initialize_tables */
 568
 569         if (!(acpi_gbl_root_table_list.flags & ACPI_ROOT_ALLOW_RESIZE)) {
 570                 ACPI_ERROR((AE_INFO,
 571                             "Resize of Root Table Array is not allowed"));
 572                 return_ACPI_STATUS(AE_SUPPORT);
 573         }
 574
 575         /* Increase the Table Array size */
 576
 577         if (acpi_gbl_root_table_list.flags & ACPI_ROOT_ORIGIN_ALLOCATED) {
 578                 table_count = acpi_gbl_root_table_list.max_table_count;
 579         } else {
 580                 table_count = acpi_gbl_root_table_list.current_table_count;
 581         }
 582
 583         max_table_count = table_count + ACPI_ROOT_TABLE_SIZE_INCREMENT;
 584         tables = ACPI_ALLOCATE_ZEROED(((acpi_size)max_table_count) *
 585                                       sizeof(struct acpi_table_desc));
 586         if (!tables) {
 587                 ACPI_ERROR((AE_INFO,
 588                             "Could not allocate new root table array"));
 589                 return_ACPI_STATUS(AE_NO_MEMORY);
 590         }
 591
 592         /* Copy and free the previous table array */
 593
 594         current_table_count = 0;
 595         if (acpi_gbl_root_table_list.tables) {
 596                 for (i = 0; i < table_count; i++) {
 597                         if (acpi_gbl_root_table_list.tables[i].address) {
 598                                 memcpy(tables + current_table_count,
 599                                        acpi_gbl_root_table_list.tables + i,
 600                                        sizeof(struct acpi_table_desc));
 601                                 current_table_count++;
 602                         }
 603                 }
 604
 605                 if (acpi_gbl_root_table_list.flags & ACPI_ROOT_ORIGIN_ALLOCATED) {
 606                         ACPI_FREE(acpi_gbl_root_table_list.tables);
 607                 }
 608         }
 609
 610         acpi_gbl_root_table_list.tables = tables;
 611         acpi_gbl_root_table_list.max_table_count = max_table_count;
 612         acpi_gbl_root_table_list.current_table_count = current_table_count;
 613         acpi_gbl_root_table_list.flags |= ACPI_ROOT_ORIGIN_ALLOCATED;
 614
 615         return_ACPI_STATUS(AE_OK);
 616 }
 617
 618 /*******************************************************************************
 619  *
 620  * FUNCTION:    acpi_tb_get_next_table_descriptor
 621  *
 622  * PARAMETERS:  table_index         - Where table index is returned
 623  *              table_desc          - Where table descriptor is returned
 624  *
 625  * RETURN:      Status and table index/descriptor.
 626  *
 627  * DESCRIPTION: Allocate a new ACPI table entry to the global table list
 628  *
 629  ******************************************************************************/
 630
 631 acpi_status
 632 acpi_tb_get_next_table_descriptor(u32 *table_index,
 633                                   struct acpi_table_desc **table_desc)
 634 {
 635         acpi_status status;
 636         u32 i;
 637
 638         /* Ensure that there is room for the table in the Root Table List */
 639
 640         if (acpi_gbl_root_table_list.current_table_count >=
 641             acpi_gbl_root_table_list.max_table_count) {
 642                 status = acpi_tb_resize_root_table_list();
 643                 if (ACPI_FAILURE(status)) {
 644                         return (status);
 645                 }
 646         }
 647
 648         i = acpi_gbl_root_table_list.current_table_count;
 649         acpi_gbl_root_table_list.current_table_count++;
 650
 651         if (table_index) {
 652                 *table_index = i;
 653         }
 654         if (table_desc) {
 655                 *table_desc = &acpi_gbl_root_table_list.tables[i];
 656         }
 657
 658         return (AE_OK);
 659 }
 660
 661 /*******************************************************************************
 662  *
 663  * FUNCTION:    acpi_tb_terminate
 664  *
 665  * PARAMETERS:  None
 666  *
 667  * RETURN:      None
 668  *
 669  * DESCRIPTION: Delete all internal ACPI tables
 670  *
 671  ******************************************************************************/
 672
 673 void acpi_tb_terminate(void)
 674 {
 675         u32 i;
 676
 677         ACPI_FUNCTION_TRACE(tb_terminate);
 678
 679         (void)acpi_ut_acquire_mutex(ACPI_MTX_TABLES);
 680
 681         /* Delete the individual tables */
 682
 683         for (i = 0; i < acpi_gbl_root_table_list.current_table_count; i++) {
 684                 acpi_tb_uninstall_table(&acpi_gbl_root_table_list.tables[i]);
 685         }
 686
 687         /*
 688          * Delete the root table array if allocated locally. Array cannot be
 689          * mapped, so we don't need to check for that flag.
 690          */
 691         if (acpi_gbl_root_table_list.flags & ACPI_ROOT_ORIGIN_ALLOCATED) {
 692                 ACPI_FREE(acpi_gbl_root_table_list.tables);
 693         }
 694
 695         acpi_gbl_root_table_list.tables = NULL;
 696         acpi_gbl_root_table_list.flags = 0;
 697         acpi_gbl_root_table_list.current_table_count = 0;
 698
 699         ACPI_DEBUG_PRINT((ACPI_DB_INFO, "ACPI Tables freed\n"));
 700
 701         (void)acpi_ut_release_mutex(ACPI_MTX_TABLES);
 702         return_VOID;
 703 }
 704
 705 /*******************************************************************************
 706  *
 707  * FUNCTION:    acpi_tb_delete_namespace_by_owner
 708  *
 709  * PARAMETERS:  table_index         - Table index
 710  *
 711  * RETURN:      Status
 712  *
 713  * DESCRIPTION: Delete all namespace objects created when this table was loaded.
 714  *
 715  ******************************************************************************/
 716
 717 acpi_status acpi_tb_delete_namespace_by_owner(u32 table_index)
 718 {
 719         acpi_owner_id owner_id;
 720         acpi_status status;
 721
 722         ACPI_FUNCTION_TRACE(tb_delete_namespace_by_owner);
 723
 724         status = acpi_ut_acquire_mutex(ACPI_MTX_TABLES);
 725         if (ACPI_FAILURE(status)) {
 726                 return_ACPI_STATUS(status);
 727         }
 728
 729         if (table_index >= acpi_gbl_root_table_list.current_table_count) {
 730
 731                 /* The table index does not exist */
 732
 733                 (void)acpi_ut_release_mutex(ACPI_MTX_TABLES);
 734                 return_ACPI_STATUS(AE_NOT_EXIST);
 735         }
 736
 737         /* Get the owner ID for this table, used to delete namespace nodes */
 738
 739         owner_id = acpi_gbl_root_table_list.tables[table_index].owner_id;
 740         (void)acpi_ut_release_mutex(ACPI_MTX_TABLES);
 741
 742         /*
 743          * Need to acquire the namespace writer lock to prevent interference
 744          * with any concurrent namespace walks. The interpreter must be
 745          * released during the deletion since the acquisition of the deletion
 746          * lock may block, and also since the execution of a namespace walk
 747          * must be allowed to use the interpreter.
 748          */
 749         status = acpi_ut_acquire_write_lock(&acpi_gbl_namespace_rw_lock);
 750         if (ACPI_FAILURE(status)) {
 751                 return_ACPI_STATUS(status);
 752         }
 753
 754         acpi_ns_delete_namespace_by_owner(owner_id);
 755         acpi_ut_release_write_lock(&acpi_gbl_namespace_rw_lock);
 756         return_ACPI_STATUS(status);
 757 }
 758
 759 /*******************************************************************************
 760  *
 761  * FUNCTION:    acpi_tb_allocate_owner_id
 762  *
 763  * PARAMETERS:  table_index         - Table index
 764  *
 765  * RETURN:      Status
 766  *
 767  * DESCRIPTION: Allocates owner_id in table_desc
 768  *
 769  ******************************************************************************/
 770
 771 acpi_status acpi_tb_allocate_owner_id(u32 table_index)
 772 {
 773         acpi_status status = AE_BAD_PARAMETER;
 774
 775         ACPI_FUNCTION_TRACE(tb_allocate_owner_id);
 776
 777         (void)acpi_ut_acquire_mutex(ACPI_MTX_TABLES);
 778         if (table_index < acpi_gbl_root_table_list.current_table_count) {
 779                 status =
 780                     acpi_ut_allocate_owner_id(&
 781                                               (acpi_gbl_root_table_list.
 782                                                tables[table_index].owner_id));
 783         }
 784
 785         (void)acpi_ut_release_mutex(ACPI_MTX_TABLES);
 786         return_ACPI_STATUS(status);
 787 }
 788
 789 /*******************************************************************************
 790  *
 791  * FUNCTION:    acpi_tb_release_owner_id
 792  *
 793  * PARAMETERS:  table_index         - Table index
 794  *
 795  * RETURN:      Status
 796  *
 797  * DESCRIPTION: Releases owner_id in table_desc
 798  *
 799  ******************************************************************************/
 800
 801 acpi_status acpi_tb_release_owner_id(u32 table_index)
 802 {
 803         acpi_status status = AE_BAD_PARAMETER;
 804
 805         ACPI_FUNCTION_TRACE(tb_release_owner_id);
 806
 807         (void)acpi_ut_acquire_mutex(ACPI_MTX_TABLES);
 808         if (table_index < acpi_gbl_root_table_list.current_table_count) {
 809                 acpi_ut_release_owner_id(&
 810                                          (acpi_gbl_root_table_list.
 811                                           tables[table_index].owner_id));
 812                 status = AE_OK;
 813         }
 814
 815         (void)acpi_ut_release_mutex(ACPI_MTX_TABLES);
 816         return_ACPI_STATUS(status);
 817 }
 818
 819 /*******************************************************************************
 820  *
 821  * FUNCTION:    acpi_tb_get_owner_id
 822  *
 823  * PARAMETERS:  table_index         - Table index
 824  *              owner_id            - Where the table owner_id is returned
 825  *
 826  * RETURN:      Status
 827  *
 828  * DESCRIPTION: returns owner_id for the ACPI table
 829  *
 830  ******************************************************************************/
 831
 832 acpi_status acpi_tb_get_owner_id(u32 table_index, acpi_owner_id *owner_id)
 833 {
 834         acpi_status status = AE_BAD_PARAMETER;
 835
 836         ACPI_FUNCTION_TRACE(tb_get_owner_id);
 837
 838         (void)acpi_ut_acquire_mutex(ACPI_MTX_TABLES);
 839         if (table_index < acpi_gbl_root_table_list.current_table_count) {
 840                 *owner_id =
 841                     acpi_gbl_root_table_list.tables[table_index].owner_id;
 842                 status = AE_OK;
 843         }
 844
 845         (void)acpi_ut_release_mutex(ACPI_MTX_TABLES);
 846         return_ACPI_STATUS(status);
 847 }
 848
 849 /*******************************************************************************
 850  *
 851  * FUNCTION:    acpi_tb_is_table_loaded
 852  *
 853  * PARAMETERS:  table_index         - Index into the root table
 854  *
 855  * RETURN:      Table Loaded Flag
 856  *
 857  ******************************************************************************/
 858
 859 u8 acpi_tb_is_table_loaded(u32 table_index)
 860 {
 861         u8 is_loaded = FALSE;
 862
 863         (void)acpi_ut_acquire_mutex(ACPI_MTX_TABLES);
 864         if (table_index < acpi_gbl_root_table_list.current_table_count) {
 865                 is_loaded = (u8)
 866                     (acpi_gbl_root_table_list.tables[table_index].flags &
 867                      ACPI_TABLE_IS_LOADED);
 868         }
 869
 870         (void)acpi_ut_release_mutex(ACPI_MTX_TABLES);
 871         return (is_loaded);
 872 }
 873
 874 /*******************************************************************************
 875  *
 876  * FUNCTION:    acpi_tb_set_table_loaded_flag
 877  *
 878  * PARAMETERS:  table_index         - Table index
 879  *              is_loaded           - TRUE if table is loaded, FALSE otherwise
 880  *
 881  * RETURN:      None
 882  *
 883  * DESCRIPTION: Sets the table loaded flag to either TRUE or FALSE.
 884  *
 885  ******************************************************************************/
 886
 887 void acpi_tb_set_table_loaded_flag(u32 table_index, u8 is_loaded)
 888 {
 889
 890         (void)acpi_ut_acquire_mutex(ACPI_MTX_TABLES);
 891         if (table_index < acpi_gbl_root_table_list.current_table_count) {
 892                 if (is_loaded) {
 893                         acpi_gbl_root_table_list.tables[table_index].flags |=
 894                             ACPI_TABLE_IS_LOADED;
 895                 } else {
 896                         acpi_gbl_root_table_list.tables[table_index].flags &=
 897                             ~ACPI_TABLE_IS_LOADED;
 898                 }
 899         }
 900
 901         (void)acpi_ut_release_mutex(ACPI_MTX_TABLES);
 902 }
 903
 904 /*******************************************************************************
 905  *
 906  * FUNCTION:    acpi_tb_load_table
 907  *
 908  * PARAMETERS:  table_index             - Table index
 909  *              parent_node             - Where table index is returned
 910  *
 911  * RETURN:      Status
 912  *
 913  * DESCRIPTION: Load an ACPI table
 914  *
 915  ******************************************************************************/
 916
 917 acpi_status
 918 acpi_tb_load_table(u32 table_index, struct acpi_namespace_node *parent_node)
 919 {
 920         struct acpi_table_header *table;
 921         acpi_status status;
 922         acpi_owner_id owner_id;
 923
 924         ACPI_FUNCTION_TRACE(tb_load_table);
 925
 926         /*
 927          * Note: Now table is "INSTALLED", it must be validated before
 928          * using.
 929          */
 930         status = acpi_get_table_by_index(table_index, &table);
 931         if (ACPI_FAILURE(status)) {
 932                 return_ACPI_STATUS(status);
 933         }
 934
 935         status = acpi_ns_load_table(table_index, parent_node);
 936         if (ACPI_FAILURE(status)) {
 937                 return_ACPI_STATUS(status);
 938         }
 939
 940         /*
 941          * Update GPEs for any new _Lxx/_Exx methods. Ignore errors. The host is
 942          * responsible for discovering any new wake GPEs by running _PRW methods
 943          * that may have been loaded by this table.
 944          */
 945         status = acpi_tb_get_owner_id(table_index, &owner_id);
 946         if (ACPI_SUCCESS(status)) {
 947                 acpi_ev_update_gpes(owner_id);
 948         }
 949
 950         /* Invoke table handler */
 951
 952         acpi_tb_notify_table(ACPI_TABLE_EVENT_LOAD, table);
 953         return_ACPI_STATUS(status);
 954 }
 955
 956 /*******************************************************************************
 957  *
 958  * FUNCTION:    acpi_tb_install_and_load_table
 959  *
 960  * PARAMETERS:  address                 - Physical address of the table
 961  *              flags                   - Allocation flags of the table
 962  *              override                - Whether override should be performed
 963  *              table_index             - Where table index is returned
 964  *
 965  * RETURN:      Status
 966  *
 967  * DESCRIPTION: Install and load an ACPI table
 968  *
 969  ******************************************************************************/
 970
 971 acpi_status
 972 acpi_tb_install_and_load_table(acpi_physical_address address,
 973                                u8 flags, u8 override, u32 *table_index)
 974 {
 975         acpi_status status;
 976         u32 i;
 977
 978         ACPI_FUNCTION_TRACE(tb_install_and_load_table);
 979
 980         /* Install the table and load it into the namespace */
 981
 982         status = acpi_tb_install_standard_table(address, flags, TRUE,
 983                                                 override, &i);
 984         if (ACPI_FAILURE(status)) {
 985                 goto exit;
 986         }
 987
 988         status = acpi_tb_load_table(i, acpi_gbl_root_node);
 989
 990 exit:
 991         *table_index = i;
 992         return_ACPI_STATUS(status);
 993 }
 994
 995 ACPI_EXPORT_SYMBOL(acpi_tb_install_and_load_table)
 996
 997 /*******************************************************************************
 998  *
 999  * FUNCTION:    acpi_tb_unload_table
1000  *
1001  * PARAMETERS:  table_index             - Table index
1002  *
1003  * RETURN:      Status
1004  *
1005  * DESCRIPTION: Unload an ACPI table
1006  *
1007  ******************************************************************************/
1008
1009 acpi_status acpi_tb_unload_table(u32 table_index)
1010 {
1011         acpi_status status = AE_OK;
1012         struct acpi_table_header *table;
1013
1014         ACPI_FUNCTION_TRACE(tb_unload_table);
1015
1016         /* Ensure the table is still loaded */
1017
1018         if (!acpi_tb_is_table_loaded(table_index)) {
1019                 return_ACPI_STATUS(AE_NOT_EXIST);
1020         }
1021
1022         /* Invoke table handler */
1023
1024         status = acpi_get_table_by_index(table_index, &table);
1025         if (ACPI_SUCCESS(status)) {
1026                 acpi_tb_notify_table(ACPI_TABLE_EVENT_UNLOAD, table);
1027         }
1028
1029         /* Delete the portion of the namespace owned by this table */
1030
1031         status = acpi_tb_delete_namespace_by_owner(table_index);
1032         if (ACPI_FAILURE(status)) {
1033                 return_ACPI_STATUS(status);
1034         }
1035
1036         (void)acpi_tb_release_owner_id(table_index);
1037         acpi_tb_set_table_loaded_flag(table_index, FALSE);
1038         return_ACPI_STATUS(status);
1039 }
1040
1041 ACPI_EXPORT_SYMBOL(acpi_tb_unload_table)
1042
1043 /*******************************************************************************
1044  *
1045  * FUNCTION:    acpi_tb_notify_table
1046  *
1047  * PARAMETERS:  event               - Table event
1048  *              table               - Validated table pointer
1049  *
1050  * RETURN:      None
1051  *
1052  * DESCRIPTION: Notify a table event to the users.
1053  *
1054  ******************************************************************************/
1055
1056 void acpi_tb_notify_table(u32 event, void *table)
1057 {
1058         /* Invoke table handler if present */
1059
1060         if (acpi_gbl_table_handler) {
1061                 (void)acpi_gbl_table_handler(event, table,
1062                                              acpi_gbl_table_handler_context);
1063         }
1064 }