1 /****************************************************************************** 2 * 3 * Module Name: oslinuxtbl - Linux OSL for obtaining ACPI tables 4 * 5 *****************************************************************************/ 6 7 /* 8 * Copyright (C) 2000 - 2017, 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 "acpidump.h" 45 46 #define _COMPONENT ACPI_OS_SERVICES 47 ACPI_MODULE_NAME("oslinuxtbl") 48 49 #ifndef PATH_MAX 50 #define PATH_MAX 256 51 #endif 52 /* List of information about obtained ACPI tables */ 53 typedef struct osl_table_info { 54 struct osl_table_info *next; 55 u32 instance; 56 char signature[ACPI_NAME_SIZE]; 57 58 } osl_table_info; 59 60 /* Local prototypes */ 61 62 static acpi_status osl_table_initialize(void); 63 64 static acpi_status 65 osl_table_name_from_file(char *filename, char *signature, u32 *instance); 66 67 static acpi_status osl_add_table_to_list(char *signature, u32 instance); 68 69 static acpi_status 70 osl_read_table_from_file(char *filename, 71 acpi_size file_offset, 72 char *signature, struct acpi_table_header **table); 73 74 static acpi_status 75 osl_map_table(acpi_size address, 76 char *signature, struct acpi_table_header **table); 77 78 static void osl_unmap_table(struct acpi_table_header *table); 79 80 static acpi_physical_address 81 osl_find_rsdp_via_efi_by_keyword(FILE * file, const char *keyword); 82 83 static acpi_physical_address osl_find_rsdp_via_efi(void); 84 85 static acpi_status osl_load_rsdp(void); 86 87 static acpi_status osl_list_customized_tables(char *directory); 88 89 static acpi_status 90 osl_get_customized_table(char *pathname, 91 char *signature, 92 u32 instance, 93 struct acpi_table_header **table, 94 acpi_physical_address *address); 95 96 static acpi_status osl_list_bios_tables(void); 97 98 static acpi_status 99 osl_get_bios_table(char *signature, 100 u32 instance, 101 struct acpi_table_header **table, 102 acpi_physical_address *address); 103 104 static acpi_status osl_get_last_status(acpi_status default_status); 105 106 /* File locations */ 107 108 #define DYNAMIC_TABLE_DIR "/sys/firmware/acpi/tables/dynamic" 109 #define STATIC_TABLE_DIR "/sys/firmware/acpi/tables" 110 #define EFI_SYSTAB "/sys/firmware/efi/systab" 111 112 /* Should we get dynamically loaded SSDTs from DYNAMIC_TABLE_DIR? */ 113 114 u8 gbl_dump_dynamic_tables = TRUE; 115 116 /* Initialization flags */ 117 118 u8 gbl_table_list_initialized = FALSE; 119 120 /* Local copies of main ACPI tables */ 121 122 struct acpi_table_rsdp gbl_rsdp; 123 struct acpi_table_fadt *gbl_fadt = NULL; 124 struct acpi_table_rsdt *gbl_rsdt = NULL; 125 struct acpi_table_xsdt *gbl_xsdt = NULL; 126 127 /* Table addresses */ 128 129 acpi_physical_address gbl_fadt_address = 0; 130 acpi_physical_address gbl_rsdp_address = 0; 131 132 /* Revision of RSD PTR */ 133 134 u8 gbl_revision = 0; 135 136 struct osl_table_info *gbl_table_list_head = NULL; 137 u32 gbl_table_count = 0; 138 139 /****************************************************************************** 140 * 141 * FUNCTION: osl_get_last_status 142 * 143 * PARAMETERS: default_status - Default error status to return 144 * 145 * RETURN: Status; Converted from errno. 146 * 147 * DESCRIPTION: Get last errno and conver it to acpi_status. 148 * 149 *****************************************************************************/ 150 151 static acpi_status osl_get_last_status(acpi_status default_status) 152 { 153 154 switch (errno) { 155 case EACCES: 156 case EPERM: 157 158 return (AE_ACCESS); 159 160 case ENOENT: 161 162 return (AE_NOT_FOUND); 163 164 case ENOMEM: 165 166 return (AE_NO_MEMORY); 167 168 default: 169 170 return (default_status); 171 } 172 } 173 174 /****************************************************************************** 175 * 176 * FUNCTION: acpi_os_get_table_by_address 177 * 178 * PARAMETERS: address - Physical address of the ACPI table 179 * table - Where a pointer to the table is returned 180 * 181 * RETURN: Status; Table buffer is returned if AE_OK. 182 * AE_NOT_FOUND: A valid table was not found at the address 183 * 184 * DESCRIPTION: Get an ACPI table via a physical memory address. 185 * 186 *****************************************************************************/ 187 188 acpi_status 189 acpi_os_get_table_by_address(acpi_physical_address address, 190 struct acpi_table_header **table) 191 { 192 u32 table_length; 193 struct acpi_table_header *mapped_table; 194 struct acpi_table_header *local_table = NULL; 195 acpi_status status = AE_OK; 196 197 /* Get main ACPI tables from memory on first invocation of this function */ 198 199 status = osl_table_initialize(); 200 if (ACPI_FAILURE(status)) { 201 return (status); 202 } 203 204 /* Map the table and validate it */ 205 206 status = osl_map_table(address, NULL, &mapped_table); 207 if (ACPI_FAILURE(status)) { 208 return (status); 209 } 210 211 /* Copy table to local buffer and return it */ 212 213 table_length = ap_get_table_length(mapped_table); 214 if (table_length == 0) { 215 status = AE_BAD_HEADER; 216 goto exit; 217 } 218 219 local_table = calloc(1, table_length); 220 if (!local_table) { 221 status = AE_NO_MEMORY; 222 goto exit; 223 } 224 225 memcpy(local_table, mapped_table, table_length); 226 227 exit: 228 osl_unmap_table(mapped_table); 229 *table = local_table; 230 return (status); 231 } 232 233 /****************************************************************************** 234 * 235 * FUNCTION: acpi_os_get_table_by_name 236 * 237 * PARAMETERS: signature - ACPI Signature for desired table. Must be 238 * a null terminated 4-character string. 239 * instance - Multiple table support for SSDT/UEFI (0...n) 240 * Must be 0 for other tables. 241 * table - Where a pointer to the table is returned 242 * address - Where the table physical address is returned 243 * 244 * RETURN: Status; Table buffer and physical address returned if AE_OK. 245 * AE_LIMIT: Instance is beyond valid limit 246 * AE_NOT_FOUND: A table with the signature was not found 247 * 248 * NOTE: Assumes the input signature is uppercase. 249 * 250 *****************************************************************************/ 251 252 acpi_status 253 acpi_os_get_table_by_name(char *signature, 254 u32 instance, 255 struct acpi_table_header **table, 256 acpi_physical_address *address) 257 { 258 acpi_status status; 259 260 /* Get main ACPI tables from memory on first invocation of this function */ 261 262 status = osl_table_initialize(); 263 if (ACPI_FAILURE(status)) { 264 return (status); 265 } 266 267 /* Not a main ACPI table, attempt to extract it from the RSDT/XSDT */ 268 269 if (!gbl_dump_customized_tables) { 270 271 /* Attempt to get the table from the memory */ 272 273 status = 274 osl_get_bios_table(signature, instance, table, address); 275 } else { 276 /* Attempt to get the table from the static directory */ 277 278 status = osl_get_customized_table(STATIC_TABLE_DIR, signature, 279 instance, table, address); 280 } 281 282 if (ACPI_FAILURE(status) && status == AE_LIMIT) { 283 if (gbl_dump_dynamic_tables) { 284 285 /* Attempt to get a dynamic table */ 286 287 status = 288 osl_get_customized_table(DYNAMIC_TABLE_DIR, 289 signature, instance, table, 290 address); 291 } 292 } 293 294 return (status); 295 } 296 297 /****************************************************************************** 298 * 299 * FUNCTION: osl_add_table_to_list 300 * 301 * PARAMETERS: signature - Table signature 302 * instance - Table instance 303 * 304 * RETURN: Status; Successfully added if AE_OK. 305 * AE_NO_MEMORY: Memory allocation error 306 * 307 * DESCRIPTION: Insert a table structure into OSL table list. 308 * 309 *****************************************************************************/ 310 311 static acpi_status osl_add_table_to_list(char *signature, u32 instance) 312 { 313 struct osl_table_info *new_info; 314 struct osl_table_info *next; 315 u32 next_instance = 0; 316 u8 found = FALSE; 317 318 new_info = calloc(1, sizeof(struct osl_table_info)); 319 if (!new_info) { 320 return (AE_NO_MEMORY); 321 } 322 323 ACPI_MOVE_NAME(new_info->signature, signature); 324 325 if (!gbl_table_list_head) { 326 gbl_table_list_head = new_info; 327 } else { 328 next = gbl_table_list_head; 329 while (1) { 330 if (ACPI_COMPARE_NAME(next->signature, signature)) { 331 if (next->instance == instance) { 332 found = TRUE; 333 } 334 if (next->instance >= next_instance) { 335 next_instance = next->instance + 1; 336 } 337 } 338 339 if (!next->next) { 340 break; 341 } 342 next = next->next; 343 } 344 next->next = new_info; 345 } 346 347 if (found) { 348 if (instance) { 349 fprintf(stderr, 350 "%4.4s: Warning unmatched table instance %d, expected %d\n", 351 signature, instance, next_instance); 352 } 353 instance = next_instance; 354 } 355 356 new_info->instance = instance; 357 gbl_table_count++; 358 359 return (AE_OK); 360 } 361 362 /****************************************************************************** 363 * 364 * FUNCTION: acpi_os_get_table_by_index 365 * 366 * PARAMETERS: index - Which table to get 367 * table - Where a pointer to the table is returned 368 * instance - Where a pointer to the table instance no. is 369 * returned 370 * address - Where the table physical address is returned 371 * 372 * RETURN: Status; Table buffer and physical address returned if AE_OK. 373 * AE_LIMIT: Index is beyond valid limit 374 * 375 * DESCRIPTION: Get an ACPI table via an index value (0 through n). Returns 376 * AE_LIMIT when an invalid index is reached. Index is not 377 * necessarily an index into the RSDT/XSDT. 378 * 379 *****************************************************************************/ 380 381 acpi_status 382 acpi_os_get_table_by_index(u32 index, 383 struct acpi_table_header **table, 384 u32 *instance, acpi_physical_address *address) 385 { 386 struct osl_table_info *info; 387 acpi_status status; 388 u32 i; 389 390 /* Get main ACPI tables from memory on first invocation of this function */ 391 392 status = osl_table_initialize(); 393 if (ACPI_FAILURE(status)) { 394 return (status); 395 } 396 397 /* Validate Index */ 398 399 if (index >= gbl_table_count) { 400 return (AE_LIMIT); 401 } 402 403 /* Point to the table list entry specified by the Index argument */ 404 405 info = gbl_table_list_head; 406 for (i = 0; i < index; i++) { 407 info = info->next; 408 } 409 410 /* Now we can just get the table via the signature */ 411 412 status = acpi_os_get_table_by_name(info->signature, info->instance, 413 table, address); 414 415 if (ACPI_SUCCESS(status)) { 416 *instance = info->instance; 417 } 418 return (status); 419 } 420 421 /****************************************************************************** 422 * 423 * FUNCTION: osl_find_rsdp_via_efi_by_keyword 424 * 425 * PARAMETERS: keyword - Character string indicating ACPI GUID version 426 * in the EFI table 427 * 428 * RETURN: RSDP address if found 429 * 430 * DESCRIPTION: Find RSDP address via EFI using keyword indicating the ACPI 431 * GUID version. 432 * 433 *****************************************************************************/ 434 435 static acpi_physical_address 436 osl_find_rsdp_via_efi_by_keyword(FILE * file, const char *keyword) 437 { 438 char buffer[80]; 439 unsigned long long address = 0; 440 char format[32]; 441 442 snprintf(format, 32, "%s=%s", keyword, "%llx"); 443 fseek(file, 0, SEEK_SET); 444 while (fgets(buffer, 80, file)) { 445 if (sscanf(buffer, format, &address) == 1) { 446 break; 447 } 448 } 449 450 return ((acpi_physical_address)(address)); 451 } 452 453 /****************************************************************************** 454 * 455 * FUNCTION: osl_find_rsdp_via_efi 456 * 457 * PARAMETERS: None 458 * 459 * RETURN: RSDP address if found 460 * 461 * DESCRIPTION: Find RSDP address via EFI. 462 * 463 *****************************************************************************/ 464 465 static acpi_physical_address osl_find_rsdp_via_efi(void) 466 { 467 FILE *file; 468 acpi_physical_address address = 0; 469 470 file = fopen(EFI_SYSTAB, "r"); 471 if (file) { 472 address = osl_find_rsdp_via_efi_by_keyword(file, "ACPI20"); 473 if (!address) { 474 address = 475 osl_find_rsdp_via_efi_by_keyword(file, "ACPI"); 476 } 477 fclose(file); 478 } 479 480 return (address); 481 } 482 483 /****************************************************************************** 484 * 485 * FUNCTION: osl_load_rsdp 486 * 487 * PARAMETERS: None 488 * 489 * RETURN: Status 490 * 491 * DESCRIPTION: Scan and load RSDP. 492 * 493 *****************************************************************************/ 494 495 static acpi_status osl_load_rsdp(void) 496 { 497 struct acpi_table_header *mapped_table; 498 u8 *rsdp_address; 499 acpi_physical_address rsdp_base; 500 acpi_size rsdp_size; 501 502 /* Get RSDP from memory */ 503 504 rsdp_size = sizeof(struct acpi_table_rsdp); 505 if (gbl_rsdp_base) { 506 rsdp_base = gbl_rsdp_base; 507 } else { 508 rsdp_base = osl_find_rsdp_via_efi(); 509 } 510 511 if (!rsdp_base) { 512 rsdp_base = ACPI_HI_RSDP_WINDOW_BASE; 513 rsdp_size = ACPI_HI_RSDP_WINDOW_SIZE; 514 } 515 516 rsdp_address = acpi_os_map_memory(rsdp_base, rsdp_size); 517 if (!rsdp_address) { 518 return (osl_get_last_status(AE_BAD_ADDRESS)); 519 } 520 521 /* Search low memory for the RSDP */ 522 523 mapped_table = ACPI_CAST_PTR(struct acpi_table_header, 524 acpi_tb_scan_memory_for_rsdp(rsdp_address, 525 rsdp_size)); 526 if (!mapped_table) { 527 acpi_os_unmap_memory(rsdp_address, rsdp_size); 528 return (AE_NOT_FOUND); 529 } 530 531 gbl_rsdp_address = 532 rsdp_base + (ACPI_CAST8(mapped_table) - rsdp_address); 533 534 memcpy(&gbl_rsdp, mapped_table, sizeof(struct acpi_table_rsdp)); 535 acpi_os_unmap_memory(rsdp_address, rsdp_size); 536 537 return (AE_OK); 538 } 539 540 /****************************************************************************** 541 * 542 * FUNCTION: osl_can_use_xsdt 543 * 544 * PARAMETERS: None 545 * 546 * RETURN: TRUE if XSDT is allowed to be used. 547 * 548 * DESCRIPTION: This function collects logic that can be used to determine if 549 * XSDT should be used instead of RSDT. 550 * 551 *****************************************************************************/ 552 553 static u8 osl_can_use_xsdt(void) 554 { 555 if (gbl_revision && !acpi_gbl_do_not_use_xsdt) { 556 return (TRUE); 557 } else { 558 return (FALSE); 559 } 560 } 561 562 /****************************************************************************** 563 * 564 * FUNCTION: osl_table_initialize 565 * 566 * PARAMETERS: None 567 * 568 * RETURN: Status 569 * 570 * DESCRIPTION: Initialize ACPI table data. Get and store main ACPI tables to 571 * local variables. Main ACPI tables include RSDT, FADT, RSDT, 572 * and/or XSDT. 573 * 574 *****************************************************************************/ 575 576 static acpi_status osl_table_initialize(void) 577 { 578 acpi_status status; 579 acpi_physical_address address; 580 581 if (gbl_table_list_initialized) { 582 return (AE_OK); 583 } 584 585 if (!gbl_dump_customized_tables) { 586 587 /* Get RSDP from memory */ 588 589 status = osl_load_rsdp(); 590 if (ACPI_FAILURE(status)) { 591 return (status); 592 } 593 594 /* Get XSDT from memory */ 595 596 if (gbl_rsdp.revision && !gbl_do_not_dump_xsdt) { 597 if (gbl_xsdt) { 598 free(gbl_xsdt); 599 gbl_xsdt = NULL; 600 } 601 602 gbl_revision = 2; 603 status = osl_get_bios_table(ACPI_SIG_XSDT, 0, 604 ACPI_CAST_PTR(struct 605 acpi_table_header 606 *, &gbl_xsdt), 607 &address); 608 if (ACPI_FAILURE(status)) { 609 return (status); 610 } 611 } 612 613 /* Get RSDT from memory */ 614 615 if (gbl_rsdp.rsdt_physical_address) { 616 if (gbl_rsdt) { 617 free(gbl_rsdt); 618 gbl_rsdt = NULL; 619 } 620 621 status = osl_get_bios_table(ACPI_SIG_RSDT, 0, 622 ACPI_CAST_PTR(struct 623 acpi_table_header 624 *, &gbl_rsdt), 625 &address); 626 if (ACPI_FAILURE(status)) { 627 return (status); 628 } 629 } 630 631 /* Get FADT from memory */ 632 633 if (gbl_fadt) { 634 free(gbl_fadt); 635 gbl_fadt = NULL; 636 } 637 638 status = osl_get_bios_table(ACPI_SIG_FADT, 0, 639 ACPI_CAST_PTR(struct 640 acpi_table_header *, 641 &gbl_fadt), 642 &gbl_fadt_address); 643 if (ACPI_FAILURE(status)) { 644 return (status); 645 } 646 647 /* Add mandatory tables to global table list first */ 648 649 status = osl_add_table_to_list(ACPI_RSDP_NAME, 0); 650 if (ACPI_FAILURE(status)) { 651 return (status); 652 } 653 654 status = osl_add_table_to_list(ACPI_SIG_RSDT, 0); 655 if (ACPI_FAILURE(status)) { 656 return (status); 657 } 658 659 if (gbl_revision == 2) { 660 status = osl_add_table_to_list(ACPI_SIG_XSDT, 0); 661 if (ACPI_FAILURE(status)) { 662 return (status); 663 } 664 } 665 666 status = osl_add_table_to_list(ACPI_SIG_DSDT, 0); 667 if (ACPI_FAILURE(status)) { 668 return (status); 669 } 670 671 status = osl_add_table_to_list(ACPI_SIG_FACS, 0); 672 if (ACPI_FAILURE(status)) { 673 return (status); 674 } 675 676 /* Add all tables found in the memory */ 677 678 status = osl_list_bios_tables(); 679 if (ACPI_FAILURE(status)) { 680 return (status); 681 } 682 } else { 683 /* Add all tables found in the static directory */ 684 685 status = osl_list_customized_tables(STATIC_TABLE_DIR); 686 if (ACPI_FAILURE(status)) { 687 return (status); 688 } 689 } 690 691 if (gbl_dump_dynamic_tables) { 692 693 /* Add all dynamically loaded tables in the dynamic directory */ 694 695 status = osl_list_customized_tables(DYNAMIC_TABLE_DIR); 696 if (ACPI_FAILURE(status)) { 697 return (status); 698 } 699 } 700 701 gbl_table_list_initialized = TRUE; 702 return (AE_OK); 703 } 704 705 /****************************************************************************** 706 * 707 * FUNCTION: osl_list_bios_tables 708 * 709 * PARAMETERS: None 710 * 711 * RETURN: Status; Table list is initialized if AE_OK. 712 * 713 * DESCRIPTION: Add ACPI tables to the table list from memory. 714 * 715 * NOTE: This works on Linux as table customization does not modify the 716 * addresses stored in RSDP/RSDT/XSDT/FADT. 717 * 718 *****************************************************************************/ 719 720 static acpi_status osl_list_bios_tables(void) 721 { 722 struct acpi_table_header *mapped_table = NULL; 723 u8 *table_data; 724 u8 number_of_tables; 725 u8 item_size; 726 acpi_physical_address table_address = 0; 727 acpi_status status = AE_OK; 728 u32 i; 729 730 if (osl_can_use_xsdt()) { 731 item_size = sizeof(u64); 732 table_data = 733 ACPI_CAST8(gbl_xsdt) + sizeof(struct acpi_table_header); 734 number_of_tables = 735 (u8)((gbl_xsdt->header.length - 736 sizeof(struct acpi_table_header)) 737 / item_size); 738 } else { /* Use RSDT if XSDT is not available */ 739 740 item_size = sizeof(u32); 741 table_data = 742 ACPI_CAST8(gbl_rsdt) + sizeof(struct acpi_table_header); 743 number_of_tables = 744 (u8)((gbl_rsdt->header.length - 745 sizeof(struct acpi_table_header)) 746 / item_size); 747 } 748 749 /* Search RSDT/XSDT for the requested table */ 750 751 for (i = 0; i < number_of_tables; ++i, table_data += item_size) { 752 if (osl_can_use_xsdt()) { 753 table_address = 754 (acpi_physical_address)(*ACPI_CAST64(table_data)); 755 } else { 756 table_address = 757 (acpi_physical_address)(*ACPI_CAST32(table_data)); 758 } 759 760 /* Skip NULL entries in RSDT/XSDT */ 761 762 if (table_address == 0) { 763 continue; 764 } 765 766 status = osl_map_table(table_address, NULL, &mapped_table); 767 if (ACPI_FAILURE(status)) { 768 return (status); 769 } 770 771 osl_add_table_to_list(mapped_table->signature, 0); 772 osl_unmap_table(mapped_table); 773 } 774 775 return (AE_OK); 776 } 777 778 /****************************************************************************** 779 * 780 * FUNCTION: osl_get_bios_table 781 * 782 * PARAMETERS: signature - ACPI Signature for common table. Must be 783 * a null terminated 4-character string. 784 * instance - Multiple table support for SSDT/UEFI (0...n) 785 * Must be 0 for other tables. 786 * table - Where a pointer to the table is returned 787 * address - Where the table physical address is returned 788 * 789 * RETURN: Status; Table buffer and physical address returned if AE_OK. 790 * AE_LIMIT: Instance is beyond valid limit 791 * AE_NOT_FOUND: A table with the signature was not found 792 * 793 * DESCRIPTION: Get a BIOS provided ACPI table 794 * 795 * NOTE: Assumes the input signature is uppercase. 796 * 797 *****************************************************************************/ 798 799 static acpi_status 800 osl_get_bios_table(char *signature, 801 u32 instance, 802 struct acpi_table_header **table, 803 acpi_physical_address *address) 804 { 805 struct acpi_table_header *local_table = NULL; 806 struct acpi_table_header *mapped_table = NULL; 807 u8 *table_data; 808 u8 number_of_tables; 809 u8 item_size; 810 u32 current_instance = 0; 811 acpi_physical_address table_address; 812 acpi_physical_address first_table_address = 0; 813 u32 table_length = 0; 814 acpi_status status = AE_OK; 815 u32 i; 816 817 /* Handle special tables whose addresses are not in RSDT/XSDT */ 818 819 if (ACPI_COMPARE_NAME(signature, ACPI_RSDP_NAME) || 820 ACPI_COMPARE_NAME(signature, ACPI_SIG_RSDT) || 821 ACPI_COMPARE_NAME(signature, ACPI_SIG_XSDT) || 822 ACPI_COMPARE_NAME(signature, ACPI_SIG_DSDT) || 823 ACPI_COMPARE_NAME(signature, ACPI_SIG_FACS)) { 824 825 find_next_instance: 826 827 table_address = 0; 828 829 /* 830 * Get the appropriate address, either 32-bit or 64-bit. Be very 831 * careful about the FADT length and validate table addresses. 832 * Note: The 64-bit addresses have priority. 833 */ 834 if (ACPI_COMPARE_NAME(signature, ACPI_SIG_DSDT)) { 835 if (current_instance < 2) { 836 if ((gbl_fadt->header.length >= 837 MIN_FADT_FOR_XDSDT) && gbl_fadt->Xdsdt 838 && current_instance == 0) { 839 table_address = 840 (acpi_physical_address)gbl_fadt-> 841 Xdsdt; 842 } else 843 if ((gbl_fadt->header.length >= 844 MIN_FADT_FOR_DSDT) 845 && gbl_fadt->dsdt != 846 first_table_address) { 847 table_address = 848 (acpi_physical_address)gbl_fadt-> 849 dsdt; 850 } 851 } 852 } else if (ACPI_COMPARE_NAME(signature, ACPI_SIG_FACS)) { 853 if (current_instance < 2) { 854 if ((gbl_fadt->header.length >= 855 MIN_FADT_FOR_XFACS) && gbl_fadt->Xfacs 856 && current_instance == 0) { 857 table_address = 858 (acpi_physical_address)gbl_fadt-> 859 Xfacs; 860 } else 861 if ((gbl_fadt->header.length >= 862 MIN_FADT_FOR_FACS) 863 && gbl_fadt->facs != 864 first_table_address) { 865 table_address = 866 (acpi_physical_address)gbl_fadt-> 867 facs; 868 } 869 } 870 } else if (ACPI_COMPARE_NAME(signature, ACPI_SIG_XSDT)) { 871 if (!gbl_revision) { 872 return (AE_BAD_SIGNATURE); 873 } 874 if (current_instance == 0) { 875 table_address = 876 (acpi_physical_address)gbl_rsdp. 877 xsdt_physical_address; 878 } 879 } else if (ACPI_COMPARE_NAME(signature, ACPI_SIG_RSDT)) { 880 if (current_instance == 0) { 881 table_address = 882 (acpi_physical_address)gbl_rsdp. 883 rsdt_physical_address; 884 } 885 } else { 886 if (current_instance == 0) { 887 table_address = 888 (acpi_physical_address)gbl_rsdp_address; 889 signature = ACPI_SIG_RSDP; 890 } 891 } 892 893 if (table_address == 0) { 894 goto exit_find_table; 895 } 896 897 /* Now we can get the requested special table */ 898 899 status = osl_map_table(table_address, signature, &mapped_table); 900 if (ACPI_FAILURE(status)) { 901 return (status); 902 } 903 904 table_length = ap_get_table_length(mapped_table); 905 if (first_table_address == 0) { 906 first_table_address = table_address; 907 } 908 909 /* Match table instance */ 910 911 if (current_instance != instance) { 912 osl_unmap_table(mapped_table); 913 mapped_table = NULL; 914 current_instance++; 915 goto find_next_instance; 916 } 917 } else { /* Case for a normal ACPI table */ 918 919 if (osl_can_use_xsdt()) { 920 item_size = sizeof(u64); 921 table_data = 922 ACPI_CAST8(gbl_xsdt) + 923 sizeof(struct acpi_table_header); 924 number_of_tables = 925 (u8)((gbl_xsdt->header.length - 926 sizeof(struct acpi_table_header)) 927 / item_size); 928 } else { /* Use RSDT if XSDT is not available */ 929 930 item_size = sizeof(u32); 931 table_data = 932 ACPI_CAST8(gbl_rsdt) + 933 sizeof(struct acpi_table_header); 934 number_of_tables = 935 (u8)((gbl_rsdt->header.length - 936 sizeof(struct acpi_table_header)) 937 / item_size); 938 } 939 940 /* Search RSDT/XSDT for the requested table */ 941 942 for (i = 0; i < number_of_tables; ++i, table_data += item_size) { 943 if (osl_can_use_xsdt()) { 944 table_address = 945 (acpi_physical_address)(*ACPI_CAST64 946 (table_data)); 947 } else { 948 table_address = 949 (acpi_physical_address)(*ACPI_CAST32 950 (table_data)); 951 } 952 953 /* Skip NULL entries in RSDT/XSDT */ 954 955 if (table_address == 0) { 956 continue; 957 } 958 959 status = 960 osl_map_table(table_address, NULL, &mapped_table); 961 if (ACPI_FAILURE(status)) { 962 return (status); 963 } 964 table_length = mapped_table->length; 965 966 /* Does this table match the requested signature? */ 967 968 if (!ACPI_COMPARE_NAME 969 (mapped_table->signature, signature)) { 970 osl_unmap_table(mapped_table); 971 mapped_table = NULL; 972 continue; 973 } 974 975 /* Match table instance (for SSDT/UEFI tables) */ 976 977 if (current_instance != instance) { 978 osl_unmap_table(mapped_table); 979 mapped_table = NULL; 980 current_instance++; 981 continue; 982 } 983 984 break; 985 } 986 } 987 988 exit_find_table: 989 990 if (!mapped_table) { 991 return (AE_LIMIT); 992 } 993 994 if (table_length == 0) { 995 status = AE_BAD_HEADER; 996 goto exit; 997 } 998 999 /* Copy table to local buffer and return it */ 1000 1001 local_table = calloc(1, table_length); 1002 if (!local_table) { 1003 status = AE_NO_MEMORY; 1004 goto exit; 1005 } 1006 1007 memcpy(local_table, mapped_table, table_length); 1008 *address = table_address; 1009 *table = local_table; 1010 1011 exit: 1012 osl_unmap_table(mapped_table); 1013 return (status); 1014 } 1015 1016 /****************************************************************************** 1017 * 1018 * FUNCTION: osl_list_customized_tables 1019 * 1020 * PARAMETERS: directory - Directory that contains the tables 1021 * 1022 * RETURN: Status; Table list is initialized if AE_OK. 1023 * 1024 * DESCRIPTION: Add ACPI tables to the table list from a directory. 1025 * 1026 *****************************************************************************/ 1027 1028 static acpi_status osl_list_customized_tables(char *directory) 1029 { 1030 void *table_dir; 1031 u32 instance; 1032 char temp_name[ACPI_NAME_SIZE]; 1033 char *filename; 1034 acpi_status status = AE_OK; 1035 1036 /* Open the requested directory */ 1037 1038 table_dir = acpi_os_open_directory(directory, "*", REQUEST_FILE_ONLY); 1039 if (!table_dir) { 1040 return (osl_get_last_status(AE_NOT_FOUND)); 1041 } 1042 1043 /* Examine all entries in this directory */ 1044 1045 while ((filename = acpi_os_get_next_filename(table_dir))) { 1046 1047 /* Extract table name and instance number */ 1048 1049 status = 1050 osl_table_name_from_file(filename, temp_name, &instance); 1051 1052 /* Ignore meaningless files */ 1053 1054 if (ACPI_FAILURE(status)) { 1055 continue; 1056 } 1057 1058 /* Add new info node to global table list */ 1059 1060 status = osl_add_table_to_list(temp_name, instance); 1061 if (ACPI_FAILURE(status)) { 1062 break; 1063 } 1064 } 1065 1066 acpi_os_close_directory(table_dir); 1067 return (status); 1068 } 1069 1070 /****************************************************************************** 1071 * 1072 * FUNCTION: osl_map_table 1073 * 1074 * PARAMETERS: address - Address of the table in memory 1075 * signature - Optional ACPI Signature for desired table. 1076 * Null terminated 4-character string. 1077 * table - Where a pointer to the mapped table is 1078 * returned 1079 * 1080 * RETURN: Status; Mapped table is returned if AE_OK. 1081 * AE_NOT_FOUND: A valid table was not found at the address 1082 * 1083 * DESCRIPTION: Map entire ACPI table into caller's address space. 1084 * 1085 *****************************************************************************/ 1086 1087 static acpi_status 1088 osl_map_table(acpi_size address, 1089 char *signature, struct acpi_table_header **table) 1090 { 1091 struct acpi_table_header *mapped_table; 1092 u32 length; 1093 1094 if (!address) { 1095 return (AE_BAD_ADDRESS); 1096 } 1097 1098 /* 1099 * Map the header so we can get the table length. 1100 * Use sizeof (struct acpi_table_header) as: 1101 * 1. it is bigger than 24 to include RSDP->Length 1102 * 2. it is smaller than sizeof (struct acpi_table_rsdp) 1103 */ 1104 mapped_table = 1105 acpi_os_map_memory(address, sizeof(struct acpi_table_header)); 1106 if (!mapped_table) { 1107 fprintf(stderr, "Could not map table header at 0x%8.8X%8.8X\n", 1108 ACPI_FORMAT_UINT64(address)); 1109 return (osl_get_last_status(AE_BAD_ADDRESS)); 1110 } 1111 1112 /* If specified, signature must match */ 1113 1114 if (signature) { 1115 if (ACPI_VALIDATE_RSDP_SIG(signature)) { 1116 if (!ACPI_VALIDATE_RSDP_SIG(mapped_table->signature)) { 1117 acpi_os_unmap_memory(mapped_table, 1118 sizeof(struct 1119 acpi_table_header)); 1120 return (AE_BAD_SIGNATURE); 1121 } 1122 } else 1123 if (!ACPI_COMPARE_NAME(signature, mapped_table->signature)) 1124 { 1125 acpi_os_unmap_memory(mapped_table, 1126 sizeof(struct acpi_table_header)); 1127 return (AE_BAD_SIGNATURE); 1128 } 1129 } 1130 1131 /* Map the entire table */ 1132 1133 length = ap_get_table_length(mapped_table); 1134 acpi_os_unmap_memory(mapped_table, sizeof(struct acpi_table_header)); 1135 if (length == 0) { 1136 return (AE_BAD_HEADER); 1137 } 1138 1139 mapped_table = acpi_os_map_memory(address, length); 1140 if (!mapped_table) { 1141 fprintf(stderr, 1142 "Could not map table at 0x%8.8X%8.8X length %8.8X\n", 1143 ACPI_FORMAT_UINT64(address), length); 1144 return (osl_get_last_status(AE_INVALID_TABLE_LENGTH)); 1145 } 1146 1147 (void)ap_is_valid_checksum(mapped_table); 1148 1149 *table = mapped_table; 1150 return (AE_OK); 1151 } 1152 1153 /****************************************************************************** 1154 * 1155 * FUNCTION: osl_unmap_table 1156 * 1157 * PARAMETERS: table - A pointer to the mapped table 1158 * 1159 * RETURN: None 1160 * 1161 * DESCRIPTION: Unmap entire ACPI table. 1162 * 1163 *****************************************************************************/ 1164 1165 static void osl_unmap_table(struct acpi_table_header *table) 1166 { 1167 if (table) { 1168 acpi_os_unmap_memory(table, ap_get_table_length(table)); 1169 } 1170 } 1171 1172 /****************************************************************************** 1173 * 1174 * FUNCTION: osl_table_name_from_file 1175 * 1176 * PARAMETERS: filename - File that contains the desired table 1177 * signature - Pointer to 4-character buffer to store 1178 * extracted table signature. 1179 * instance - Pointer to integer to store extracted 1180 * table instance number. 1181 * 1182 * RETURN: Status; Table name is extracted if AE_OK. 1183 * 1184 * DESCRIPTION: Extract table signature and instance number from a table file 1185 * name. 1186 * 1187 *****************************************************************************/ 1188 1189 static acpi_status 1190 osl_table_name_from_file(char *filename, char *signature, u32 *instance) 1191 { 1192 1193 /* Ignore meaningless files */ 1194 1195 if (strlen(filename) < ACPI_NAME_SIZE) { 1196 return (AE_BAD_SIGNATURE); 1197 } 1198 1199 /* Extract instance number */ 1200 1201 if (isdigit((int)filename[ACPI_NAME_SIZE])) { 1202 sscanf(&filename[ACPI_NAME_SIZE], "%u", instance); 1203 } else if (strlen(filename) != ACPI_NAME_SIZE) { 1204 return (AE_BAD_SIGNATURE); 1205 } else { 1206 *instance = 0; 1207 } 1208 1209 /* Extract signature */ 1210 1211 ACPI_MOVE_NAME(signature, filename); 1212 return (AE_OK); 1213 } 1214 1215 /****************************************************************************** 1216 * 1217 * FUNCTION: osl_read_table_from_file 1218 * 1219 * PARAMETERS: filename - File that contains the desired table 1220 * file_offset - Offset of the table in file 1221 * signature - Optional ACPI Signature for desired table. 1222 * A null terminated 4-character string. 1223 * table - Where a pointer to the table is returned 1224 * 1225 * RETURN: Status; Table buffer is returned if AE_OK. 1226 * 1227 * DESCRIPTION: Read a ACPI table from a file. 1228 * 1229 *****************************************************************************/ 1230 1231 static acpi_status 1232 osl_read_table_from_file(char *filename, 1233 acpi_size file_offset, 1234 char *signature, struct acpi_table_header **table) 1235 { 1236 FILE *table_file; 1237 struct acpi_table_header header; 1238 struct acpi_table_header *local_table = NULL; 1239 u32 table_length; 1240 s32 count; 1241 acpi_status status = AE_OK; 1242 1243 /* Open the file */ 1244 1245 table_file = fopen(filename, "rb"); 1246 if (table_file == NULL) { 1247 fprintf(stderr, "Could not open table file: %s\n", filename); 1248 return (osl_get_last_status(AE_NOT_FOUND)); 1249 } 1250 1251 fseek(table_file, file_offset, SEEK_SET); 1252 1253 /* Read the Table header to get the table length */ 1254 1255 count = fread(&header, 1, sizeof(struct acpi_table_header), table_file); 1256 if (count != sizeof(struct acpi_table_header)) { 1257 fprintf(stderr, "Could not read table header: %s\n", filename); 1258 status = AE_BAD_HEADER; 1259 goto exit; 1260 } 1261 1262 /* If signature is specified, it must match the table */ 1263 1264 if (signature) { 1265 if (ACPI_VALIDATE_RSDP_SIG(signature)) { 1266 if (!ACPI_VALIDATE_RSDP_SIG(header.signature)) { 1267 fprintf(stderr, 1268 "Incorrect RSDP signature: found %8.8s\n", 1269 header.signature); 1270 status = AE_BAD_SIGNATURE; 1271 goto exit; 1272 } 1273 } else if (!ACPI_COMPARE_NAME(signature, header.signature)) { 1274 fprintf(stderr, 1275 "Incorrect signature: Expecting %4.4s, found %4.4s\n", 1276 signature, header.signature); 1277 status = AE_BAD_SIGNATURE; 1278 goto exit; 1279 } 1280 } 1281 1282 table_length = ap_get_table_length(&header); 1283 if (table_length == 0) { 1284 status = AE_BAD_HEADER; 1285 goto exit; 1286 } 1287 1288 /* Read the entire table into a local buffer */ 1289 1290 local_table = calloc(1, table_length); 1291 if (!local_table) { 1292 fprintf(stderr, 1293 "%4.4s: Could not allocate buffer for table of length %X\n", 1294 header.signature, table_length); 1295 status = AE_NO_MEMORY; 1296 goto exit; 1297 } 1298 1299 fseek(table_file, file_offset, SEEK_SET); 1300 1301 count = fread(local_table, 1, table_length, table_file); 1302 if (count != table_length) { 1303 fprintf(stderr, "%4.4s: Could not read table content\n", 1304 header.signature); 1305 status = AE_INVALID_TABLE_LENGTH; 1306 goto exit; 1307 } 1308 1309 /* Validate checksum */ 1310 1311 (void)ap_is_valid_checksum(local_table); 1312 1313 exit: 1314 fclose(table_file); 1315 *table = local_table; 1316 return (status); 1317 } 1318 1319 /****************************************************************************** 1320 * 1321 * FUNCTION: osl_get_customized_table 1322 * 1323 * PARAMETERS: pathname - Directory to find Linux customized table 1324 * signature - ACPI Signature for desired table. Must be 1325 * a null terminated 4-character string. 1326 * instance - Multiple table support for SSDT/UEFI (0...n) 1327 * Must be 0 for other tables. 1328 * table - Where a pointer to the table is returned 1329 * address - Where the table physical address is returned 1330 * 1331 * RETURN: Status; Table buffer is returned if AE_OK. 1332 * AE_LIMIT: Instance is beyond valid limit 1333 * AE_NOT_FOUND: A table with the signature was not found 1334 * 1335 * DESCRIPTION: Get an OS customized table. 1336 * 1337 *****************************************************************************/ 1338 1339 static acpi_status 1340 osl_get_customized_table(char *pathname, 1341 char *signature, 1342 u32 instance, 1343 struct acpi_table_header **table, 1344 acpi_physical_address *address) 1345 { 1346 void *table_dir; 1347 u32 current_instance = 0; 1348 char temp_name[ACPI_NAME_SIZE]; 1349 char table_filename[PATH_MAX]; 1350 char *filename; 1351 acpi_status status; 1352 1353 /* Open the directory for customized tables */ 1354 1355 table_dir = acpi_os_open_directory(pathname, "*", REQUEST_FILE_ONLY); 1356 if (!table_dir) { 1357 return (osl_get_last_status(AE_NOT_FOUND)); 1358 } 1359 1360 /* Attempt to find the table in the directory */ 1361 1362 while ((filename = acpi_os_get_next_filename(table_dir))) { 1363 1364 /* Ignore meaningless files */ 1365 1366 if (!ACPI_COMPARE_NAME(filename, signature)) { 1367 continue; 1368 } 1369 1370 /* Extract table name and instance number */ 1371 1372 status = 1373 osl_table_name_from_file(filename, temp_name, 1374 ¤t_instance); 1375 1376 /* Ignore meaningless files */ 1377 1378 if (ACPI_FAILURE(status) || current_instance != instance) { 1379 continue; 1380 } 1381 1382 /* Create the table pathname */ 1383 1384 if (instance != 0) { 1385 sprintf(table_filename, "%s/%4.4s%d", pathname, 1386 temp_name, instance); 1387 } else { 1388 sprintf(table_filename, "%s/%4.4s", pathname, 1389 temp_name); 1390 } 1391 break; 1392 } 1393 1394 acpi_os_close_directory(table_dir); 1395 1396 if (!filename) { 1397 return (AE_LIMIT); 1398 } 1399 1400 /* There is no physical address saved for customized tables, use zero */ 1401 1402 *address = 0; 1403 status = osl_read_table_from_file(table_filename, 0, NULL, table); 1404 1405 return (status); 1406 } 1407