1 /****************************************************************************** 2 * 3 * Module Name: tbdata - Table manager data structure functions 4 * 5 *****************************************************************************/ 6 7 /* 8 * Copyright (C) 2000 - 2016, 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 49 #define _COMPONENT ACPI_TABLES 50 ACPI_MODULE_NAME("tbdata") 51 52 /******************************************************************************* 53 * 54 * FUNCTION: acpi_tb_init_table_descriptor 55 * 56 * PARAMETERS: table_desc - Table descriptor 57 * address - Physical address of the table 58 * flags - Allocation flags of the table 59 * table - Pointer to the table 60 * 61 * RETURN: None 62 * 63 * DESCRIPTION: Initialize a new table descriptor 64 * 65 ******************************************************************************/ 66 void 67 acpi_tb_init_table_descriptor(struct acpi_table_desc *table_desc, 68 acpi_physical_address address, 69 u8 flags, struct acpi_table_header *table) 70 { 71 72 /* 73 * Initialize the table descriptor. Set the pointer to NULL, since the 74 * table is not fully mapped at this time. 75 */ 76 memset(table_desc, 0, sizeof(struct acpi_table_desc)); 77 table_desc->address = address; 78 table_desc->length = table->length; 79 table_desc->flags = flags; 80 ACPI_MOVE_32_TO_32(table_desc->signature.ascii, table->signature); 81 } 82 83 /******************************************************************************* 84 * 85 * FUNCTION: acpi_tb_acquire_table 86 * 87 * PARAMETERS: table_desc - Table descriptor 88 * table_ptr - Where table is returned 89 * table_length - Where table length is returned 90 * table_flags - Where table allocation flags are returned 91 * 92 * RETURN: Status 93 * 94 * DESCRIPTION: Acquire an ACPI table. It can be used for tables not 95 * maintained in the acpi_gbl_root_table_list. 96 * 97 ******************************************************************************/ 98 99 acpi_status 100 acpi_tb_acquire_table(struct acpi_table_desc *table_desc, 101 struct acpi_table_header **table_ptr, 102 u32 *table_length, u8 *table_flags) 103 { 104 struct acpi_table_header *table = NULL; 105 106 switch (table_desc->flags & ACPI_TABLE_ORIGIN_MASK) { 107 case ACPI_TABLE_ORIGIN_INTERNAL_PHYSICAL: 108 109 table = 110 acpi_os_map_memory(table_desc->address, table_desc->length); 111 break; 112 113 case ACPI_TABLE_ORIGIN_INTERNAL_VIRTUAL: 114 case ACPI_TABLE_ORIGIN_EXTERNAL_VIRTUAL: 115 116 table = ACPI_CAST_PTR(struct acpi_table_header, 117 ACPI_PHYSADDR_TO_PTR(table_desc-> 118 address)); 119 break; 120 121 default: 122 123 break; 124 } 125 126 /* Table is not valid yet */ 127 128 if (!table) { 129 return (AE_NO_MEMORY); 130 } 131 132 /* Fill the return values */ 133 134 *table_ptr = table; 135 *table_length = table_desc->length; 136 *table_flags = table_desc->flags; 137 return (AE_OK); 138 } 139 140 /******************************************************************************* 141 * 142 * FUNCTION: acpi_tb_release_table 143 * 144 * PARAMETERS: table - Pointer for the table 145 * table_length - Length for the table 146 * table_flags - Allocation flags for the table 147 * 148 * RETURN: None 149 * 150 * DESCRIPTION: Release a table. The inverse of acpi_tb_acquire_table(). 151 * 152 ******************************************************************************/ 153 154 void 155 acpi_tb_release_table(struct acpi_table_header *table, 156 u32 table_length, u8 table_flags) 157 { 158 159 switch (table_flags & ACPI_TABLE_ORIGIN_MASK) { 160 case ACPI_TABLE_ORIGIN_INTERNAL_PHYSICAL: 161 162 acpi_os_unmap_memory(table, table_length); 163 break; 164 165 case ACPI_TABLE_ORIGIN_INTERNAL_VIRTUAL: 166 case ACPI_TABLE_ORIGIN_EXTERNAL_VIRTUAL: 167 default: 168 169 break; 170 } 171 } 172 173 /******************************************************************************* 174 * 175 * FUNCTION: acpi_tb_acquire_temp_table 176 * 177 * PARAMETERS: table_desc - Table descriptor to be acquired 178 * address - Address of the table 179 * flags - Allocation flags of the table 180 * 181 * RETURN: Status 182 * 183 * DESCRIPTION: This function validates the table header to obtain the length 184 * of a table and fills the table descriptor to make its state as 185 * "INSTALLED". Such a table descriptor is only used for verified 186 * installation. 187 * 188 ******************************************************************************/ 189 190 acpi_status 191 acpi_tb_acquire_temp_table(struct acpi_table_desc *table_desc, 192 acpi_physical_address address, u8 flags) 193 { 194 struct acpi_table_header *table_header; 195 196 switch (flags & ACPI_TABLE_ORIGIN_MASK) { 197 case ACPI_TABLE_ORIGIN_INTERNAL_PHYSICAL: 198 199 /* Get the length of the full table from the header */ 200 201 table_header = 202 acpi_os_map_memory(address, 203 sizeof(struct acpi_table_header)); 204 if (!table_header) { 205 return (AE_NO_MEMORY); 206 } 207 208 acpi_tb_init_table_descriptor(table_desc, address, flags, 209 table_header); 210 acpi_os_unmap_memory(table_header, 211 sizeof(struct acpi_table_header)); 212 return (AE_OK); 213 214 case ACPI_TABLE_ORIGIN_INTERNAL_VIRTUAL: 215 case ACPI_TABLE_ORIGIN_EXTERNAL_VIRTUAL: 216 217 table_header = ACPI_CAST_PTR(struct acpi_table_header, 218 ACPI_PHYSADDR_TO_PTR(address)); 219 if (!table_header) { 220 return (AE_NO_MEMORY); 221 } 222 223 acpi_tb_init_table_descriptor(table_desc, address, flags, 224 table_header); 225 return (AE_OK); 226 227 default: 228 229 break; 230 } 231 232 /* Table is not valid yet */ 233 234 return (AE_NO_MEMORY); 235 } 236 237 /******************************************************************************* 238 * 239 * FUNCTION: acpi_tb_release_temp_table 240 * 241 * PARAMETERS: table_desc - Table descriptor to be released 242 * 243 * RETURN: Status 244 * 245 * DESCRIPTION: The inverse of acpi_tb_acquire_temp_table(). 246 * 247 *****************************************************************************/ 248 249 void acpi_tb_release_temp_table(struct acpi_table_desc *table_desc) 250 { 251 252 /* 253 * Note that the .Address is maintained by the callers of 254 * acpi_tb_acquire_temp_table(), thus do not invoke acpi_tb_uninstall_table() 255 * where .Address will be freed. 256 */ 257 acpi_tb_invalidate_table(table_desc); 258 } 259 260 /****************************************************************************** 261 * 262 * FUNCTION: acpi_tb_validate_table 263 * 264 * PARAMETERS: table_desc - Table descriptor 265 * 266 * RETURN: Status 267 * 268 * DESCRIPTION: This function is called to validate the table, the returned 269 * table descriptor is in "VALIDATED" state. 270 * 271 *****************************************************************************/ 272 273 acpi_status acpi_tb_validate_table(struct acpi_table_desc *table_desc) 274 { 275 acpi_status status = AE_OK; 276 277 ACPI_FUNCTION_TRACE(tb_validate_table); 278 279 /* Validate the table if necessary */ 280 281 if (!table_desc->pointer) { 282 status = acpi_tb_acquire_table(table_desc, &table_desc->pointer, 283 &table_desc->length, 284 &table_desc->flags); 285 if (!table_desc->pointer) { 286 status = AE_NO_MEMORY; 287 } 288 } 289 290 return_ACPI_STATUS(status); 291 } 292 293 /******************************************************************************* 294 * 295 * FUNCTION: acpi_tb_invalidate_table 296 * 297 * PARAMETERS: table_desc - Table descriptor 298 * 299 * RETURN: None 300 * 301 * DESCRIPTION: Invalidate one internal ACPI table, this is the inverse of 302 * acpi_tb_validate_table(). 303 * 304 ******************************************************************************/ 305 306 void acpi_tb_invalidate_table(struct acpi_table_desc *table_desc) 307 { 308 309 ACPI_FUNCTION_TRACE(tb_invalidate_table); 310 311 /* Table must be validated */ 312 313 if (!table_desc->pointer) { 314 return_VOID; 315 } 316 317 acpi_tb_release_table(table_desc->pointer, table_desc->length, 318 table_desc->flags); 319 table_desc->pointer = NULL; 320 321 return_VOID; 322 } 323 324 /****************************************************************************** 325 * 326 * FUNCTION: acpi_tb_validate_temp_table 327 * 328 * PARAMETERS: table_desc - Table descriptor 329 * 330 * RETURN: Status 331 * 332 * DESCRIPTION: This function is called to validate the table, the returned 333 * table descriptor is in "VALIDATED" state. 334 * 335 *****************************************************************************/ 336 337 acpi_status acpi_tb_validate_temp_table(struct acpi_table_desc *table_desc) 338 { 339 340 if (!table_desc->pointer && !acpi_gbl_verify_table_checksum) { 341 /* 342 * Only validates the header of the table. 343 * Note that Length contains the size of the mapping after invoking 344 * this work around, this value is required by 345 * acpi_tb_release_temp_table(). 346 * We can do this because in acpi_init_table_descriptor(), the Length 347 * field of the installed descriptor is filled with the actual 348 * table length obtaining from the table header. 349 */ 350 table_desc->length = sizeof(struct acpi_table_header); 351 } 352 353 return (acpi_tb_validate_table(table_desc)); 354 } 355 356 /****************************************************************************** 357 * 358 * FUNCTION: acpi_tb_verify_temp_table 359 * 360 * PARAMETERS: table_desc - Table descriptor 361 * signature - Table signature to verify 362 * 363 * RETURN: Status 364 * 365 * DESCRIPTION: This function is called to validate and verify the table, the 366 * returned table descriptor is in "VALIDATED" state. 367 * 368 *****************************************************************************/ 369 370 acpi_status 371 acpi_tb_verify_temp_table(struct acpi_table_desc * table_desc, char *signature) 372 { 373 acpi_status status = AE_OK; 374 375 ACPI_FUNCTION_TRACE(tb_verify_temp_table); 376 377 /* Validate the table */ 378 379 status = acpi_tb_validate_temp_table(table_desc); 380 if (ACPI_FAILURE(status)) { 381 return_ACPI_STATUS(AE_NO_MEMORY); 382 } 383 384 /* If a particular signature is expected (DSDT/FACS), it must match */ 385 386 if (signature && !ACPI_COMPARE_NAME(&table_desc->signature, signature)) { 387 ACPI_BIOS_ERROR((AE_INFO, 388 "Invalid signature 0x%X for ACPI table, expected [%s]", 389 table_desc->signature.integer, signature)); 390 status = AE_BAD_SIGNATURE; 391 goto invalidate_and_exit; 392 } 393 394 /* Verify the checksum */ 395 396 if (acpi_gbl_verify_table_checksum) { 397 status = 398 acpi_tb_verify_checksum(table_desc->pointer, 399 table_desc->length); 400 if (ACPI_FAILURE(status)) { 401 ACPI_EXCEPTION((AE_INFO, AE_NO_MEMORY, 402 "%4.4s 0x%8.8X%8.8X" 403 " Attempted table install failed", 404 acpi_ut_valid_acpi_name(table_desc-> 405 signature. 406 ascii) ? 407 table_desc->signature.ascii : "????", 408 ACPI_FORMAT_UINT64(table_desc-> 409 address))); 410 411 goto invalidate_and_exit; 412 } 413 } 414 415 return_ACPI_STATUS(AE_OK); 416 417 invalidate_and_exit: 418 acpi_tb_invalidate_table(table_desc); 419 return_ACPI_STATUS(status); 420 } 421 422 /******************************************************************************* 423 * 424 * FUNCTION: acpi_tb_resize_root_table_list 425 * 426 * PARAMETERS: None 427 * 428 * RETURN: Status 429 * 430 * DESCRIPTION: Expand the size of global table array 431 * 432 ******************************************************************************/ 433 434 acpi_status acpi_tb_resize_root_table_list(void) 435 { 436 struct acpi_table_desc *tables; 437 u32 table_count; 438 439 ACPI_FUNCTION_TRACE(tb_resize_root_table_list); 440 441 /* allow_resize flag is a parameter to acpi_initialize_tables */ 442 443 if (!(acpi_gbl_root_table_list.flags & ACPI_ROOT_ALLOW_RESIZE)) { 444 ACPI_ERROR((AE_INFO, 445 "Resize of Root Table Array is not allowed")); 446 return_ACPI_STATUS(AE_SUPPORT); 447 } 448 449 /* Increase the Table Array size */ 450 451 if (acpi_gbl_root_table_list.flags & ACPI_ROOT_ORIGIN_ALLOCATED) { 452 table_count = acpi_gbl_root_table_list.max_table_count; 453 } else { 454 table_count = acpi_gbl_root_table_list.current_table_count; 455 } 456 457 tables = ACPI_ALLOCATE_ZEROED(((acpi_size) table_count + 458 ACPI_ROOT_TABLE_SIZE_INCREMENT) * 459 sizeof(struct acpi_table_desc)); 460 if (!tables) { 461 ACPI_ERROR((AE_INFO, 462 "Could not allocate new root table array")); 463 return_ACPI_STATUS(AE_NO_MEMORY); 464 } 465 466 /* Copy and free the previous table array */ 467 468 if (acpi_gbl_root_table_list.tables) { 469 memcpy(tables, acpi_gbl_root_table_list.tables, 470 (acpi_size) table_count * 471 sizeof(struct acpi_table_desc)); 472 473 if (acpi_gbl_root_table_list.flags & ACPI_ROOT_ORIGIN_ALLOCATED) { 474 ACPI_FREE(acpi_gbl_root_table_list.tables); 475 } 476 } 477 478 acpi_gbl_root_table_list.tables = tables; 479 acpi_gbl_root_table_list.max_table_count = 480 table_count + ACPI_ROOT_TABLE_SIZE_INCREMENT; 481 acpi_gbl_root_table_list.flags |= ACPI_ROOT_ORIGIN_ALLOCATED; 482 483 return_ACPI_STATUS(AE_OK); 484 } 485 486 /******************************************************************************* 487 * 488 * FUNCTION: acpi_tb_get_next_table_descriptor 489 * 490 * PARAMETERS: table_index - Where table index is returned 491 * table_desc - Where table descriptor is returned 492 * 493 * RETURN: Status and table index/descriptor. 494 * 495 * DESCRIPTION: Allocate a new ACPI table entry to the global table list 496 * 497 ******************************************************************************/ 498 499 acpi_status 500 acpi_tb_get_next_table_descriptor(u32 *table_index, 501 struct acpi_table_desc **table_desc) 502 { 503 acpi_status status; 504 u32 i; 505 506 /* Ensure that there is room for the table in the Root Table List */ 507 508 if (acpi_gbl_root_table_list.current_table_count >= 509 acpi_gbl_root_table_list.max_table_count) { 510 status = acpi_tb_resize_root_table_list(); 511 if (ACPI_FAILURE(status)) { 512 return (status); 513 } 514 } 515 516 i = acpi_gbl_root_table_list.current_table_count; 517 acpi_gbl_root_table_list.current_table_count++; 518 519 if (table_index) { 520 *table_index = i; 521 } 522 if (table_desc) { 523 *table_desc = &acpi_gbl_root_table_list.tables[i]; 524 } 525 526 return (AE_OK); 527 } 528 529 /******************************************************************************* 530 * 531 * FUNCTION: acpi_tb_terminate 532 * 533 * PARAMETERS: None 534 * 535 * RETURN: None 536 * 537 * DESCRIPTION: Delete all internal ACPI tables 538 * 539 ******************************************************************************/ 540 541 void acpi_tb_terminate(void) 542 { 543 u32 i; 544 545 ACPI_FUNCTION_TRACE(tb_terminate); 546 547 (void)acpi_ut_acquire_mutex(ACPI_MTX_TABLES); 548 549 /* Delete the individual tables */ 550 551 for (i = 0; i < acpi_gbl_root_table_list.current_table_count; i++) { 552 acpi_tb_uninstall_table(&acpi_gbl_root_table_list.tables[i]); 553 } 554 555 /* 556 * Delete the root table array if allocated locally. Array cannot be 557 * mapped, so we don't need to check for that flag. 558 */ 559 if (acpi_gbl_root_table_list.flags & ACPI_ROOT_ORIGIN_ALLOCATED) { 560 ACPI_FREE(acpi_gbl_root_table_list.tables); 561 } 562 563 acpi_gbl_root_table_list.tables = NULL; 564 acpi_gbl_root_table_list.flags = 0; 565 acpi_gbl_root_table_list.current_table_count = 0; 566 567 ACPI_DEBUG_PRINT((ACPI_DB_INFO, "ACPI Tables freed\n")); 568 569 (void)acpi_ut_release_mutex(ACPI_MTX_TABLES); 570 return_VOID; 571 } 572 573 /******************************************************************************* 574 * 575 * FUNCTION: acpi_tb_delete_namespace_by_owner 576 * 577 * PARAMETERS: table_index - Table index 578 * 579 * RETURN: Status 580 * 581 * DESCRIPTION: Delete all namespace objects created when this table was loaded. 582 * 583 ******************************************************************************/ 584 585 acpi_status acpi_tb_delete_namespace_by_owner(u32 table_index) 586 { 587 acpi_owner_id owner_id; 588 acpi_status status; 589 590 ACPI_FUNCTION_TRACE(tb_delete_namespace_by_owner); 591 592 status = acpi_ut_acquire_mutex(ACPI_MTX_TABLES); 593 if (ACPI_FAILURE(status)) { 594 return_ACPI_STATUS(status); 595 } 596 597 if (table_index >= acpi_gbl_root_table_list.current_table_count) { 598 599 /* The table index does not exist */ 600 601 (void)acpi_ut_release_mutex(ACPI_MTX_TABLES); 602 return_ACPI_STATUS(AE_NOT_EXIST); 603 } 604 605 /* Get the owner ID for this table, used to delete namespace nodes */ 606 607 owner_id = acpi_gbl_root_table_list.tables[table_index].owner_id; 608 (void)acpi_ut_release_mutex(ACPI_MTX_TABLES); 609 610 /* 611 * Need to acquire the namespace writer lock to prevent interference 612 * with any concurrent namespace walks. The interpreter must be 613 * released during the deletion since the acquisition of the deletion 614 * lock may block, and also since the execution of a namespace walk 615 * must be allowed to use the interpreter. 616 */ 617 (void)acpi_ut_release_mutex(ACPI_MTX_INTERPRETER); 618 status = acpi_ut_acquire_write_lock(&acpi_gbl_namespace_rw_lock); 619 620 acpi_ns_delete_namespace_by_owner(owner_id); 621 if (ACPI_FAILURE(status)) { 622 return_ACPI_STATUS(status); 623 } 624 625 acpi_ut_release_write_lock(&acpi_gbl_namespace_rw_lock); 626 627 status = acpi_ut_acquire_mutex(ACPI_MTX_INTERPRETER); 628 return_ACPI_STATUS(status); 629 } 630 631 /******************************************************************************* 632 * 633 * FUNCTION: acpi_tb_allocate_owner_id 634 * 635 * PARAMETERS: table_index - Table index 636 * 637 * RETURN: Status 638 * 639 * DESCRIPTION: Allocates owner_id in table_desc 640 * 641 ******************************************************************************/ 642 643 acpi_status acpi_tb_allocate_owner_id(u32 table_index) 644 { 645 acpi_status status = AE_BAD_PARAMETER; 646 647 ACPI_FUNCTION_TRACE(tb_allocate_owner_id); 648 649 (void)acpi_ut_acquire_mutex(ACPI_MTX_TABLES); 650 if (table_index < acpi_gbl_root_table_list.current_table_count) { 651 status = 652 acpi_ut_allocate_owner_id(& 653 (acpi_gbl_root_table_list. 654 tables[table_index].owner_id)); 655 } 656 657 (void)acpi_ut_release_mutex(ACPI_MTX_TABLES); 658 return_ACPI_STATUS(status); 659 } 660 661 /******************************************************************************* 662 * 663 * FUNCTION: acpi_tb_release_owner_id 664 * 665 * PARAMETERS: table_index - Table index 666 * 667 * RETURN: Status 668 * 669 * DESCRIPTION: Releases owner_id in table_desc 670 * 671 ******************************************************************************/ 672 673 acpi_status acpi_tb_release_owner_id(u32 table_index) 674 { 675 acpi_status status = AE_BAD_PARAMETER; 676 677 ACPI_FUNCTION_TRACE(tb_release_owner_id); 678 679 (void)acpi_ut_acquire_mutex(ACPI_MTX_TABLES); 680 if (table_index < acpi_gbl_root_table_list.current_table_count) { 681 acpi_ut_release_owner_id(& 682 (acpi_gbl_root_table_list. 683 tables[table_index].owner_id)); 684 status = AE_OK; 685 } 686 687 (void)acpi_ut_release_mutex(ACPI_MTX_TABLES); 688 return_ACPI_STATUS(status); 689 } 690 691 /******************************************************************************* 692 * 693 * FUNCTION: acpi_tb_get_owner_id 694 * 695 * PARAMETERS: table_index - Table index 696 * owner_id - Where the table owner_id is returned 697 * 698 * RETURN: Status 699 * 700 * DESCRIPTION: returns owner_id for the ACPI table 701 * 702 ******************************************************************************/ 703 704 acpi_status acpi_tb_get_owner_id(u32 table_index, acpi_owner_id * owner_id) 705 { 706 acpi_status status = AE_BAD_PARAMETER; 707 708 ACPI_FUNCTION_TRACE(tb_get_owner_id); 709 710 (void)acpi_ut_acquire_mutex(ACPI_MTX_TABLES); 711 if (table_index < acpi_gbl_root_table_list.current_table_count) { 712 *owner_id = 713 acpi_gbl_root_table_list.tables[table_index].owner_id; 714 status = AE_OK; 715 } 716 717 (void)acpi_ut_release_mutex(ACPI_MTX_TABLES); 718 return_ACPI_STATUS(status); 719 } 720 721 /******************************************************************************* 722 * 723 * FUNCTION: acpi_tb_is_table_loaded 724 * 725 * PARAMETERS: table_index - Index into the root table 726 * 727 * RETURN: Table Loaded Flag 728 * 729 ******************************************************************************/ 730 731 u8 acpi_tb_is_table_loaded(u32 table_index) 732 { 733 u8 is_loaded = FALSE; 734 735 (void)acpi_ut_acquire_mutex(ACPI_MTX_TABLES); 736 if (table_index < acpi_gbl_root_table_list.current_table_count) { 737 is_loaded = (u8) 738 (acpi_gbl_root_table_list.tables[table_index].flags & 739 ACPI_TABLE_IS_LOADED); 740 } 741 742 (void)acpi_ut_release_mutex(ACPI_MTX_TABLES); 743 return (is_loaded); 744 } 745 746 /******************************************************************************* 747 * 748 * FUNCTION: acpi_tb_set_table_loaded_flag 749 * 750 * PARAMETERS: table_index - Table index 751 * is_loaded - TRUE if table is loaded, FALSE otherwise 752 * 753 * RETURN: None 754 * 755 * DESCRIPTION: Sets the table loaded flag to either TRUE or FALSE. 756 * 757 ******************************************************************************/ 758 759 void acpi_tb_set_table_loaded_flag(u32 table_index, u8 is_loaded) 760 { 761 762 (void)acpi_ut_acquire_mutex(ACPI_MTX_TABLES); 763 if (table_index < acpi_gbl_root_table_list.current_table_count) { 764 if (is_loaded) { 765 acpi_gbl_root_table_list.tables[table_index].flags |= 766 ACPI_TABLE_IS_LOADED; 767 } else { 768 acpi_gbl_root_table_list.tables[table_index].flags &= 769 ~ACPI_TABLE_IS_LOADED; 770 } 771 } 772 773 (void)acpi_ut_release_mutex(ACPI_MTX_TABLES); 774 } 775