kernel/tools/power/acpi/os_specific/service_layers/oslinuxtbl.c

   1 /******************************************************************************
   2  *
   3  * Module Name: oslinuxtbl - Linux OSL for obtaining ACPI tables
   4  *
   5  *****************************************************************************/
   6
   7 /*
   8  * Copyright (C) 2000 - 2015, 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         ACPI_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         ACPI_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         /* Get RSDP from memory */
 586
 587         status = osl_load_rsdp();
 588         if (ACPI_FAILURE(status)) {
 589                 return (status);
 590         }
 591
 592         /* Get XSDT from memory */
 593
 594         if (gbl_rsdp.revision && !gbl_do_not_dump_xsdt) {
 595                 if (gbl_xsdt) {
 596                         free(gbl_xsdt);
 597                         gbl_xsdt = NULL;
 598                 }
 599
 600                 gbl_revision = 2;
 601                 status = osl_get_bios_table(ACPI_SIG_XSDT, 0,
 602                                             ACPI_CAST_PTR(struct
 603                                                           acpi_table_header *,
 604                                                           &gbl_xsdt), &address);
 605                 if (ACPI_FAILURE(status)) {
 606                         return (status);
 607                 }
 608         }
 609
 610         /* Get RSDT from memory */
 611
 612         if (gbl_rsdp.rsdt_physical_address) {
 613                 if (gbl_rsdt) {
 614                         free(gbl_rsdt);
 615                         gbl_rsdt = NULL;
 616                 }
 617
 618                 status = osl_get_bios_table(ACPI_SIG_RSDT, 0,
 619                                             ACPI_CAST_PTR(struct
 620                                                           acpi_table_header *,
 621                                                           &gbl_rsdt), &address);
 622                 if (ACPI_FAILURE(status)) {
 623                         return (status);
 624                 }
 625         }
 626
 627         /* Get FADT from memory */
 628
 629         if (gbl_fadt) {
 630                 free(gbl_fadt);
 631                 gbl_fadt = NULL;
 632         }
 633
 634         status = osl_get_bios_table(ACPI_SIG_FADT, 0,
 635                                     ACPI_CAST_PTR(struct acpi_table_header *,
 636                                                   &gbl_fadt),
 637                                     &gbl_fadt_address);
 638         if (ACPI_FAILURE(status)) {
 639                 return (status);
 640         }
 641
 642         if (!gbl_dump_customized_tables) {
 643
 644                 /* Add mandatory tables to global table list first */
 645
 646                 status = osl_add_table_to_list(ACPI_RSDP_NAME, 0);
 647                 if (ACPI_FAILURE(status)) {
 648                         return (status);
 649                 }
 650
 651                 status = osl_add_table_to_list(ACPI_SIG_RSDT, 0);
 652                 if (ACPI_FAILURE(status)) {
 653                         return (status);
 654                 }
 655
 656                 if (gbl_revision == 2) {
 657                         status = osl_add_table_to_list(ACPI_SIG_XSDT, 0);
 658                         if (ACPI_FAILURE(status)) {
 659                                 return (status);
 660                         }
 661                 }
 662
 663                 status = osl_add_table_to_list(ACPI_SIG_DSDT, 0);
 664                 if (ACPI_FAILURE(status)) {
 665                         return (status);
 666                 }
 667
 668                 status = osl_add_table_to_list(ACPI_SIG_FACS, 0);
 669                 if (ACPI_FAILURE(status)) {
 670                         return (status);
 671                 }
 672
 673                 /* Add all tables found in the memory */
 674
 675                 status = osl_list_bios_tables();
 676                 if (ACPI_FAILURE(status)) {
 677                         return (status);
 678                 }
 679         } else {
 680                 /* Add all tables found in the static directory */
 681
 682                 status = osl_list_customized_tables(STATIC_TABLE_DIR);
 683                 if (ACPI_FAILURE(status)) {
 684                         return (status);
 685                 }
 686         }
 687
 688         if (gbl_dump_dynamic_tables) {
 689
 690                 /* Add all dynamically loaded tables in the dynamic directory */
 691
 692                 status = osl_list_customized_tables(DYNAMIC_TABLE_DIR);
 693                 if (ACPI_FAILURE(status)) {
 694                         return (status);
 695                 }
 696         }
 697
 698         gbl_table_list_initialized = TRUE;
 699         return (AE_OK);
 700 }
 701
 702 /******************************************************************************
 703  *
 704  * FUNCTION:    osl_list_bios_tables
 705  *
 706  * PARAMETERS:  None
 707  *
 708  * RETURN:      Status; Table list is initialized if AE_OK.
 709  *
 710  * DESCRIPTION: Add ACPI tables to the table list from memory.
 711  *
 712  * NOTE:        This works on Linux as table customization does not modify the
 713  *              addresses stored in RSDP/RSDT/XSDT/FADT.
 714  *
 715  *****************************************************************************/
 716
 717 static acpi_status osl_list_bios_tables(void)
 718 {
 719         struct acpi_table_header *mapped_table = NULL;
 720         u8 *table_data;
 721         u8 number_of_tables;
 722         u8 item_size;
 723         acpi_physical_address table_address = 0;
 724         acpi_status status = AE_OK;
 725         u32 i;
 726
 727         if (osl_can_use_xsdt()) {
 728                 item_size = sizeof(u64);
 729                 table_data =
 730                     ACPI_CAST8(gbl_xsdt) + sizeof(struct acpi_table_header);
 731                 number_of_tables =
 732                     (u8)((gbl_xsdt->header.length -
 733                           sizeof(struct acpi_table_header))
 734                          / item_size);
 735         } else {                /* Use RSDT if XSDT is not available */
 736
 737                 item_size = sizeof(u32);
 738                 table_data =
 739                     ACPI_CAST8(gbl_rsdt) + sizeof(struct acpi_table_header);
 740                 number_of_tables =
 741                     (u8)((gbl_rsdt->header.length -
 742                           sizeof(struct acpi_table_header))
 743                          / item_size);
 744         }
 745
 746         /* Search RSDT/XSDT for the requested table */
 747
 748         for (i = 0; i < number_of_tables; ++i, table_data += item_size) {
 749                 if (osl_can_use_xsdt()) {
 750                         table_address =
 751                             (acpi_physical_address) (*ACPI_CAST64(table_data));
 752                 } else {
 753                         table_address =
 754                             (acpi_physical_address) (*ACPI_CAST32(table_data));
 755                 }
 756
 757                 /* Skip NULL entries in RSDT/XSDT */
 758
 759                 if (!table_address) {
 760                         continue;
 761                 }
 762
 763                 status = osl_map_table(table_address, NULL, &mapped_table);
 764                 if (ACPI_FAILURE(status)) {
 765                         return (status);
 766                 }
 767
 768                 osl_add_table_to_list(mapped_table->signature, 0);
 769                 osl_unmap_table(mapped_table);
 770         }
 771
 772         return (AE_OK);
 773 }
 774
 775 /******************************************************************************
 776  *
 777  * FUNCTION:    osl_get_bios_table
 778  *
 779  * PARAMETERS:  signature       - ACPI Signature for common table. Must be
 780  *                                a null terminated 4-character string.
 781  *              instance        - Multiple table support for SSDT/UEFI (0...n)
 782  *                                Must be 0 for other tables.
 783  *              table           - Where a pointer to the table is returned
 784  *              address         - Where the table physical address is returned
 785  *
 786  * RETURN:      Status; Table buffer and physical address returned if AE_OK.
 787  *              AE_LIMIT: Instance is beyond valid limit
 788  *              AE_NOT_FOUND: A table with the signature was not found
 789  *
 790  * DESCRIPTION: Get a BIOS provided ACPI table
 791  *
 792  * NOTE:        Assumes the input signature is uppercase.
 793  *
 794  *****************************************************************************/
 795
 796 static acpi_status
 797 osl_get_bios_table(char *signature,
 798                    u32 instance,
 799                    struct acpi_table_header **table,
 800                    acpi_physical_address * address)
 801 {
 802         struct acpi_table_header *local_table = NULL;
 803         struct acpi_table_header *mapped_table = NULL;
 804         u8 *table_data;
 805         u8 number_of_tables;
 806         u8 item_size;
 807         u32 current_instance = 0;
 808         acpi_physical_address table_address = 0;
 809         u32 table_length = 0;
 810         acpi_status status = AE_OK;
 811         u32 i;
 812
 813         /* Handle special tables whose addresses are not in RSDT/XSDT */
 814
 815         if (ACPI_COMPARE_NAME(signature, ACPI_RSDP_NAME) ||
 816             ACPI_COMPARE_NAME(signature, ACPI_SIG_RSDT) ||
 817             ACPI_COMPARE_NAME(signature, ACPI_SIG_XSDT) ||
 818             ACPI_COMPARE_NAME(signature, ACPI_SIG_DSDT) ||
 819             ACPI_COMPARE_NAME(signature, ACPI_SIG_FACS)) {
 820                 if (instance > 0) {
 821                         return (AE_LIMIT);
 822                 }
 823
 824                 /*
 825                  * Get the appropriate address, either 32-bit or 64-bit. Be very
 826                  * careful about the FADT length and validate table addresses.
 827                  * Note: The 64-bit addresses have priority.
 828                  */
 829                 if (ACPI_COMPARE_NAME(signature, ACPI_SIG_DSDT)) {
 830                         if ((gbl_fadt->header.length >= MIN_FADT_FOR_XDSDT) &&
 831                             gbl_fadt->Xdsdt) {
 832                                 table_address =
 833                                     (acpi_physical_address) gbl_fadt->Xdsdt;
 834                         } else
 835                             if ((gbl_fadt->header.length >= MIN_FADT_FOR_DSDT)
 836                                 && gbl_fadt->dsdt) {
 837                                 table_address =
 838                                     (acpi_physical_address) gbl_fadt->dsdt;
 839                         }
 840                 } else if (ACPI_COMPARE_NAME(signature, ACPI_SIG_FACS)) {
 841                         if ((gbl_fadt->header.length >= MIN_FADT_FOR_XFACS) &&
 842                             gbl_fadt->Xfacs) {
 843                                 table_address =
 844                                     (acpi_physical_address) gbl_fadt->Xfacs;
 845                         } else
 846                             if ((gbl_fadt->header.length >= MIN_FADT_FOR_FACS)
 847                                 && gbl_fadt->facs) {
 848                                 table_address =
 849                                     (acpi_physical_address) gbl_fadt->facs;
 850                         }
 851                 } else if (ACPI_COMPARE_NAME(signature, ACPI_SIG_XSDT)) {
 852                         if (!gbl_revision) {
 853                                 return (AE_BAD_SIGNATURE);
 854                         }
 855                         table_address =
 856                             (acpi_physical_address) gbl_rsdp.
 857                             xsdt_physical_address;
 858                 } else if (ACPI_COMPARE_NAME(signature, ACPI_SIG_RSDT)) {
 859                         table_address =
 860                             (acpi_physical_address) gbl_rsdp.
 861                             rsdt_physical_address;
 862                 } else {
 863                         table_address =
 864                             (acpi_physical_address) gbl_rsdp_address;
 865                         signature = ACPI_SIG_RSDP;
 866                 }
 867
 868                 /* Now we can get the requested special table */
 869
 870                 status = osl_map_table(table_address, signature, &mapped_table);
 871                 if (ACPI_FAILURE(status)) {
 872                         return (status);
 873                 }
 874
 875                 table_length = ap_get_table_length(mapped_table);
 876         } else {                /* Case for a normal ACPI table */
 877
 878                 if (osl_can_use_xsdt()) {
 879                         item_size = sizeof(u64);
 880                         table_data =
 881                             ACPI_CAST8(gbl_xsdt) +
 882                             sizeof(struct acpi_table_header);
 883                         number_of_tables =
 884                             (u8)((gbl_xsdt->header.length -
 885                                   sizeof(struct acpi_table_header))
 886                                  / item_size);
 887                 } else {        /* Use RSDT if XSDT is not available */
 888
 889                         item_size = sizeof(u32);
 890                         table_data =
 891                             ACPI_CAST8(gbl_rsdt) +
 892                             sizeof(struct acpi_table_header);
 893                         number_of_tables =
 894                             (u8)((gbl_rsdt->header.length -
 895                                   sizeof(struct acpi_table_header))
 896                                  / item_size);
 897                 }
 898
 899                 /* Search RSDT/XSDT for the requested table */
 900
 901                 for (i = 0; i < number_of_tables; ++i, table_data += item_size) {
 902                         if (osl_can_use_xsdt()) {
 903                                 table_address =
 904                                     (acpi_physical_address) (*ACPI_CAST64
 905                                                              (table_data));
 906                         } else {
 907                                 table_address =
 908                                     (acpi_physical_address) (*ACPI_CAST32
 909                                                              (table_data));
 910                         }
 911
 912                         /* Skip NULL entries in RSDT/XSDT */
 913
 914                         if (!table_address) {
 915                                 continue;
 916                         }
 917
 918                         status =
 919                             osl_map_table(table_address, NULL, &mapped_table);
 920                         if (ACPI_FAILURE(status)) {
 921                                 return (status);
 922                         }
 923                         table_length = mapped_table->length;
 924
 925                         /* Does this table match the requested signature? */
 926
 927                         if (!ACPI_COMPARE_NAME
 928                             (mapped_table->signature, signature)) {
 929                                 osl_unmap_table(mapped_table);
 930                                 mapped_table = NULL;
 931                                 continue;
 932                         }
 933
 934                         /* Match table instance (for SSDT/UEFI tables) */
 935
 936                         if (current_instance != instance) {
 937                                 osl_unmap_table(mapped_table);
 938                                 mapped_table = NULL;
 939                                 current_instance++;
 940                                 continue;
 941                         }
 942
 943                         break;
 944                 }
 945         }
 946
 947         if (!mapped_table) {
 948                 return (AE_LIMIT);
 949         }
 950
 951         if (table_length == 0) {
 952                 status = AE_BAD_HEADER;
 953                 goto exit;
 954         }
 955
 956         /* Copy table to local buffer and return it */
 957
 958         local_table = calloc(1, table_length);
 959         if (!local_table) {
 960                 status = AE_NO_MEMORY;
 961                 goto exit;
 962         }
 963
 964         ACPI_MEMCPY(local_table, mapped_table, table_length);
 965         *address = table_address;
 966         *table = local_table;
 967
 968 exit:
 969         osl_unmap_table(mapped_table);
 970         return (status);
 971 }
 972
 973 /******************************************************************************
 974  *
 975  * FUNCTION:    osl_list_customized_tables
 976  *
 977  * PARAMETERS:  directory           - Directory that contains the tables
 978  *
 979  * RETURN:      Status; Table list is initialized if AE_OK.
 980  *
 981  * DESCRIPTION: Add ACPI tables to the table list from a directory.
 982  *
 983  *****************************************************************************/
 984
 985 static acpi_status osl_list_customized_tables(char *directory)
 986 {
 987         void *table_dir;
 988         u32 instance;
 989         char temp_name[ACPI_NAME_SIZE];
 990         char *filename;
 991         acpi_status status = AE_OK;
 992
 993         /* Open the requested directory */
 994
 995         table_dir = acpi_os_open_directory(directory, "*", REQUEST_FILE_ONLY);
 996         if (!table_dir) {
 997                 return (osl_get_last_status(AE_NOT_FOUND));
 998         }
 999
1000         /* Examine all entries in this directory */
1001
1002         while ((filename = acpi_os_get_next_filename(table_dir))) {
1003
1004                 /* Extract table name and instance number */
1005
1006                 status =
1007                     osl_table_name_from_file(filename, temp_name, &instance);
1008
1009                 /* Ignore meaningless files */
1010
1011                 if (ACPI_FAILURE(status)) {
1012                         continue;
1013                 }
1014
1015                 /* Add new info node to global table list */
1016
1017                 status = osl_add_table_to_list(temp_name, instance);
1018                 if (ACPI_FAILURE(status)) {
1019                         break;
1020                 }
1021         }
1022
1023         acpi_os_close_directory(table_dir);
1024         return (status);
1025 }
1026
1027 /******************************************************************************
1028  *
1029  * FUNCTION:    osl_map_table
1030  *
1031  * PARAMETERS:  address             - Address of the table in memory
1032  *              signature           - Optional ACPI Signature for desired table.
1033  *                                    Null terminated 4-character string.
1034  *              table               - Where a pointer to the mapped table is
1035  *                                    returned
1036  *
1037  * RETURN:      Status; Mapped table is returned if AE_OK.
1038  *              AE_NOT_FOUND: A valid table was not found at the address
1039  *
1040  * DESCRIPTION: Map entire ACPI table into caller's address space.
1041  *
1042  *****************************************************************************/
1043
1044 static acpi_status
1045 osl_map_table(acpi_size address,
1046               char *signature, struct acpi_table_header **table)
1047 {
1048         struct acpi_table_header *mapped_table;
1049         u32 length;
1050
1051         if (!address) {
1052                 return (AE_BAD_ADDRESS);
1053         }
1054
1055         /*
1056          * Map the header so we can get the table length.
1057          * Use sizeof (struct acpi_table_header) as:
1058          * 1. it is bigger than 24 to include RSDP->Length
1059          * 2. it is smaller than sizeof (struct acpi_table_rsdp)
1060          */
1061         mapped_table =
1062             acpi_os_map_memory(address, sizeof(struct acpi_table_header));
1063         if (!mapped_table) {
1064                 fprintf(stderr, "Could not map table header at 0x%8.8X%8.8X\n",
1065                         ACPI_FORMAT_UINT64(address));
1066                 return (osl_get_last_status(AE_BAD_ADDRESS));
1067         }
1068
1069         /* If specified, signature must match */
1070
1071         if (signature) {
1072                 if (ACPI_VALIDATE_RSDP_SIG(signature)) {
1073                         if (!ACPI_VALIDATE_RSDP_SIG(mapped_table->signature)) {
1074                                 acpi_os_unmap_memory(mapped_table,
1075                                                      sizeof(struct
1076                                                             acpi_table_header));
1077                                 return (AE_BAD_SIGNATURE);
1078                         }
1079                 } else
1080                     if (!ACPI_COMPARE_NAME(signature, mapped_table->signature))
1081                 {
1082                         acpi_os_unmap_memory(mapped_table,
1083                                              sizeof(struct acpi_table_header));
1084                         return (AE_BAD_SIGNATURE);
1085                 }
1086         }
1087
1088         /* Map the entire table */
1089
1090         length = ap_get_table_length(mapped_table);
1091         acpi_os_unmap_memory(mapped_table, sizeof(struct acpi_table_header));
1092         if (length == 0) {
1093                 return (AE_BAD_HEADER);
1094         }
1095
1096         mapped_table = acpi_os_map_memory(address, length);
1097         if (!mapped_table) {
1098                 fprintf(stderr,
1099                         "Could not map table at 0x%8.8X%8.8X length %8.8X\n",
1100                         ACPI_FORMAT_UINT64(address), length);
1101                 return (osl_get_last_status(AE_INVALID_TABLE_LENGTH));
1102         }
1103
1104         (void)ap_is_valid_checksum(mapped_table);
1105
1106         *table = mapped_table;
1107         return (AE_OK);
1108 }
1109
1110 /******************************************************************************
1111  *
1112  * FUNCTION:    osl_unmap_table
1113  *
1114  * PARAMETERS:  table               - A pointer to the mapped table
1115  *
1116  * RETURN:      None
1117  *
1118  * DESCRIPTION: Unmap entire ACPI table.
1119  *
1120  *****************************************************************************/
1121
1122 static void osl_unmap_table(struct acpi_table_header *table)
1123 {
1124         if (table) {
1125                 acpi_os_unmap_memory(table, ap_get_table_length(table));
1126         }
1127 }
1128
1129 /******************************************************************************
1130  *
1131  * FUNCTION:    osl_table_name_from_file
1132  *
1133  * PARAMETERS:  filename            - File that contains the desired table
1134  *              signature           - Pointer to 4-character buffer to store
1135  *                                    extracted table signature.
1136  *              instance            - Pointer to integer to store extracted
1137  *                                    table instance number.
1138  *
1139  * RETURN:      Status; Table name is extracted if AE_OK.
1140  *
1141  * DESCRIPTION: Extract table signature and instance number from a table file
1142  *              name.
1143  *
1144  *****************************************************************************/
1145
1146 static acpi_status
1147 osl_table_name_from_file(char *filename, char *signature, u32 *instance)
1148 {
1149
1150         /* Ignore meaningless files */
1151
1152         if (strlen(filename) < ACPI_NAME_SIZE) {
1153                 return (AE_BAD_SIGNATURE);
1154         }
1155
1156         /* Extract instance number */
1157
1158         if (isdigit((int)filename[ACPI_NAME_SIZE])) {
1159                 sscanf(&filename[ACPI_NAME_SIZE], "%u", instance);
1160         } else if (strlen(filename) != ACPI_NAME_SIZE) {
1161                 return (AE_BAD_SIGNATURE);
1162         } else {
1163                 *instance = 0;
1164         }
1165
1166         /* Extract signature */
1167
1168         ACPI_MOVE_NAME(signature, filename);
1169         return (AE_OK);
1170 }
1171
1172 /******************************************************************************
1173  *
1174  * FUNCTION:    osl_read_table_from_file
1175  *
1176  * PARAMETERS:  filename            - File that contains the desired table
1177  *              file_offset         - Offset of the table in file
1178  *              signature           - Optional ACPI Signature for desired table.
1179  *                                    A null terminated 4-character string.
1180  *              table               - Where a pointer to the table is returned
1181  *
1182  * RETURN:      Status; Table buffer is returned if AE_OK.
1183  *
1184  * DESCRIPTION: Read a ACPI table from a file.
1185  *
1186  *****************************************************************************/
1187
1188 static acpi_status
1189 osl_read_table_from_file(char *filename,
1190                          acpi_size file_offset,
1191                          char *signature, struct acpi_table_header **table)
1192 {
1193         FILE *table_file;
1194         struct acpi_table_header header;
1195         struct acpi_table_header *local_table = NULL;
1196         u32 table_length;
1197         s32 count;
1198         acpi_status status = AE_OK;
1199
1200         /* Open the file */
1201
1202         table_file = fopen(filename, "rb");
1203         if (table_file == NULL) {
1204                 fprintf(stderr, "Could not open table file: %s\n", filename);
1205                 return (osl_get_last_status(AE_NOT_FOUND));
1206         }
1207
1208         fseek(table_file, file_offset, SEEK_SET);
1209
1210         /* Read the Table header to get the table length */
1211
1212         count = fread(&header, 1, sizeof(struct acpi_table_header), table_file);
1213         if (count != sizeof(struct acpi_table_header)) {
1214                 fprintf(stderr, "Could not read table header: %s\n", filename);
1215                 status = AE_BAD_HEADER;
1216                 goto exit;
1217         }
1218
1219         /* If signature is specified, it must match the table */
1220
1221         if (signature) {
1222                 if (ACPI_VALIDATE_RSDP_SIG(signature)) {
1223                         if (!ACPI_VALIDATE_RSDP_SIG(header.signature)) {
1224                                 fprintf(stderr,
1225                                         "Incorrect RSDP signature: found %8.8s\n",
1226                                         header.signature);
1227                                 status = AE_BAD_SIGNATURE;
1228                                 goto exit;
1229                         }
1230                 } else if (!ACPI_COMPARE_NAME(signature, header.signature)) {
1231                         fprintf(stderr,
1232                                 "Incorrect signature: Expecting %4.4s, found %4.4s\n",
1233                                 signature, header.signature);
1234                         status = AE_BAD_SIGNATURE;
1235                         goto exit;
1236                 }
1237         }
1238
1239         table_length = ap_get_table_length(&header);
1240         if (table_length == 0) {
1241                 status = AE_BAD_HEADER;
1242                 goto exit;
1243         }
1244
1245         /* Read the entire table into a local buffer */
1246
1247         local_table = calloc(1, table_length);
1248         if (!local_table) {
1249                 fprintf(stderr,
1250                         "%4.4s: Could not allocate buffer for table of length %X\n",
1251                         header.signature, table_length);
1252                 status = AE_NO_MEMORY;
1253                 goto exit;
1254         }
1255
1256         fseek(table_file, file_offset, SEEK_SET);
1257
1258         count = fread(local_table, 1, table_length, table_file);
1259         if (count != table_length) {
1260                 fprintf(stderr, "%4.4s: Could not read table content\n",
1261                         header.signature);
1262                 status = AE_INVALID_TABLE_LENGTH;
1263                 goto exit;
1264         }
1265
1266         /* Validate checksum */
1267
1268         (void)ap_is_valid_checksum(local_table);
1269
1270 exit:
1271         fclose(table_file);
1272         *table = local_table;
1273         return (status);
1274 }
1275
1276 /******************************************************************************
1277  *
1278  * FUNCTION:    osl_get_customized_table
1279  *
1280  * PARAMETERS:  pathname        - Directory to find Linux customized table
1281  *              signature       - ACPI Signature for desired table. Must be
1282  *                                a null terminated 4-character string.
1283  *              instance        - Multiple table support for SSDT/UEFI (0...n)
1284  *                                Must be 0 for other tables.
1285  *              table           - Where a pointer to the table is returned
1286  *              address         - Where the table physical address is returned
1287  *
1288  * RETURN:      Status; Table buffer is returned if AE_OK.
1289  *              AE_LIMIT: Instance is beyond valid limit
1290  *              AE_NOT_FOUND: A table with the signature was not found
1291  *
1292  * DESCRIPTION: Get an OS customized table.
1293  *
1294  *****************************************************************************/
1295
1296 static acpi_status
1297 osl_get_customized_table(char *pathname,
1298                          char *signature,
1299                          u32 instance,
1300                          struct acpi_table_header **table,
1301                          acpi_physical_address * address)
1302 {
1303         void *table_dir;
1304         u32 current_instance = 0;
1305         char temp_name[ACPI_NAME_SIZE];
1306         char table_filename[PATH_MAX];
1307         char *filename;
1308         acpi_status status;
1309
1310         /* Open the directory for customized tables */
1311
1312         table_dir = acpi_os_open_directory(pathname, "*", REQUEST_FILE_ONLY);
1313         if (!table_dir) {
1314                 return (osl_get_last_status(AE_NOT_FOUND));
1315         }
1316
1317         /* Attempt to find the table in the directory */
1318
1319         while ((filename = acpi_os_get_next_filename(table_dir))) {
1320
1321                 /* Ignore meaningless files */
1322
1323                 if (!ACPI_COMPARE_NAME(filename, signature)) {
1324                         continue;
1325                 }
1326
1327                 /* Extract table name and instance number */
1328
1329                 status =
1330                     osl_table_name_from_file(filename, temp_name,
1331                                              &current_instance);
1332
1333                 /* Ignore meaningless files */
1334
1335                 if (ACPI_FAILURE(status) || current_instance != instance) {
1336                         continue;
1337                 }
1338
1339                 /* Create the table pathname */
1340
1341                 if (instance != 0) {
1342                         sprintf(table_filename, "%s/%4.4s%d", pathname,
1343                                 temp_name, instance);
1344                 } else {
1345                         sprintf(table_filename, "%s/%4.4s", pathname,
1346                                 temp_name);
1347                 }
1348                 break;
1349         }
1350
1351         acpi_os_close_directory(table_dir);
1352
1353         if (!filename) {
1354                 return (AE_LIMIT);
1355         }
1356
1357         /* There is no physical address saved for customized tables, use zero */
1358
1359         *address = 0;
1360         status = osl_read_table_from_file(table_filename, 0, NULL, table);
1361
1362         return (status);
1363 }