1 /****************************************************************************** 2 * 3 * Module Name: tbxface - Public interfaces to the ACPI subsystem 4 * ACPI table oriented interfaces 5 * 6 *****************************************************************************/ 7 8 /* 9 * Copyright (C) 2000 - 2010, Intel Corp. 10 * All rights reserved. 11 * 12 * Redistribution and use in source and binary forms, with or without 13 * modification, are permitted provided that the following conditions 14 * are met: 15 * 1. Redistributions of source code must retain the above copyright 16 * notice, this list of conditions, and the following disclaimer, 17 * without modification. 18 * 2. Redistributions in binary form must reproduce at minimum a disclaimer 19 * substantially similar to the "NO WARRANTY" disclaimer below 20 * ("Disclaimer") and any redistribution must be conditioned upon 21 * including a substantially similar Disclaimer requirement for further 22 * binary redistribution. 23 * 3. Neither the names of the above-listed copyright holders nor the names 24 * of any contributors may be used to endorse or promote products derived 25 * from this software without specific prior written permission. 26 * 27 * Alternatively, this software may be distributed under the terms of the 28 * GNU General Public License ("GPL") version 2 as published by the Free 29 * Software Foundation. 30 * 31 * NO WARRANTY 32 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS 33 * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT 34 * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTIBILITY AND FITNESS FOR 35 * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT 36 * HOLDERS OR CONTRIBUTORS BE LIABLE FOR SPECIAL, EXEMPLARY, OR CONSEQUENTIAL 37 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS 38 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) 39 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, 40 * STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING 41 * IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE 42 * POSSIBILITY OF SUCH DAMAGES. 43 */ 44 45 #include <acpi/acpi.h> 46 #include "accommon.h" 47 #include "acnamesp.h" 48 #include "actables.h" 49 50 #define _COMPONENT ACPI_TABLES 51 ACPI_MODULE_NAME("tbxface") 52 53 /* Local prototypes */ 54 static acpi_status acpi_tb_load_namespace(void); 55 56 static int no_auto_ssdt; 57 58 /******************************************************************************* 59 * 60 * FUNCTION: acpi_allocate_root_table 61 * 62 * PARAMETERS: initial_table_count - Size of initial_table_array, in number of 63 * struct acpi_table_desc structures 64 * 65 * RETURN: Status 66 * 67 * DESCRIPTION: Allocate a root table array. Used by i_aSL compiler and 68 * acpi_initialize_tables. 69 * 70 ******************************************************************************/ 71 72 acpi_status acpi_allocate_root_table(u32 initial_table_count) 73 { 74 75 acpi_gbl_root_table_list.max_table_count = initial_table_count; 76 acpi_gbl_root_table_list.flags = ACPI_ROOT_ALLOW_RESIZE; 77 78 return (acpi_tb_resize_root_table_list()); 79 } 80 81 /******************************************************************************* 82 * 83 * FUNCTION: acpi_initialize_tables 84 * 85 * PARAMETERS: initial_table_array - Pointer to an array of pre-allocated 86 * struct acpi_table_desc structures. If NULL, the 87 * array is dynamically allocated. 88 * initial_table_count - Size of initial_table_array, in number of 89 * struct acpi_table_desc structures 90 * allow_realloc - Flag to tell Table Manager if resize of 91 * pre-allocated array is allowed. Ignored 92 * if initial_table_array is NULL. 93 * 94 * RETURN: Status 95 * 96 * DESCRIPTION: Initialize the table manager, get the RSDP and RSDT/XSDT. 97 * 98 * NOTE: Allows static allocation of the initial table array in order 99 * to avoid the use of dynamic memory in confined environments 100 * such as the kernel boot sequence where it may not be available. 101 * 102 * If the host OS memory managers are initialized, use NULL for 103 * initial_table_array, and the table will be dynamically allocated. 104 * 105 ******************************************************************************/ 106 107 acpi_status __init 108 acpi_initialize_tables(struct acpi_table_desc * initial_table_array, 109 u32 initial_table_count, u8 allow_resize) 110 { 111 acpi_physical_address rsdp_address; 112 acpi_status status; 113 114 ACPI_FUNCTION_TRACE(acpi_initialize_tables); 115 116 /* 117 * Set up the Root Table Array 118 * Allocate the table array if requested 119 */ 120 if (!initial_table_array) { 121 status = acpi_allocate_root_table(initial_table_count); 122 if (ACPI_FAILURE(status)) { 123 return_ACPI_STATUS(status); 124 } 125 } else { 126 /* Root Table Array has been statically allocated by the host */ 127 128 ACPI_MEMSET(initial_table_array, 0, 129 (acpi_size) initial_table_count * 130 sizeof(struct acpi_table_desc)); 131 132 acpi_gbl_root_table_list.tables = initial_table_array; 133 acpi_gbl_root_table_list.max_table_count = initial_table_count; 134 acpi_gbl_root_table_list.flags = ACPI_ROOT_ORIGIN_UNKNOWN; 135 if (allow_resize) { 136 acpi_gbl_root_table_list.flags |= 137 ACPI_ROOT_ALLOW_RESIZE; 138 } 139 } 140 141 /* Get the address of the RSDP */ 142 143 rsdp_address = acpi_os_get_root_pointer(); 144 if (!rsdp_address) { 145 return_ACPI_STATUS(AE_NOT_FOUND); 146 } 147 148 /* 149 * Get the root table (RSDT or XSDT) and extract all entries to the local 150 * Root Table Array. This array contains the information of the RSDT/XSDT 151 * in a common, more useable format. 152 */ 153 status = acpi_tb_parse_root_table(rsdp_address); 154 return_ACPI_STATUS(status); 155 } 156 157 /******************************************************************************* 158 * 159 * FUNCTION: acpi_reallocate_root_table 160 * 161 * PARAMETERS: None 162 * 163 * RETURN: Status 164 * 165 * DESCRIPTION: Reallocate Root Table List into dynamic memory. Copies the 166 * root list from the previously provided scratch area. Should 167 * be called once dynamic memory allocation is available in the 168 * kernel 169 * 170 ******************************************************************************/ 171 acpi_status acpi_reallocate_root_table(void) 172 { 173 struct acpi_table_desc *tables; 174 acpi_size new_size; 175 acpi_size current_size; 176 177 ACPI_FUNCTION_TRACE(acpi_reallocate_root_table); 178 179 /* 180 * Only reallocate the root table if the host provided a static buffer 181 * for the table array in the call to acpi_initialize_tables. 182 */ 183 if (acpi_gbl_root_table_list.flags & ACPI_ROOT_ORIGIN_ALLOCATED) { 184 return_ACPI_STATUS(AE_SUPPORT); 185 } 186 187 /* 188 * Get the current size of the root table and add the default 189 * increment to create the new table size. 190 */ 191 current_size = (acpi_size) 192 acpi_gbl_root_table_list.current_table_count * 193 sizeof(struct acpi_table_desc); 194 195 new_size = current_size + 196 (ACPI_ROOT_TABLE_SIZE_INCREMENT * sizeof(struct acpi_table_desc)); 197 198 /* Create new array and copy the old array */ 199 200 tables = ACPI_ALLOCATE_ZEROED(new_size); 201 if (!tables) { 202 return_ACPI_STATUS(AE_NO_MEMORY); 203 } 204 205 ACPI_MEMCPY(tables, acpi_gbl_root_table_list.tables, current_size); 206 207 /* 208 * Update the root table descriptor. The new size will be the current 209 * number of tables plus the increment, independent of the reserved 210 * size of the original table list. 211 */ 212 acpi_gbl_root_table_list.tables = tables; 213 acpi_gbl_root_table_list.max_table_count = 214 acpi_gbl_root_table_list.current_table_count + 215 ACPI_ROOT_TABLE_SIZE_INCREMENT; 216 acpi_gbl_root_table_list.flags = 217 ACPI_ROOT_ORIGIN_ALLOCATED | ACPI_ROOT_ALLOW_RESIZE; 218 219 return_ACPI_STATUS(AE_OK); 220 } 221 222 /******************************************************************************* 223 * 224 * FUNCTION: acpi_load_table 225 * 226 * PARAMETERS: table_ptr - pointer to a buffer containing the entire 227 * table to be loaded 228 * 229 * RETURN: Status 230 * 231 * DESCRIPTION: This function is called to load a table from the caller's 232 * buffer. The buffer must contain an entire ACPI Table including 233 * a valid header. The header fields will be verified, and if it 234 * is determined that the table is invalid, the call will fail. 235 * 236 ******************************************************************************/ 237 acpi_status acpi_load_table(struct acpi_table_header *table_ptr) 238 { 239 acpi_status status; 240 u32 table_index; 241 struct acpi_table_desc table_desc; 242 243 if (!table_ptr) 244 return AE_BAD_PARAMETER; 245 246 ACPI_MEMSET(&table_desc, 0, sizeof(struct acpi_table_desc)); 247 table_desc.pointer = table_ptr; 248 table_desc.length = table_ptr->length; 249 table_desc.flags = ACPI_TABLE_ORIGIN_UNKNOWN; 250 251 /* 252 * Install the new table into the local data structures 253 */ 254 status = acpi_tb_add_table(&table_desc, &table_index); 255 if (ACPI_FAILURE(status)) { 256 return status; 257 } 258 status = acpi_ns_load_table(table_index, acpi_gbl_root_node); 259 return status; 260 } 261 262 ACPI_EXPORT_SYMBOL(acpi_load_table) 263 264 /******************************************************************************* 265 * 266 * FUNCTION: acpi_get_table_header 267 * 268 * PARAMETERS: Signature - ACPI signature of needed table 269 * Instance - Which instance (for SSDTs) 270 * out_table_header - The pointer to the table header to fill 271 * 272 * RETURN: Status and pointer to mapped table header 273 * 274 * DESCRIPTION: Finds an ACPI table header. 275 * 276 * NOTE: Caller is responsible in unmapping the header with 277 * acpi_os_unmap_memory 278 * 279 ******************************************************************************/ 280 acpi_status 281 acpi_get_table_header(char *signature, 282 u32 instance, struct acpi_table_header *out_table_header) 283 { 284 u32 i; 285 u32 j; 286 struct acpi_table_header *header; 287 288 /* Parameter validation */ 289 290 if (!signature || !out_table_header) { 291 return (AE_BAD_PARAMETER); 292 } 293 294 /* Walk the root table list */ 295 296 for (i = 0, j = 0; i < acpi_gbl_root_table_list.current_table_count; 297 i++) { 298 if (!ACPI_COMPARE_NAME 299 (&(acpi_gbl_root_table_list.tables[i].signature), 300 signature)) { 301 continue; 302 } 303 304 if (++j < instance) { 305 continue; 306 } 307 308 if (!acpi_gbl_root_table_list.tables[i].pointer) { 309 if ((acpi_gbl_root_table_list.tables[i].flags & 310 ACPI_TABLE_ORIGIN_MASK) == 311 ACPI_TABLE_ORIGIN_MAPPED) { 312 header = 313 acpi_os_map_memory(acpi_gbl_root_table_list. 314 tables[i].address, 315 sizeof(struct 316 acpi_table_header)); 317 if (!header) { 318 return AE_NO_MEMORY; 319 } 320 ACPI_MEMCPY(out_table_header, header, 321 sizeof(struct acpi_table_header)); 322 acpi_os_unmap_memory(header, 323 sizeof(struct 324 acpi_table_header)); 325 } else { 326 return AE_NOT_FOUND; 327 } 328 } else { 329 ACPI_MEMCPY(out_table_header, 330 acpi_gbl_root_table_list.tables[i].pointer, 331 sizeof(struct acpi_table_header)); 332 } 333 return (AE_OK); 334 } 335 336 return (AE_NOT_FOUND); 337 } 338 339 ACPI_EXPORT_SYMBOL(acpi_get_table_header) 340 341 /******************************************************************************* 342 * 343 * FUNCTION: acpi_unload_table_id 344 * 345 * PARAMETERS: id - Owner ID of the table to be removed. 346 * 347 * RETURN: Status 348 * 349 * DESCRIPTION: This routine is used to force the unload of a table (by id) 350 * 351 ******************************************************************************/ 352 acpi_status acpi_unload_table_id(acpi_owner_id id) 353 { 354 int i; 355 acpi_status status = AE_NOT_EXIST; 356 357 ACPI_FUNCTION_TRACE(acpi_unload_table_id); 358 359 /* Find table in the global table list */ 360 for (i = 0; i < acpi_gbl_root_table_list.current_table_count; ++i) { 361 if (id != acpi_gbl_root_table_list.tables[i].owner_id) { 362 continue; 363 } 364 /* 365 * Delete all namespace objects owned by this table. Note that these 366 * objects can appear anywhere in the namespace by virtue of the AML 367 * "Scope" operator. Thus, we need to track ownership by an ID, not 368 * simply a position within the hierarchy 369 */ 370 acpi_tb_delete_namespace_by_owner(i); 371 status = acpi_tb_release_owner_id(i); 372 acpi_tb_set_table_loaded_flag(i, FALSE); 373 break; 374 } 375 return_ACPI_STATUS(status); 376 } 377 378 ACPI_EXPORT_SYMBOL(acpi_unload_table_id) 379 380 /******************************************************************************* 381 * 382 * FUNCTION: acpi_get_table_with_size 383 * 384 * PARAMETERS: Signature - ACPI signature of needed table 385 * Instance - Which instance (for SSDTs) 386 * out_table - Where the pointer to the table is returned 387 * 388 * RETURN: Status and pointer to table 389 * 390 * DESCRIPTION: Finds and verifies an ACPI table. 391 * 392 ******************************************************************************/ 393 acpi_status 394 acpi_get_table_with_size(char *signature, 395 u32 instance, struct acpi_table_header **out_table, 396 acpi_size *tbl_size) 397 { 398 u32 i; 399 u32 j; 400 acpi_status status; 401 402 /* Parameter validation */ 403 404 if (!signature || !out_table) { 405 return (AE_BAD_PARAMETER); 406 } 407 408 /* Walk the root table list */ 409 410 for (i = 0, j = 0; i < acpi_gbl_root_table_list.current_table_count; 411 i++) { 412 if (!ACPI_COMPARE_NAME 413 (&(acpi_gbl_root_table_list.tables[i].signature), 414 signature)) { 415 continue; 416 } 417 418 if (++j < instance) { 419 continue; 420 } 421 422 status = 423 acpi_tb_verify_table(&acpi_gbl_root_table_list.tables[i]); 424 if (ACPI_SUCCESS(status)) { 425 *out_table = acpi_gbl_root_table_list.tables[i].pointer; 426 *tbl_size = acpi_gbl_root_table_list.tables[i].length; 427 } 428 429 if (!acpi_gbl_permanent_mmap) { 430 acpi_gbl_root_table_list.tables[i].pointer = NULL; 431 } 432 433 return (status); 434 } 435 436 return (AE_NOT_FOUND); 437 } 438 439 acpi_status 440 acpi_get_table(char *signature, 441 u32 instance, struct acpi_table_header **out_table) 442 { 443 acpi_size tbl_size; 444 445 return acpi_get_table_with_size(signature, 446 instance, out_table, &tbl_size); 447 } 448 ACPI_EXPORT_SYMBOL(acpi_get_table) 449 450 /******************************************************************************* 451 * 452 * FUNCTION: acpi_get_table_by_index 453 * 454 * PARAMETERS: table_index - Table index 455 * Table - Where the pointer to the table is returned 456 * 457 * RETURN: Status and pointer to the table 458 * 459 * DESCRIPTION: Obtain a table by an index into the global table list. 460 * 461 ******************************************************************************/ 462 acpi_status 463 acpi_get_table_by_index(u32 table_index, struct acpi_table_header **table) 464 { 465 acpi_status status; 466 467 ACPI_FUNCTION_TRACE(acpi_get_table_by_index); 468 469 /* Parameter validation */ 470 471 if (!table) { 472 return_ACPI_STATUS(AE_BAD_PARAMETER); 473 } 474 475 (void)acpi_ut_acquire_mutex(ACPI_MTX_TABLES); 476 477 /* Validate index */ 478 479 if (table_index >= acpi_gbl_root_table_list.current_table_count) { 480 (void)acpi_ut_release_mutex(ACPI_MTX_TABLES); 481 return_ACPI_STATUS(AE_BAD_PARAMETER); 482 } 483 484 if (!acpi_gbl_root_table_list.tables[table_index].pointer) { 485 486 /* Table is not mapped, map it */ 487 488 status = 489 acpi_tb_verify_table(&acpi_gbl_root_table_list. 490 tables[table_index]); 491 if (ACPI_FAILURE(status)) { 492 (void)acpi_ut_release_mutex(ACPI_MTX_TABLES); 493 return_ACPI_STATUS(status); 494 } 495 } 496 497 *table = acpi_gbl_root_table_list.tables[table_index].pointer; 498 (void)acpi_ut_release_mutex(ACPI_MTX_TABLES); 499 return_ACPI_STATUS(AE_OK); 500 } 501 502 ACPI_EXPORT_SYMBOL(acpi_get_table_by_index) 503 504 /******************************************************************************* 505 * 506 * FUNCTION: acpi_tb_load_namespace 507 * 508 * PARAMETERS: None 509 * 510 * RETURN: Status 511 * 512 * DESCRIPTION: Load the namespace from the DSDT and all SSDTs/PSDTs found in 513 * the RSDT/XSDT. 514 * 515 ******************************************************************************/ 516 static acpi_status acpi_tb_load_namespace(void) 517 { 518 acpi_status status; 519 u32 i; 520 struct acpi_table_header *new_dsdt; 521 522 ACPI_FUNCTION_TRACE(tb_load_namespace); 523 524 (void)acpi_ut_acquire_mutex(ACPI_MTX_TABLES); 525 526 /* 527 * Load the namespace. The DSDT is required, but any SSDT and 528 * PSDT tables are optional. Verify the DSDT. 529 */ 530 if (!acpi_gbl_root_table_list.current_table_count || 531 !ACPI_COMPARE_NAME(& 532 (acpi_gbl_root_table_list. 533 tables[ACPI_TABLE_INDEX_DSDT].signature), 534 ACPI_SIG_DSDT) 535 || 536 ACPI_FAILURE(acpi_tb_verify_table 537 (&acpi_gbl_root_table_list. 538 tables[ACPI_TABLE_INDEX_DSDT]))) { 539 status = AE_NO_ACPI_TABLES; 540 goto unlock_and_exit; 541 } 542 543 /* 544 * Save the DSDT pointer for simple access. This is the mapped memory 545 * address. We must take care here because the address of the .Tables 546 * array can change dynamically as tables are loaded at run-time. Note: 547 * .Pointer field is not validated until after call to acpi_tb_verify_table. 548 */ 549 acpi_gbl_DSDT = 550 acpi_gbl_root_table_list.tables[ACPI_TABLE_INDEX_DSDT].pointer; 551 552 /* 553 * Optionally copy the entire DSDT to local memory (instead of simply 554 * mapping it.) There are some BIOSs that corrupt or replace the original 555 * DSDT, creating the need for this option. Default is FALSE, do not copy 556 * the DSDT. 557 */ 558 if (acpi_gbl_copy_dsdt_locally) { 559 new_dsdt = acpi_tb_copy_dsdt(ACPI_TABLE_INDEX_DSDT); 560 if (new_dsdt) { 561 acpi_gbl_DSDT = new_dsdt; 562 } 563 } 564 565 /* 566 * Save the original DSDT header for detection of table corruption 567 * and/or replacement of the DSDT from outside the OS. 568 */ 569 ACPI_MEMCPY(&acpi_gbl_original_dsdt_header, acpi_gbl_DSDT, 570 sizeof(struct acpi_table_header)); 571 572 (void)acpi_ut_release_mutex(ACPI_MTX_TABLES); 573 574 /* Load and parse tables */ 575 576 status = acpi_ns_load_table(ACPI_TABLE_INDEX_DSDT, acpi_gbl_root_node); 577 if (ACPI_FAILURE(status)) { 578 return_ACPI_STATUS(status); 579 } 580 581 /* Load any SSDT or PSDT tables. Note: Loop leaves tables locked */ 582 583 (void)acpi_ut_acquire_mutex(ACPI_MTX_TABLES); 584 for (i = 0; i < acpi_gbl_root_table_list.current_table_count; ++i) { 585 if ((!ACPI_COMPARE_NAME 586 (&(acpi_gbl_root_table_list.tables[i].signature), 587 ACPI_SIG_SSDT) 588 && 589 !ACPI_COMPARE_NAME(& 590 (acpi_gbl_root_table_list.tables[i]. 591 signature), ACPI_SIG_PSDT)) 592 || 593 ACPI_FAILURE(acpi_tb_verify_table 594 (&acpi_gbl_root_table_list.tables[i]))) { 595 continue; 596 } 597 598 if (no_auto_ssdt) { 599 printk(KERN_WARNING "ACPI: SSDT ignored due to \"acpi_no_auto_ssdt\"\n"); 600 continue; 601 } 602 603 /* Ignore errors while loading tables, get as many as possible */ 604 605 (void)acpi_ut_release_mutex(ACPI_MTX_TABLES); 606 (void)acpi_ns_load_table(i, acpi_gbl_root_node); 607 (void)acpi_ut_acquire_mutex(ACPI_MTX_TABLES); 608 } 609 610 ACPI_DEBUG_PRINT((ACPI_DB_INIT, "ACPI Tables successfully acquired\n")); 611 612 unlock_and_exit: 613 (void)acpi_ut_release_mutex(ACPI_MTX_TABLES); 614 return_ACPI_STATUS(status); 615 } 616 617 /******************************************************************************* 618 * 619 * FUNCTION: acpi_load_tables 620 * 621 * PARAMETERS: None 622 * 623 * RETURN: Status 624 * 625 * DESCRIPTION: Load the ACPI tables from the RSDT/XSDT 626 * 627 ******************************************************************************/ 628 629 acpi_status acpi_load_tables(void) 630 { 631 acpi_status status; 632 633 ACPI_FUNCTION_TRACE(acpi_load_tables); 634 635 /* Load the namespace from the tables */ 636 637 status = acpi_tb_load_namespace(); 638 if (ACPI_FAILURE(status)) { 639 ACPI_EXCEPTION((AE_INFO, status, 640 "While loading namespace from ACPI tables")); 641 } 642 643 return_ACPI_STATUS(status); 644 } 645 646 ACPI_EXPORT_SYMBOL(acpi_load_tables) 647 648 649 /******************************************************************************* 650 * 651 * FUNCTION: acpi_install_table_handler 652 * 653 * PARAMETERS: Handler - Table event handler 654 * Context - Value passed to the handler on each event 655 * 656 * RETURN: Status 657 * 658 * DESCRIPTION: Install table event handler 659 * 660 ******************************************************************************/ 661 acpi_status 662 acpi_install_table_handler(acpi_tbl_handler handler, void *context) 663 { 664 acpi_status status; 665 666 ACPI_FUNCTION_TRACE(acpi_install_table_handler); 667 668 if (!handler) { 669 return_ACPI_STATUS(AE_BAD_PARAMETER); 670 } 671 672 status = acpi_ut_acquire_mutex(ACPI_MTX_EVENTS); 673 if (ACPI_FAILURE(status)) { 674 return_ACPI_STATUS(status); 675 } 676 677 /* Don't allow more than one handler */ 678 679 if (acpi_gbl_table_handler) { 680 status = AE_ALREADY_EXISTS; 681 goto cleanup; 682 } 683 684 /* Install the handler */ 685 686 acpi_gbl_table_handler = handler; 687 acpi_gbl_table_handler_context = context; 688 689 cleanup: 690 (void)acpi_ut_release_mutex(ACPI_MTX_EVENTS); 691 return_ACPI_STATUS(status); 692 } 693 694 ACPI_EXPORT_SYMBOL(acpi_install_table_handler) 695 696 /******************************************************************************* 697 * 698 * FUNCTION: acpi_remove_table_handler 699 * 700 * PARAMETERS: Handler - Table event handler that was installed 701 * previously. 702 * 703 * RETURN: Status 704 * 705 * DESCRIPTION: Remove table event handler 706 * 707 ******************************************************************************/ 708 acpi_status acpi_remove_table_handler(acpi_tbl_handler handler) 709 { 710 acpi_status status; 711 712 ACPI_FUNCTION_TRACE(acpi_remove_table_handler); 713 714 status = acpi_ut_acquire_mutex(ACPI_MTX_EVENTS); 715 if (ACPI_FAILURE(status)) { 716 return_ACPI_STATUS(status); 717 } 718 719 /* Make sure that the installed handler is the same */ 720 721 if (!handler || handler != acpi_gbl_table_handler) { 722 status = AE_BAD_PARAMETER; 723 goto cleanup; 724 } 725 726 /* Remove the handler */ 727 728 acpi_gbl_table_handler = NULL; 729 730 cleanup: 731 (void)acpi_ut_release_mutex(ACPI_MTX_EVENTS); 732 return_ACPI_STATUS(status); 733 } 734 735 ACPI_EXPORT_SYMBOL(acpi_remove_table_handler) 736 737 738 static int __init acpi_no_auto_ssdt_setup(char *s) { 739 740 printk(KERN_NOTICE "ACPI: SSDT auto-load disabled\n"); 741 742 no_auto_ssdt = 1; 743 744 return 1; 745 } 746 747 __setup("acpi_no_auto_ssdt", acpi_no_auto_ssdt_setup); 748