1 /****************************************************************************** 2 * 3 * Module Name: tbdata - Table manager data structure functions 4 * 5 *****************************************************************************/ 6 7 /* 8 * Copyright (C) 2000 - 2014, 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 ACPI_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 = 117 ACPI_CAST_PTR(struct acpi_table_header, 118 table_desc->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, address); 218 if (!table_header) { 219 return (AE_NO_MEMORY); 220 } 221 222 acpi_tb_init_table_descriptor(table_desc, address, flags, 223 table_header); 224 return (AE_OK); 225 226 default: 227 228 break; 229 } 230 231 /* Table is not valid yet */ 232 233 return (AE_NO_MEMORY); 234 } 235 236 /******************************************************************************* 237 * 238 * FUNCTION: acpi_tb_release_temp_table 239 * 240 * PARAMETERS: table_desc - Table descriptor to be released 241 * 242 * RETURN: Status 243 * 244 * DESCRIPTION: The inverse of acpi_tb_acquire_temp_table(). 245 * 246 *****************************************************************************/ 247 248 void acpi_tb_release_temp_table(struct acpi_table_desc *table_desc) 249 { 250 251 /* 252 * Note that the .Address is maintained by the callers of 253 * acpi_tb_acquire_temp_table(), thus do not invoke acpi_tb_uninstall_table() 254 * where .Address will be freed. 255 */ 256 acpi_tb_invalidate_table(table_desc); 257 } 258 259 /****************************************************************************** 260 * 261 * FUNCTION: acpi_tb_validate_table 262 * 263 * PARAMETERS: table_desc - Table descriptor 264 * 265 * RETURN: Status 266 * 267 * DESCRIPTION: This function is called to validate the table, the returned 268 * table descriptor is in "VALIDATED" state. 269 * 270 *****************************************************************************/ 271 272 acpi_status acpi_tb_validate_table(struct acpi_table_desc *table_desc) 273 { 274 acpi_status status = AE_OK; 275 276 ACPI_FUNCTION_TRACE(tb_validate_table); 277 278 /* Validate the table if necessary */ 279 280 if (!table_desc->pointer) { 281 status = acpi_tb_acquire_table(table_desc, &table_desc->pointer, 282 &table_desc->length, 283 &table_desc->flags); 284 if (!table_desc->pointer) { 285 status = AE_NO_MEMORY; 286 } 287 } 288 289 return_ACPI_STATUS(status); 290 } 291 292 /******************************************************************************* 293 * 294 * FUNCTION: acpi_tb_invalidate_table 295 * 296 * PARAMETERS: table_desc - Table descriptor 297 * 298 * RETURN: None 299 * 300 * DESCRIPTION: Invalidate one internal ACPI table, this is the inverse of 301 * acpi_tb_validate_table(). 302 * 303 ******************************************************************************/ 304 305 void acpi_tb_invalidate_table(struct acpi_table_desc *table_desc) 306 { 307 308 ACPI_FUNCTION_TRACE(tb_invalidate_table); 309 310 /* Table must be validated */ 311 312 if (!table_desc->pointer) { 313 return_VOID; 314 } 315 316 acpi_tb_release_table(table_desc->pointer, table_desc->length, 317 table_desc->flags); 318 table_desc->pointer = NULL; 319 320 return_VOID; 321 } 322 323 /****************************************************************************** 324 * 325 * FUNCTION: acpi_tb_validate_temp_table 326 * 327 * PARAMETERS: table_desc - Table descriptor 328 * 329 * RETURN: Status 330 * 331 * DESCRIPTION: This function is called to validate the table, the returned 332 * table descriptor is in "VALIDATED" state. 333 * 334 *****************************************************************************/ 335 336 acpi_status acpi_tb_validate_temp_table(struct acpi_table_desc *table_desc) 337 { 338 339 if (!table_desc->pointer && !acpi_gbl_verify_table_checksum) { 340 /* 341 * Only validates the header of the table. 342 * Note that Length contains the size of the mapping after invoking 343 * this work around, this value is required by 344 * acpi_tb_release_temp_table(). 345 * We can do this because in acpi_init_table_descriptor(), the Length 346 * field of the installed descriptor is filled with the actual 347 * table length obtaining from the table header. 348 */ 349 table_desc->length = sizeof(struct acpi_table_header); 350 } 351 352 return (acpi_tb_validate_table(table_desc)); 353 } 354 355 /****************************************************************************** 356 * 357 * FUNCTION: acpi_tb_verify_temp_table 358 * 359 * PARAMETERS: table_desc - Table descriptor 360 * signature - Table signature to verify 361 * 362 * RETURN: Status 363 * 364 * DESCRIPTION: This function is called to validate and verify the table, the 365 * returned table descriptor is in "VALIDATED" state. 366 * 367 *****************************************************************************/ 368 369 acpi_status 370 acpi_tb_verify_temp_table(struct acpi_table_desc * table_desc, char *signature) 371 { 372 acpi_status status = AE_OK; 373 374 ACPI_FUNCTION_TRACE(tb_verify_temp_table); 375 376 /* Validate the table */ 377 378 status = acpi_tb_validate_temp_table(table_desc); 379 if (ACPI_FAILURE(status)) { 380 return_ACPI_STATUS(AE_NO_MEMORY); 381 } 382 383 /* If a particular signature is expected (DSDT/FACS), it must match */ 384 385 if (signature && !ACPI_COMPARE_NAME(&table_desc->signature, signature)) { 386 ACPI_BIOS_ERROR((AE_INFO, 387 "Invalid signature 0x%X for ACPI table, expected [%s]", 388 table_desc->signature.integer, signature)); 389 status = AE_BAD_SIGNATURE; 390 goto invalidate_and_exit; 391 } 392 393 /* Verify the checksum */ 394 395 if (acpi_gbl_verify_table_checksum) { 396 status = 397 acpi_tb_verify_checksum(table_desc->pointer, 398 table_desc->length); 399 if (ACPI_FAILURE(status)) { 400 ACPI_EXCEPTION((AE_INFO, AE_NO_MEMORY, 401 "%4.4s " ACPI_PRINTF_UINT 402 " Attempted table install failed", 403 acpi_ut_valid_acpi_name(table_desc-> 404 signature. 405 ascii) ? 406 table_desc->signature.ascii : "????", 407 ACPI_FORMAT_TO_UINT(table_desc-> 408 address))); 409 goto invalidate_and_exit; 410 } 411 } 412 413 return_ACPI_STATUS(AE_OK); 414 415 invalidate_and_exit: 416 acpi_tb_invalidate_table(table_desc); 417 return_ACPI_STATUS(status); 418 } 419 420 /******************************************************************************* 421 * 422 * FUNCTION: acpi_tb_resize_root_table_list 423 * 424 * PARAMETERS: None 425 * 426 * RETURN: Status 427 * 428 * DESCRIPTION: Expand the size of global table array 429 * 430 ******************************************************************************/ 431 432 acpi_status acpi_tb_resize_root_table_list(void) 433 { 434 struct acpi_table_desc *tables; 435 u32 table_count; 436 437 ACPI_FUNCTION_TRACE(tb_resize_root_table_list); 438 439 /* allow_resize flag is a parameter to acpi_initialize_tables */ 440 441 if (!(acpi_gbl_root_table_list.flags & ACPI_ROOT_ALLOW_RESIZE)) { 442 ACPI_ERROR((AE_INFO, 443 "Resize of Root Table Array is not allowed")); 444 return_ACPI_STATUS(AE_SUPPORT); 445 } 446 447 /* Increase the Table Array size */ 448 449 if (acpi_gbl_root_table_list.flags & ACPI_ROOT_ORIGIN_ALLOCATED) { 450 table_count = acpi_gbl_root_table_list.max_table_count; 451 } else { 452 table_count = acpi_gbl_root_table_list.current_table_count; 453 } 454 455 tables = ACPI_ALLOCATE_ZEROED(((acpi_size) table_count + 456 ACPI_ROOT_TABLE_SIZE_INCREMENT) * 457 sizeof(struct acpi_table_desc)); 458 if (!tables) { 459 ACPI_ERROR((AE_INFO, 460 "Could not allocate new root table array")); 461 return_ACPI_STATUS(AE_NO_MEMORY); 462 } 463 464 /* Copy and free the previous table array */ 465 466 if (acpi_gbl_root_table_list.tables) { 467 ACPI_MEMCPY(tables, acpi_gbl_root_table_list.tables, 468 (acpi_size) table_count * 469 sizeof(struct acpi_table_desc)); 470 471 if (acpi_gbl_root_table_list.flags & ACPI_ROOT_ORIGIN_ALLOCATED) { 472 ACPI_FREE(acpi_gbl_root_table_list.tables); 473 } 474 } 475 476 acpi_gbl_root_table_list.tables = tables; 477 acpi_gbl_root_table_list.max_table_count = 478 table_count + ACPI_ROOT_TABLE_SIZE_INCREMENT; 479 acpi_gbl_root_table_list.flags |= ACPI_ROOT_ORIGIN_ALLOCATED; 480 481 return_ACPI_STATUS(AE_OK); 482 } 483 484 /******************************************************************************* 485 * 486 * FUNCTION: acpi_tb_get_next_root_index 487 * 488 * PARAMETERS: table_index - Where table index is returned 489 * 490 * RETURN: Status and table index. 491 * 492 * DESCRIPTION: Allocate a new ACPI table entry to the global table list 493 * 494 ******************************************************************************/ 495 496 acpi_status acpi_tb_get_next_root_index(u32 *table_index) 497 { 498 acpi_status status; 499 500 /* Ensure that there is room for the table in the Root Table List */ 501 502 if (acpi_gbl_root_table_list.current_table_count >= 503 acpi_gbl_root_table_list.max_table_count) { 504 status = acpi_tb_resize_root_table_list(); 505 if (ACPI_FAILURE(status)) { 506 return (status); 507 } 508 } 509 510 *table_index = acpi_gbl_root_table_list.current_table_count; 511 acpi_gbl_root_table_list.current_table_count++; 512 return (AE_OK); 513 } 514 515 /******************************************************************************* 516 * 517 * FUNCTION: acpi_tb_terminate 518 * 519 * PARAMETERS: None 520 * 521 * RETURN: None 522 * 523 * DESCRIPTION: Delete all internal ACPI tables 524 * 525 ******************************************************************************/ 526 527 void acpi_tb_terminate(void) 528 { 529 u32 i; 530 531 ACPI_FUNCTION_TRACE(tb_terminate); 532 533 (void)acpi_ut_acquire_mutex(ACPI_MTX_TABLES); 534 535 /* Delete the individual tables */ 536 537 for (i = 0; i < acpi_gbl_root_table_list.current_table_count; i++) { 538 acpi_tb_uninstall_table(&acpi_gbl_root_table_list.tables[i]); 539 } 540 541 /* 542 * Delete the root table array if allocated locally. Array cannot be 543 * mapped, so we don't need to check for that flag. 544 */ 545 if (acpi_gbl_root_table_list.flags & ACPI_ROOT_ORIGIN_ALLOCATED) { 546 ACPI_FREE(acpi_gbl_root_table_list.tables); 547 } 548 549 acpi_gbl_root_table_list.tables = NULL; 550 acpi_gbl_root_table_list.flags = 0; 551 acpi_gbl_root_table_list.current_table_count = 0; 552 553 ACPI_DEBUG_PRINT((ACPI_DB_INFO, "ACPI Tables freed\n")); 554 555 (void)acpi_ut_release_mutex(ACPI_MTX_TABLES); 556 return_VOID; 557 } 558 559 /******************************************************************************* 560 * 561 * FUNCTION: acpi_tb_delete_namespace_by_owner 562 * 563 * PARAMETERS: table_index - Table index 564 * 565 * RETURN: Status 566 * 567 * DESCRIPTION: Delete all namespace objects created when this table was loaded. 568 * 569 ******************************************************************************/ 570 571 acpi_status acpi_tb_delete_namespace_by_owner(u32 table_index) 572 { 573 acpi_owner_id owner_id; 574 acpi_status status; 575 576 ACPI_FUNCTION_TRACE(tb_delete_namespace_by_owner); 577 578 status = acpi_ut_acquire_mutex(ACPI_MTX_TABLES); 579 if (ACPI_FAILURE(status)) { 580 return_ACPI_STATUS(status); 581 } 582 583 if (table_index >= acpi_gbl_root_table_list.current_table_count) { 584 585 /* The table index does not exist */ 586 587 (void)acpi_ut_release_mutex(ACPI_MTX_TABLES); 588 return_ACPI_STATUS(AE_NOT_EXIST); 589 } 590 591 /* Get the owner ID for this table, used to delete namespace nodes */ 592 593 owner_id = acpi_gbl_root_table_list.tables[table_index].owner_id; 594 (void)acpi_ut_release_mutex(ACPI_MTX_TABLES); 595 596 /* 597 * Need to acquire the namespace writer lock to prevent interference 598 * with any concurrent namespace walks. The interpreter must be 599 * released during the deletion since the acquisition of the deletion 600 * lock may block, and also since the execution of a namespace walk 601 * must be allowed to use the interpreter. 602 */ 603 (void)acpi_ut_release_mutex(ACPI_MTX_INTERPRETER); 604 status = acpi_ut_acquire_write_lock(&acpi_gbl_namespace_rw_lock); 605 606 acpi_ns_delete_namespace_by_owner(owner_id); 607 if (ACPI_FAILURE(status)) { 608 return_ACPI_STATUS(status); 609 } 610 611 acpi_ut_release_write_lock(&acpi_gbl_namespace_rw_lock); 612 613 status = acpi_ut_acquire_mutex(ACPI_MTX_INTERPRETER); 614 return_ACPI_STATUS(status); 615 } 616 617 /******************************************************************************* 618 * 619 * FUNCTION: acpi_tb_allocate_owner_id 620 * 621 * PARAMETERS: table_index - Table index 622 * 623 * RETURN: Status 624 * 625 * DESCRIPTION: Allocates owner_id in table_desc 626 * 627 ******************************************************************************/ 628 629 acpi_status acpi_tb_allocate_owner_id(u32 table_index) 630 { 631 acpi_status status = AE_BAD_PARAMETER; 632 633 ACPI_FUNCTION_TRACE(tb_allocate_owner_id); 634 635 (void)acpi_ut_acquire_mutex(ACPI_MTX_TABLES); 636 if (table_index < acpi_gbl_root_table_list.current_table_count) { 637 status = 638 acpi_ut_allocate_owner_id(& 639 (acpi_gbl_root_table_list. 640 tables[table_index].owner_id)); 641 } 642 643 (void)acpi_ut_release_mutex(ACPI_MTX_TABLES); 644 return_ACPI_STATUS(status); 645 } 646 647 /******************************************************************************* 648 * 649 * FUNCTION: acpi_tb_release_owner_id 650 * 651 * PARAMETERS: table_index - Table index 652 * 653 * RETURN: Status 654 * 655 * DESCRIPTION: Releases owner_id in table_desc 656 * 657 ******************************************************************************/ 658 659 acpi_status acpi_tb_release_owner_id(u32 table_index) 660 { 661 acpi_status status = AE_BAD_PARAMETER; 662 663 ACPI_FUNCTION_TRACE(tb_release_owner_id); 664 665 (void)acpi_ut_acquire_mutex(ACPI_MTX_TABLES); 666 if (table_index < acpi_gbl_root_table_list.current_table_count) { 667 acpi_ut_release_owner_id(& 668 (acpi_gbl_root_table_list. 669 tables[table_index].owner_id)); 670 status = AE_OK; 671 } 672 673 (void)acpi_ut_release_mutex(ACPI_MTX_TABLES); 674 return_ACPI_STATUS(status); 675 } 676 677 /******************************************************************************* 678 * 679 * FUNCTION: acpi_tb_get_owner_id 680 * 681 * PARAMETERS: table_index - Table index 682 * owner_id - Where the table owner_id is returned 683 * 684 * RETURN: Status 685 * 686 * DESCRIPTION: returns owner_id for the ACPI table 687 * 688 ******************************************************************************/ 689 690 acpi_status acpi_tb_get_owner_id(u32 table_index, acpi_owner_id * owner_id) 691 { 692 acpi_status status = AE_BAD_PARAMETER; 693 694 ACPI_FUNCTION_TRACE(tb_get_owner_id); 695 696 (void)acpi_ut_acquire_mutex(ACPI_MTX_TABLES); 697 if (table_index < acpi_gbl_root_table_list.current_table_count) { 698 *owner_id = 699 acpi_gbl_root_table_list.tables[table_index].owner_id; 700 status = AE_OK; 701 } 702 703 (void)acpi_ut_release_mutex(ACPI_MTX_TABLES); 704 return_ACPI_STATUS(status); 705 } 706 707 /******************************************************************************* 708 * 709 * FUNCTION: acpi_tb_is_table_loaded 710 * 711 * PARAMETERS: table_index - Index into the root table 712 * 713 * RETURN: Table Loaded Flag 714 * 715 ******************************************************************************/ 716 717 u8 acpi_tb_is_table_loaded(u32 table_index) 718 { 719 u8 is_loaded = FALSE; 720 721 (void)acpi_ut_acquire_mutex(ACPI_MTX_TABLES); 722 if (table_index < acpi_gbl_root_table_list.current_table_count) { 723 is_loaded = (u8) 724 (acpi_gbl_root_table_list.tables[table_index].flags & 725 ACPI_TABLE_IS_LOADED); 726 } 727 728 (void)acpi_ut_release_mutex(ACPI_MTX_TABLES); 729 return (is_loaded); 730 } 731 732 /******************************************************************************* 733 * 734 * FUNCTION: acpi_tb_set_table_loaded_flag 735 * 736 * PARAMETERS: table_index - Table index 737 * is_loaded - TRUE if table is loaded, FALSE otherwise 738 * 739 * RETURN: None 740 * 741 * DESCRIPTION: Sets the table loaded flag to either TRUE or FALSE. 742 * 743 ******************************************************************************/ 744 745 void acpi_tb_set_table_loaded_flag(u32 table_index, u8 is_loaded) 746 { 747 748 (void)acpi_ut_acquire_mutex(ACPI_MTX_TABLES); 749 if (table_index < acpi_gbl_root_table_list.current_table_count) { 750 if (is_loaded) { 751 acpi_gbl_root_table_list.tables[table_index].flags |= 752 ACPI_TABLE_IS_LOADED; 753 } else { 754 acpi_gbl_root_table_list.tables[table_index].flags &= 755 ~ACPI_TABLE_IS_LOADED; 756 } 757 } 758 759 (void)acpi_ut_release_mutex(ACPI_MTX_TABLES); 760 } 761