drivers/bus/acpi/acpica/tables/tbxface.c

   1 /******************************************************************************
   2  *
   3  * Module Name: tbxface - ACPI table-oriented external interfaces
   4  *
   5  *****************************************************************************/
   6
   7 /******************************************************************************
   8  *
   9  * 1. Copyright Notice
  10  *
  11  * Some or all of this work - Copyright (c) 1999 - 2014, Intel Corp.
  12  * All rights reserved.
  13  *
  14  * 2. License
  15  *
  16  * 2.1. This is your license from Intel Corp. under its intellectual property
  17  * rights. You may have additional license terms from the party that provided
  18  * you this software, covering your right to use that party's intellectual
  19  * property rights.
  20  *
  21  * 2.2. Intel grants, free of charge, to any person ("Licensee") obtaining a
  22  * copy of the source code appearing in this file ("Covered Code") an
  23  * irrevocable, perpetual, worldwide license under Intel's copyrights in the
  24  * base code distributed originally by Intel ("Original Intel Code") to copy,
  25  * make derivatives, distribute, use and display any portion of the Covered
  26  * Code in any form, with the right to sublicense such rights; and
  27  *
  28  * 2.3. Intel grants Licensee a non-exclusive and non-transferable patent
  29  * license (with the right to sublicense), under only those claims of Intel
  30  * patents that are infringed by the Original Intel Code, to make, use, sell,
  31  * offer to sell, and import the Covered Code and derivative works thereof
  32  * solely to the minimum extent necessary to exercise the above copyright
  33  * license, and in no event shall the patent license extend to any additions
  34  * to or modifications of the Original Intel Code. No other license or right
  35  * is granted directly or by implication, estoppel or otherwise;
  36  *
  37  * The above copyright and patent license is granted only if the following
  38  * conditions are met:
  39  *
  40  * 3. Conditions
  41  *
  42  * 3.1. Redistribution of Source with Rights to Further Distribute Source.
  43  * Redistribution of source code of any substantial portion of the Covered
  44  * Code or modification with rights to further distribute source must include
  45  * the above Copyright Notice, the above License, this list of Conditions,
  46  * and the following Disclaimer and Export Compliance provision. In addition,
  47  * Licensee must cause all Covered Code to which Licensee contributes to
  48  * contain a file documenting the changes Licensee made to create that Covered
  49  * Code and the date of any change. Licensee must include in that file the
  50  * documentation of any changes made by any predecessor Licensee. Licensee
  51  * must include a prominent statement that the modification is derived,
  52  * directly or indirectly, from Original Intel Code.
  53  *
  54  * 3.2. Redistribution of Source with no Rights to Further Distribute Source.
  55  * Redistribution of source code of any substantial portion of the Covered
  56  * Code or modification without rights to further distribute source must
  57  * include the following Disclaimer and Export Compliance provision in the
  58  * documentation and/or other materials provided with distribution. In
  59  * addition, Licensee may not authorize further sublicense of source of any
  60  * portion of the Covered Code, and must include terms to the effect that the
  61  * license from Licensee to its licensee is limited to the intellectual
  62  * property embodied in the software Licensee provides to its licensee, and
  63  * not to intellectual property embodied in modifications its licensee may
  64  * make.
  65  *
  66  * 3.3. Redistribution of Executable. Redistribution in executable form of any
  67  * substantial portion of the Covered Code or modification must reproduce the
  68  * above Copyright Notice, and the following Disclaimer and Export Compliance
  69  * provision in the documentation and/or other materials provided with the
  70  * distribution.
  71  *
  72  * 3.4. Intel retains all right, title, and interest in and to the Original
  73  * Intel Code.
  74  *
  75  * 3.5. Neither the name Intel nor any other trademark owned or controlled by
  76  * Intel shall be used in advertising or otherwise to promote the sale, use or
  77  * other dealings in products derived from or relating to the Covered Code
  78  * without prior written authorization from Intel.
  79  *
  80  * 4. Disclaimer and Export Compliance
  81  *
  82  * 4.1. INTEL MAKES NO WARRANTY OF ANY KIND REGARDING ANY SOFTWARE PROVIDED
  83  * HERE. ANY SOFTWARE ORIGINATING FROM INTEL OR DERIVED FROM INTEL SOFTWARE
  84  * IS PROVIDED "AS IS," AND INTEL WILL NOT PROVIDE ANY SUPPORT, ASSISTANCE,
  85  * INSTALLATION, TRAINING OR OTHER SERVICES. INTEL WILL NOT PROVIDE ANY
  86  * UPDATES, ENHANCEMENTS OR EXTENSIONS. INTEL SPECIFICALLY DISCLAIMS ANY
  87  * IMPLIED WARRANTIES OF MERCHANTABILITY, NONINFRINGEMENT AND FITNESS FOR A
  88  * PARTICULAR PURPOSE.
  89  *
  90  * 4.2. IN NO EVENT SHALL INTEL HAVE ANY LIABILITY TO LICENSEE, ITS LICENSEES
  91  * OR ANY OTHER THIRD PARTY, FOR ANY LOST PROFITS, LOST DATA, LOSS OF USE OR
  92  * COSTS OF PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES, OR FOR ANY INDIRECT,
  93  * SPECIAL OR CONSEQUENTIAL DAMAGES ARISING OUT OF THIS AGREEMENT, UNDER ANY
  94  * CAUSE OF ACTION OR THEORY OF LIABILITY, AND IRRESPECTIVE OF WHETHER INTEL
  95  * HAS ADVANCE NOTICE OF THE POSSIBILITY OF SUCH DAMAGES. THESE LIMITATIONS
  96  * SHALL APPLY NOTWITHSTANDING THE FAILURE OF THE ESSENTIAL PURPOSE OF ANY
  97  * LIMITED REMEDY.
  98  *
  99  * 4.3. Licensee shall not export, either directly or indirectly, any of this
 100  * software or system incorporating such software without first obtaining any
 101  * required license or other approval from the U. S. Department of Commerce or
 102  * any other agency or department of the United States Government. In the
 103  * event Licensee exports any such software from the United States or
 104  * re-exports any such software from a foreign destination, Licensee shall
 105  * ensure that the distribution and export/re-export of the software is in
 106  * compliance with all laws, regulations, orders, or other restrictions of the
 107  * U.S. Export Administration Regulations. Licensee agrees that neither it nor
 108  * any of its subsidiaries will export/re-export any technical data, process,
 109  * software, or service, directly or indirectly, to any country for which the
 110  * United States government or any agency thereof requires an export license,
 111  * other governmental approval, or letter of assurance, without first obtaining
 112  * such license, approval or letter.
 113  *
 114  *****************************************************************************/
 115
 116 #define __TBXFACE_C__
 117 #define EXPORT_ACPI_INTERFACES
 118
 119 #include "acpi.h"
 120 #include "accommon.h"
 121 #include "actables.h"
 122
 123 #define _COMPONENT          ACPI_TABLES
 124         ACPI_MODULE_NAME    ("tbxface")
 125
 126
 127 /*******************************************************************************
 128  *
 129  * FUNCTION:    AcpiAllocateRootTable
 130  *
 131  * PARAMETERS:  InitialTableCount   - Size of InitialTableArray, in number of
 132  *                                    ACPI_TABLE_DESC structures
 133  *
 134  * RETURN:      Status
 135  *
 136  * DESCRIPTION: Allocate a root table array. Used by iASL compiler and
 137  *              AcpiInitializeTables.
 138  *
 139  ******************************************************************************/
 140
 141 ACPI_STATUS
 142 AcpiAllocateRootTable (
 143     UINT32                  InitialTableCount)
 144 {
 145
 146     AcpiGbl_RootTableList.MaxTableCount = InitialTableCount;
 147     AcpiGbl_RootTableList.Flags = ACPI_ROOT_ALLOW_RESIZE;
 148
 149     return (AcpiTbResizeRootTableList ());
 150 }
 151
 152
 153 /*******************************************************************************
 154  *
 155  * FUNCTION:    AcpiInitializeTables
 156  *
 157  * PARAMETERS:  InitialTableArray   - Pointer to an array of pre-allocated
 158  *                                    ACPI_TABLE_DESC structures. If NULL, the
 159  *                                    array is dynamically allocated.
 160  *              InitialTableCount   - Size of InitialTableArray, in number of
 161  *                                    ACPI_TABLE_DESC structures
 162  *              AllowResize         - Flag to tell Table Manager if resize of
 163  *                                    pre-allocated array is allowed. Ignored
 164  *                                    if InitialTableArray is NULL.
 165  *
 166  * RETURN:      Status
 167  *
 168  * DESCRIPTION: Initialize the table manager, get the RSDP and RSDT/XSDT.
 169  *
 170  * NOTE:        Allows static allocation of the initial table array in order
 171  *              to avoid the use of dynamic memory in confined environments
 172  *              such as the kernel boot sequence where it may not be available.
 173  *
 174  *              If the host OS memory managers are initialized, use NULL for
 175  *              InitialTableArray, and the table will be dynamically allocated.
 176  *
 177  ******************************************************************************/
 178
 179 ACPI_STATUS
 180 AcpiInitializeTables (
 181     ACPI_TABLE_DESC         *InitialTableArray,
 182     UINT32                  InitialTableCount,
 183     BOOLEAN                 AllowResize)
 184 {
 185     ACPI_PHYSICAL_ADDRESS   RsdpAddress;
 186     ACPI_STATUS             Status;
 187
 188
 189     ACPI_FUNCTION_TRACE (AcpiInitializeTables);
 190
 191
 192     /*
 193      * Setup the Root Table Array and allocate the table array
 194      * if requested
 195      */
 196     if (!InitialTableArray)
 197     {
 198         Status = AcpiAllocateRootTable (InitialTableCount);
 199         if (ACPI_FAILURE (Status))
 200         {
 201             return_ACPI_STATUS (Status);
 202         }
 203     }
 204     else
 205     {
 206         /* Root Table Array has been statically allocated by the host */
 207
 208         ACPI_MEMSET (InitialTableArray, 0,
 209             (ACPI_SIZE) InitialTableCount * sizeof (ACPI_TABLE_DESC));
 210
 211         AcpiGbl_RootTableList.Tables = InitialTableArray;
 212         AcpiGbl_RootTableList.MaxTableCount = InitialTableCount;
 213         AcpiGbl_RootTableList.Flags = ACPI_ROOT_ORIGIN_UNKNOWN;
 214         if (AllowResize)
 215         {
 216             AcpiGbl_RootTableList.Flags |= ACPI_ROOT_ALLOW_RESIZE;
 217         }
 218     }
 219
 220     /* Get the address of the RSDP */
 221
 222     RsdpAddress = AcpiOsGetRootPointer ();
 223     if (!RsdpAddress)
 224     {
 225         return_ACPI_STATUS (AE_NOT_FOUND);
 226     }
 227
 228     /*
 229      * Get the root table (RSDT or XSDT) and extract all entries to the local
 230      * Root Table Array. This array contains the information of the RSDT/XSDT
 231      * in a common, more useable format.
 232      */
 233     Status = AcpiTbParseRootTable (RsdpAddress);
 234     return_ACPI_STATUS (Status);
 235 }
 236
 237 ACPI_EXPORT_SYMBOL_INIT (AcpiInitializeTables)
 238
 239
 240 /*******************************************************************************
 241  *
 242  * FUNCTION:    AcpiReallocateRootTable
 243  *
 244  * PARAMETERS:  None
 245  *
 246  * RETURN:      Status
 247  *
 248  * DESCRIPTION: Reallocate Root Table List into dynamic memory. Copies the
 249  *              root list from the previously provided scratch area. Should
 250  *              be called once dynamic memory allocation is available in the
 251  *              kernel.
 252  *
 253  ******************************************************************************/
 254
 255 ACPI_STATUS
 256 AcpiReallocateRootTable (
 257     void)
 258 {
 259     ACPI_STATUS             Status;
 260
 261
 262     ACPI_FUNCTION_TRACE (AcpiReallocateRootTable);
 263
 264
 265     /*
 266      * Only reallocate the root table if the host provided a static buffer
 267      * for the table array in the call to AcpiInitializeTables.
 268      */
 269     if (AcpiGbl_RootTableList.Flags & ACPI_ROOT_ORIGIN_ALLOCATED)
 270     {
 271         return_ACPI_STATUS (AE_SUPPORT);
 272     }
 273
 274     AcpiGbl_RootTableList.Flags |= ACPI_ROOT_ALLOW_RESIZE;
 275
 276     Status = AcpiTbResizeRootTableList ();
 277     return_ACPI_STATUS (Status);
 278 }
 279
 280 ACPI_EXPORT_SYMBOL_INIT (AcpiReallocateRootTable)
 281
 282
 283 /*******************************************************************************
 284  *
 285  * FUNCTION:    AcpiGetTableHeader
 286  *
 287  * PARAMETERS:  Signature           - ACPI signature of needed table
 288  *              Instance            - Which instance (for SSDTs)
 289  *              OutTableHeader      - The pointer to the table header to fill
 290  *
 291  * RETURN:      Status and pointer to mapped table header
 292  *
 293  * DESCRIPTION: Finds an ACPI table header.
 294  *
 295  * NOTE:        Caller is responsible in unmapping the header with
 296  *              AcpiOsUnmapMemory
 297  *
 298  ******************************************************************************/
 299
 300 ACPI_STATUS
 301 AcpiGetTableHeader (
 302     char                    *Signature,
 303     UINT32                  Instance,
 304     ACPI_TABLE_HEADER       *OutTableHeader)
 305 {
 306     UINT32                  i;
 307     UINT32                  j;
 308     ACPI_TABLE_HEADER       *Header;
 309
 310
 311     /* Parameter validation */
 312
 313     if (!Signature || !OutTableHeader)
 314     {
 315         return (AE_BAD_PARAMETER);
 316     }
 317
 318     /* Walk the root table list */
 319
 320     for (i = 0, j = 0; i < AcpiGbl_RootTableList.CurrentTableCount; i++)
 321     {
 322         if (!ACPI_COMPARE_NAME (&(AcpiGbl_RootTableList.Tables[i].Signature),
 323                     Signature))
 324         {
 325             continue;
 326         }
 327
 328         if (++j < Instance)
 329         {
 330             continue;
 331         }
 332
 333         if (!AcpiGbl_RootTableList.Tables[i].Pointer)
 334         {
 335             if ((AcpiGbl_RootTableList.Tables[i].Flags &
 336                     ACPI_TABLE_ORIGIN_MASK) ==
 337                 ACPI_TABLE_ORIGIN_INTERNAL_PHYSICAL)
 338             {
 339                 Header = AcpiOsMapMemory (
 340                             AcpiGbl_RootTableList.Tables[i].Address,
 341                             sizeof (ACPI_TABLE_HEADER));
 342                 if (!Header)
 343                 {
 344                     return (AE_NO_MEMORY);
 345                 }
 346
 347                 ACPI_MEMCPY (OutTableHeader, Header,
 348                     sizeof (ACPI_TABLE_HEADER));
 349                 AcpiOsUnmapMemory (Header, sizeof (ACPI_TABLE_HEADER));
 350             }
 351             else
 352             {
 353                 return (AE_NOT_FOUND);
 354             }
 355         }
 356         else
 357         {
 358             ACPI_MEMCPY (OutTableHeader,
 359                 AcpiGbl_RootTableList.Tables[i].Pointer,
 360                 sizeof (ACPI_TABLE_HEADER));
 361         }
 362
 363         return (AE_OK);
 364     }
 365
 366     return (AE_NOT_FOUND);
 367 }
 368
 369 ACPI_EXPORT_SYMBOL (AcpiGetTableHeader)
 370
 371
 372 /*******************************************************************************
 373  *
 374  * FUNCTION:    AcpiGetTable
 375  *
 376  * PARAMETERS:  Signature           - ACPI signature of needed table
 377  *              Instance            - Which instance (for SSDTs)
 378  *              OutTable            - Where the pointer to the table is returned
 379  *
 380  * RETURN:      Status and pointer to the requested table
 381  *
 382  * DESCRIPTION: Finds and verifies an ACPI table. Table must be in the
 383  *              RSDT/XSDT.
 384  *
 385  ******************************************************************************/
 386
 387 ACPI_STATUS
 388 AcpiGetTable (
 389     char                    *Signature,
 390     UINT32                  Instance,
 391     ACPI_TABLE_HEADER       **OutTable)
 392 {
 393     UINT32                  i;
 394     UINT32                  j;
 395     ACPI_STATUS             Status;
 396
 397
 398     /* Parameter validation */
 399
 400     if (!Signature || !OutTable)
 401     {
 402         return (AE_BAD_PARAMETER);
 403     }
 404
 405     /* Walk the root table list */
 406
 407     for (i = 0, j = 0; i < AcpiGbl_RootTableList.CurrentTableCount; i++)
 408     {
 409         if (!ACPI_COMPARE_NAME (&(AcpiGbl_RootTableList.Tables[i].Signature),
 410                 Signature))
 411         {
 412             continue;
 413         }
 414
 415         if (++j < Instance)
 416         {
 417             continue;
 418         }
 419
 420         Status = AcpiTbValidateTable (&AcpiGbl_RootTableList.Tables[i]);
 421         if (ACPI_SUCCESS (Status))
 422         {
 423             *OutTable = AcpiGbl_RootTableList.Tables[i].Pointer;
 424         }
 425
 426         return (Status);
 427     }
 428
 429     return (AE_NOT_FOUND);
 430 }
 431
 432 ACPI_EXPORT_SYMBOL (AcpiGetTable)
 433
 434
 435 /*******************************************************************************
 436  *
 437  * FUNCTION:    AcpiGetTableByIndex
 438  *
 439  * PARAMETERS:  TableIndex          - Table index
 440  *              Table               - Where the pointer to the table is returned
 441  *
 442  * RETURN:      Status and pointer to the requested table
 443  *
 444  * DESCRIPTION: Obtain a table by an index into the global table list. Used
 445  *              internally also.
 446  *
 447  ******************************************************************************/
 448
 449 ACPI_STATUS
 450 AcpiGetTableByIndex (
 451     UINT32                  TableIndex,
 452     ACPI_TABLE_HEADER       **Table)
 453 {
 454     ACPI_STATUS             Status;
 455
 456
 457     ACPI_FUNCTION_TRACE (AcpiGetTableByIndex);
 458
 459
 460     /* Parameter validation */
 461
 462     if (!Table)
 463     {
 464         return_ACPI_STATUS (AE_BAD_PARAMETER);
 465     }
 466
 467     (void) AcpiUtAcquireMutex (ACPI_MTX_TABLES);
 468
 469     /* Validate index */
 470
 471     if (TableIndex >= AcpiGbl_RootTableList.CurrentTableCount)
 472     {
 473         (void) AcpiUtReleaseMutex (ACPI_MTX_TABLES);
 474         return_ACPI_STATUS (AE_BAD_PARAMETER);
 475     }
 476
 477     if (!AcpiGbl_RootTableList.Tables[TableIndex].Pointer)
 478     {
 479         /* Table is not mapped, map it */
 480
 481         Status = AcpiTbValidateTable (&AcpiGbl_RootTableList.Tables[TableIndex]);
 482         if (ACPI_FAILURE (Status))
 483         {
 484             (void) AcpiUtReleaseMutex (ACPI_MTX_TABLES);
 485             return_ACPI_STATUS (Status);
 486         }
 487     }
 488
 489     *Table = AcpiGbl_RootTableList.Tables[TableIndex].Pointer;
 490     (void) AcpiUtReleaseMutex (ACPI_MTX_TABLES);
 491     return_ACPI_STATUS (AE_OK);
 492 }
 493
 494 ACPI_EXPORT_SYMBOL (AcpiGetTableByIndex)
 495
 496
 497 /*******************************************************************************
 498  *
 499  * FUNCTION:    AcpiInstallTableHandler
 500  *
 501  * PARAMETERS:  Handler         - Table event handler
 502  *              Context         - Value passed to the handler on each event
 503  *
 504  * RETURN:      Status
 505  *
 506  * DESCRIPTION: Install a global table event handler.
 507  *
 508  ******************************************************************************/
 509
 510 ACPI_STATUS
 511 AcpiInstallTableHandler (
 512     ACPI_TABLE_HANDLER      Handler,
 513     void                    *Context)
 514 {
 515     ACPI_STATUS             Status;
 516
 517
 518     ACPI_FUNCTION_TRACE (AcpiInstallTableHandler);
 519
 520
 521     if (!Handler)
 522     {
 523         return_ACPI_STATUS (AE_BAD_PARAMETER);
 524     }
 525
 526     Status = AcpiUtAcquireMutex (ACPI_MTX_EVENTS);
 527     if (ACPI_FAILURE (Status))
 528     {
 529         return_ACPI_STATUS (Status);
 530     }
 531
 532     /* Don't allow more than one handler */
 533
 534     if (AcpiGbl_TableHandler)
 535     {
 536         Status = AE_ALREADY_EXISTS;
 537         goto Cleanup;
 538     }
 539
 540     /* Install the handler */
 541
 542     AcpiGbl_TableHandler = Handler;
 543     AcpiGbl_TableHandlerContext = Context;
 544
 545 Cleanup:
 546     (void) AcpiUtReleaseMutex (ACPI_MTX_EVENTS);
 547     return_ACPI_STATUS (Status);
 548 }
 549
 550 ACPI_EXPORT_SYMBOL (AcpiInstallTableHandler)
 551
 552
 553 /*******************************************************************************
 554  *
 555  * FUNCTION:    AcpiRemoveTableHandler
 556  *
 557  * PARAMETERS:  Handler         - Table event handler that was installed
 558  *                                previously.
 559  *
 560  * RETURN:      Status
 561  *
 562  * DESCRIPTION: Remove a table event handler
 563  *
 564  ******************************************************************************/
 565
 566 ACPI_STATUS
 567 AcpiRemoveTableHandler (
 568     ACPI_TABLE_HANDLER      Handler)
 569 {
 570     ACPI_STATUS             Status;
 571
 572
 573     ACPI_FUNCTION_TRACE (AcpiRemoveTableHandler);
 574
 575
 576     Status = AcpiUtAcquireMutex (ACPI_MTX_EVENTS);
 577     if (ACPI_FAILURE (Status))
 578     {
 579         return_ACPI_STATUS (Status);
 580     }
 581
 582     /* Make sure that the installed handler is the same */
 583
 584     if (!Handler ||
 585         Handler != AcpiGbl_TableHandler)
 586     {
 587         Status = AE_BAD_PARAMETER;
 588         goto Cleanup;
 589     }
 590
 591     /* Remove the handler */
 592
 593     AcpiGbl_TableHandler = NULL;
 594
 595 Cleanup:
 596     (void) AcpiUtReleaseMutex (ACPI_MTX_EVENTS);
 597     return_ACPI_STATUS (Status);
 598 }
 599
 600 ACPI_EXPORT_SYMBOL (AcpiRemoveTableHandler)