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 - 2008, 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.size = 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.size = 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 176 ACPI_FUNCTION_TRACE(acpi_reallocate_root_table); 177 178 /* 179 * Only reallocate the root table if the host provided a static buffer 180 * for the table array in the call to acpi_initialize_tables. 181 */ 182 if (acpi_gbl_root_table_list.flags & ACPI_ROOT_ORIGIN_ALLOCATED) { 183 return_ACPI_STATUS(AE_SUPPORT); 184 } 185 186 new_size = ((acpi_size) acpi_gbl_root_table_list.count + 187 ACPI_ROOT_TABLE_SIZE_INCREMENT) * 188 sizeof(struct acpi_table_desc); 189 190 /* Create new array and copy the old array */ 191 192 tables = ACPI_ALLOCATE_ZEROED(new_size); 193 if (!tables) { 194 return_ACPI_STATUS(AE_NO_MEMORY); 195 } 196 197 ACPI_MEMCPY(tables, acpi_gbl_root_table_list.tables, new_size); 198 199 acpi_gbl_root_table_list.size = acpi_gbl_root_table_list.count; 200 acpi_gbl_root_table_list.tables = tables; 201 acpi_gbl_root_table_list.flags = 202 ACPI_ROOT_ORIGIN_ALLOCATED | ACPI_ROOT_ALLOW_RESIZE; 203 204 return_ACPI_STATUS(AE_OK); 205 } 206 207 /******************************************************************************* 208 * 209 * FUNCTION: acpi_load_table 210 * 211 * PARAMETERS: table_ptr - pointer to a buffer containing the entire 212 * table to be loaded 213 * 214 * RETURN: Status 215 * 216 * DESCRIPTION: This function is called to load a table from the caller's 217 * buffer. The buffer must contain an entire ACPI Table including 218 * a valid header. The header fields will be verified, and if it 219 * is determined that the table is invalid, the call will fail. 220 * 221 ******************************************************************************/ 222 acpi_status acpi_load_table(struct acpi_table_header *table_ptr) 223 { 224 acpi_status status; 225 u32 table_index; 226 struct acpi_table_desc table_desc; 227 228 if (!table_ptr) 229 return AE_BAD_PARAMETER; 230 231 ACPI_MEMSET(&table_desc, 0, sizeof(struct acpi_table_desc)); 232 table_desc.pointer = table_ptr; 233 table_desc.length = table_ptr->length; 234 table_desc.flags = ACPI_TABLE_ORIGIN_UNKNOWN; 235 236 /* 237 * Install the new table into the local data structures 238 */ 239 status = acpi_tb_add_table(&table_desc, &table_index); 240 if (ACPI_FAILURE(status)) { 241 return status; 242 } 243 status = acpi_ns_load_table(table_index, acpi_gbl_root_node); 244 return status; 245 } 246 247 ACPI_EXPORT_SYMBOL(acpi_load_table) 248 249 /******************************************************************************* 250 * 251 * FUNCTION: acpi_get_table_header 252 * 253 * PARAMETERS: Signature - ACPI signature of needed table 254 * Instance - Which instance (for SSDTs) 255 * out_table_header - The pointer to the table header to fill 256 * 257 * RETURN: Status and pointer to mapped table header 258 * 259 * DESCRIPTION: Finds an ACPI table header. 260 * 261 * NOTE: Caller is responsible in unmapping the header with 262 * acpi_os_unmap_memory 263 * 264 ******************************************************************************/ 265 acpi_status 266 acpi_get_table_header(char *signature, 267 u32 instance, struct acpi_table_header *out_table_header) 268 { 269 u32 i; 270 u32 j; 271 struct acpi_table_header *header; 272 273 /* Parameter validation */ 274 275 if (!signature || !out_table_header) { 276 return (AE_BAD_PARAMETER); 277 } 278 279 /* Walk the root table list */ 280 281 for (i = 0, j = 0; i < acpi_gbl_root_table_list.count; i++) { 282 if (!ACPI_COMPARE_NAME 283 (&(acpi_gbl_root_table_list.tables[i].signature), 284 signature)) { 285 continue; 286 } 287 288 if (++j < instance) { 289 continue; 290 } 291 292 if (!acpi_gbl_root_table_list.tables[i].pointer) { 293 if ((acpi_gbl_root_table_list.tables[i].flags & 294 ACPI_TABLE_ORIGIN_MASK) == 295 ACPI_TABLE_ORIGIN_MAPPED) { 296 header = 297 acpi_os_map_memory(acpi_gbl_root_table_list. 298 tables[i].address, 299 sizeof(struct 300 acpi_table_header)); 301 if (!header) { 302 return AE_NO_MEMORY; 303 } 304 ACPI_MEMCPY(out_table_header, header, 305 sizeof(struct acpi_table_header)); 306 acpi_os_unmap_memory(header, 307 sizeof(struct 308 acpi_table_header)); 309 } else { 310 return AE_NOT_FOUND; 311 } 312 } else { 313 ACPI_MEMCPY(out_table_header, 314 acpi_gbl_root_table_list.tables[i].pointer, 315 sizeof(struct acpi_table_header)); 316 } 317 return (AE_OK); 318 } 319 320 return (AE_NOT_FOUND); 321 } 322 323 ACPI_EXPORT_SYMBOL(acpi_get_table_header) 324 325 /******************************************************************************* 326 * 327 * FUNCTION: acpi_unload_table_id 328 * 329 * PARAMETERS: id - Owner ID of the table to be removed. 330 * 331 * RETURN: Status 332 * 333 * DESCRIPTION: This routine is used to force the unload of a table (by id) 334 * 335 ******************************************************************************/ 336 acpi_status acpi_unload_table_id(acpi_owner_id id) 337 { 338 int i; 339 acpi_status status = AE_NOT_EXIST; 340 341 ACPI_FUNCTION_TRACE(acpi_unload_table_id); 342 343 /* Find table in the global table list */ 344 for (i = 0; i < acpi_gbl_root_table_list.count; ++i) { 345 if (id != acpi_gbl_root_table_list.tables[i].owner_id) { 346 continue; 347 } 348 /* 349 * Delete all namespace objects owned by this table. Note that these 350 * objects can appear anywhere in the namespace by virtue of the AML 351 * "Scope" operator. Thus, we need to track ownership by an ID, not 352 * simply a position within the hierarchy 353 */ 354 acpi_tb_delete_namespace_by_owner(i); 355 status = acpi_tb_release_owner_id(i); 356 acpi_tb_set_table_loaded_flag(i, FALSE); 357 break; 358 } 359 return_ACPI_STATUS(status); 360 } 361 362 ACPI_EXPORT_SYMBOL(acpi_unload_table_id) 363 364 /******************************************************************************* 365 * 366 * FUNCTION: acpi_get_table_with_size 367 * 368 * PARAMETERS: Signature - ACPI signature of needed table 369 * Instance - Which instance (for SSDTs) 370 * out_table - Where the pointer to the table is returned 371 * 372 * RETURN: Status and pointer to table 373 * 374 * DESCRIPTION: Finds and verifies an ACPI table. 375 * 376 ******************************************************************************/ 377 acpi_status 378 acpi_get_table_with_size(char *signature, 379 u32 instance, struct acpi_table_header **out_table, 380 acpi_size *tbl_size) 381 { 382 u32 i; 383 u32 j; 384 acpi_status status; 385 386 /* Parameter validation */ 387 388 if (!signature || !out_table) { 389 return (AE_BAD_PARAMETER); 390 } 391 392 /* Walk the root table list */ 393 394 for (i = 0, j = 0; i < acpi_gbl_root_table_list.count; i++) { 395 if (!ACPI_COMPARE_NAME 396 (&(acpi_gbl_root_table_list.tables[i].signature), 397 signature)) { 398 continue; 399 } 400 401 if (++j < instance) { 402 continue; 403 } 404 405 status = 406 acpi_tb_verify_table(&acpi_gbl_root_table_list.tables[i]); 407 if (ACPI_SUCCESS(status)) { 408 *out_table = acpi_gbl_root_table_list.tables[i].pointer; 409 *tbl_size = acpi_gbl_root_table_list.tables[i].length; 410 } 411 412 if (!acpi_gbl_permanent_mmap) { 413 acpi_gbl_root_table_list.tables[i].pointer = NULL; 414 } 415 416 return (status); 417 } 418 419 return (AE_NOT_FOUND); 420 } 421 422 acpi_status 423 acpi_get_table(char *signature, 424 u32 instance, struct acpi_table_header **out_table) 425 { 426 acpi_size tbl_size; 427 428 return acpi_get_table_with_size(signature, 429 instance, out_table, &tbl_size); 430 } 431 ACPI_EXPORT_SYMBOL(acpi_get_table) 432 433 /******************************************************************************* 434 * 435 * FUNCTION: acpi_get_table_by_index 436 * 437 * PARAMETERS: table_index - Table index 438 * Table - Where the pointer to the table is returned 439 * 440 * RETURN: Status and pointer to the table 441 * 442 * DESCRIPTION: Obtain a table by an index into the global table list. 443 * 444 ******************************************************************************/ 445 acpi_status 446 acpi_get_table_by_index(u32 table_index, struct acpi_table_header **table) 447 { 448 acpi_status status; 449 450 ACPI_FUNCTION_TRACE(acpi_get_table_by_index); 451 452 /* Parameter validation */ 453 454 if (!table) { 455 return_ACPI_STATUS(AE_BAD_PARAMETER); 456 } 457 458 (void)acpi_ut_acquire_mutex(ACPI_MTX_TABLES); 459 460 /* Validate index */ 461 462 if (table_index >= acpi_gbl_root_table_list.count) { 463 (void)acpi_ut_release_mutex(ACPI_MTX_TABLES); 464 return_ACPI_STATUS(AE_BAD_PARAMETER); 465 } 466 467 if (!acpi_gbl_root_table_list.tables[table_index].pointer) { 468 469 /* Table is not mapped, map it */ 470 471 status = 472 acpi_tb_verify_table(&acpi_gbl_root_table_list. 473 tables[table_index]); 474 if (ACPI_FAILURE(status)) { 475 (void)acpi_ut_release_mutex(ACPI_MTX_TABLES); 476 return_ACPI_STATUS(status); 477 } 478 } 479 480 *table = acpi_gbl_root_table_list.tables[table_index].pointer; 481 (void)acpi_ut_release_mutex(ACPI_MTX_TABLES); 482 return_ACPI_STATUS(AE_OK); 483 } 484 485 ACPI_EXPORT_SYMBOL(acpi_get_table_by_index) 486 487 /******************************************************************************* 488 * 489 * FUNCTION: acpi_tb_load_namespace 490 * 491 * PARAMETERS: None 492 * 493 * RETURN: Status 494 * 495 * DESCRIPTION: Load the namespace from the DSDT and all SSDTs/PSDTs found in 496 * the RSDT/XSDT. 497 * 498 ******************************************************************************/ 499 static acpi_status acpi_tb_load_namespace(void) 500 { 501 acpi_status status; 502 u32 i; 503 504 ACPI_FUNCTION_TRACE(tb_load_namespace); 505 506 (void)acpi_ut_acquire_mutex(ACPI_MTX_TABLES); 507 508 /* 509 * Load the namespace. The DSDT is required, but any SSDT and PSDT tables 510 * are optional. 511 */ 512 if (!acpi_gbl_root_table_list.count || 513 !ACPI_COMPARE_NAME(& 514 (acpi_gbl_root_table_list. 515 tables[ACPI_TABLE_INDEX_DSDT].signature), 516 ACPI_SIG_DSDT) 517 || 518 ACPI_FAILURE(acpi_tb_verify_table 519 (&acpi_gbl_root_table_list. 520 tables[ACPI_TABLE_INDEX_DSDT]))) { 521 status = AE_NO_ACPI_TABLES; 522 goto unlock_and_exit; 523 } 524 525 /* A valid DSDT is required */ 526 527 status = 528 acpi_tb_verify_table(&acpi_gbl_root_table_list. 529 tables[ACPI_TABLE_INDEX_DSDT]); 530 if (ACPI_FAILURE(status)) { 531 532 status = AE_NO_ACPI_TABLES; 533 goto unlock_and_exit; 534 } 535 536 (void)acpi_ut_release_mutex(ACPI_MTX_TABLES); 537 538 /* Load and parse tables */ 539 540 status = acpi_ns_load_table(ACPI_TABLE_INDEX_DSDT, acpi_gbl_root_node); 541 if (ACPI_FAILURE(status)) { 542 return_ACPI_STATUS(status); 543 } 544 545 /* Load any SSDT or PSDT tables. Note: Loop leaves tables locked */ 546 547 (void)acpi_ut_acquire_mutex(ACPI_MTX_TABLES); 548 for (i = 0; i < acpi_gbl_root_table_list.count; ++i) { 549 if ((!ACPI_COMPARE_NAME 550 (&(acpi_gbl_root_table_list.tables[i].signature), 551 ACPI_SIG_SSDT) 552 && 553 !ACPI_COMPARE_NAME(& 554 (acpi_gbl_root_table_list.tables[i]. 555 signature), ACPI_SIG_PSDT)) 556 || 557 ACPI_FAILURE(acpi_tb_verify_table 558 (&acpi_gbl_root_table_list.tables[i]))) { 559 continue; 560 } 561 562 if (no_auto_ssdt) { 563 printk(KERN_WARNING "ACPI: SSDT ignored due to \"acpi_no_auto_ssdt\"\n"); 564 continue; 565 } 566 567 /* Ignore errors while loading tables, get as many as possible */ 568 569 (void)acpi_ut_release_mutex(ACPI_MTX_TABLES); 570 (void)acpi_ns_load_table(i, acpi_gbl_root_node); 571 (void)acpi_ut_acquire_mutex(ACPI_MTX_TABLES); 572 } 573 574 ACPI_DEBUG_PRINT((ACPI_DB_INIT, "ACPI Tables successfully acquired\n")); 575 576 unlock_and_exit: 577 (void)acpi_ut_release_mutex(ACPI_MTX_TABLES); 578 return_ACPI_STATUS(status); 579 } 580 581 /******************************************************************************* 582 * 583 * FUNCTION: acpi_load_tables 584 * 585 * PARAMETERS: None 586 * 587 * RETURN: Status 588 * 589 * DESCRIPTION: Load the ACPI tables from the RSDT/XSDT 590 * 591 ******************************************************************************/ 592 593 acpi_status acpi_load_tables(void) 594 { 595 acpi_status status; 596 597 ACPI_FUNCTION_TRACE(acpi_load_tables); 598 599 /* Load the namespace from the tables */ 600 601 status = acpi_tb_load_namespace(); 602 if (ACPI_FAILURE(status)) { 603 ACPI_EXCEPTION((AE_INFO, status, 604 "While loading namespace from ACPI tables")); 605 } 606 607 return_ACPI_STATUS(status); 608 } 609 610 ACPI_EXPORT_SYMBOL(acpi_load_tables) 611 612 613 /******************************************************************************* 614 * 615 * FUNCTION: acpi_install_table_handler 616 * 617 * PARAMETERS: Handler - Table event handler 618 * Context - Value passed to the handler on each event 619 * 620 * RETURN: Status 621 * 622 * DESCRIPTION: Install table event handler 623 * 624 ******************************************************************************/ 625 acpi_status 626 acpi_install_table_handler(acpi_tbl_handler handler, void *context) 627 { 628 acpi_status status; 629 630 ACPI_FUNCTION_TRACE(acpi_install_table_handler); 631 632 if (!handler) { 633 return_ACPI_STATUS(AE_BAD_PARAMETER); 634 } 635 636 status = acpi_ut_acquire_mutex(ACPI_MTX_EVENTS); 637 if (ACPI_FAILURE(status)) { 638 return_ACPI_STATUS(status); 639 } 640 641 /* Don't allow more than one handler */ 642 643 if (acpi_gbl_table_handler) { 644 status = AE_ALREADY_EXISTS; 645 goto cleanup; 646 } 647 648 /* Install the handler */ 649 650 acpi_gbl_table_handler = handler; 651 acpi_gbl_table_handler_context = context; 652 653 cleanup: 654 (void)acpi_ut_release_mutex(ACPI_MTX_EVENTS); 655 return_ACPI_STATUS(status); 656 } 657 658 ACPI_EXPORT_SYMBOL(acpi_install_table_handler) 659 660 /******************************************************************************* 661 * 662 * FUNCTION: acpi_remove_table_handler 663 * 664 * PARAMETERS: Handler - Table event handler that was installed 665 * previously. 666 * 667 * RETURN: Status 668 * 669 * DESCRIPTION: Remove table event handler 670 * 671 ******************************************************************************/ 672 acpi_status acpi_remove_table_handler(acpi_tbl_handler handler) 673 { 674 acpi_status status; 675 676 ACPI_FUNCTION_TRACE(acpi_remove_table_handler); 677 678 status = acpi_ut_acquire_mutex(ACPI_MTX_EVENTS); 679 if (ACPI_FAILURE(status)) { 680 return_ACPI_STATUS(status); 681 } 682 683 /* Make sure that the installed handler is the same */ 684 685 if (!handler || handler != acpi_gbl_table_handler) { 686 status = AE_BAD_PARAMETER; 687 goto cleanup; 688 } 689 690 /* Remove the handler */ 691 692 acpi_gbl_table_handler = NULL; 693 694 cleanup: 695 (void)acpi_ut_release_mutex(ACPI_MTX_EVENTS); 696 return_ACPI_STATUS(status); 697 } 698 699 ACPI_EXPORT_SYMBOL(acpi_remove_table_handler) 700 701 702 static int __init acpi_no_auto_ssdt_setup(char *s) { 703 704 printk(KERN_NOTICE "ACPI: SSDT auto-load disabled\n"); 705 706 no_auto_ssdt = 1; 707 708 return 1; 709 } 710 711 __setup("acpi_no_auto_ssdt", acpi_no_auto_ssdt_setup); 712