sys/contrib/dev/acpica/source/components/tables/tbxface.c

   1 /******************************************************************************
   2  *
   3  * Module Name: tbxface - ACPI table-oriented external interfaces
   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 #define EXPORT_ACPI_INTERFACES
  45
  46 #include "acpi.h"
  47 #include "accommon.h"
  48 #include "actables.h"
  49
  50 #define _COMPONENT          ACPI_TABLES
  51         ACPI_MODULE_NAME    ("tbxface")
  52
  53
  54 /*******************************************************************************
  55  *
  56  * FUNCTION:    AcpiAllocateRootTable
  57  *
  58  * PARAMETERS:  InitialTableCount   - Size of InitialTableArray, in number of
  59  *                                    ACPI_TABLE_DESC structures
  60  *
  61  * RETURN:      Status
  62  *
  63  * DESCRIPTION: Allocate a root table array. Used by iASL compiler and
  64  *              AcpiInitializeTables.
  65  *
  66  ******************************************************************************/
  67
  68 ACPI_STATUS
  69 AcpiAllocateRootTable (
  70     UINT32                  InitialTableCount)
  71 {
  72
  73     AcpiGbl_RootTableList.MaxTableCount = InitialTableCount;
  74     AcpiGbl_RootTableList.Flags = ACPI_ROOT_ALLOW_RESIZE;
  75
  76     return (AcpiTbResizeRootTableList ());
  77 }
  78
  79
  80 /*******************************************************************************
  81  *
  82  * FUNCTION:    AcpiInitializeTables
  83  *
  84  * PARAMETERS:  InitialTableArray   - Pointer to an array of pre-allocated
  85  *                                    ACPI_TABLE_DESC structures. If NULL, the
  86  *                                    array is dynamically allocated.
  87  *              InitialTableCount   - Size of InitialTableArray, in number of
  88  *                                    ACPI_TABLE_DESC structures
  89  *              AllowResize         - Flag to tell Table Manager if resize of
  90  *                                    pre-allocated array is allowed. Ignored
  91  *                                    if InitialTableArray is NULL.
  92  *
  93  * RETURN:      Status
  94  *
  95  * DESCRIPTION: Initialize the table manager, get the RSDP and RSDT/XSDT.
  96  *
  97  * NOTE:        Allows static allocation of the initial table array in order
  98  *              to avoid the use of dynamic memory in confined environments
  99  *              such as the kernel boot sequence where it may not be available.
 100  *
 101  *              If the host OS memory managers are initialized, use NULL for
 102  *              InitialTableArray, and the table will be dynamically allocated.
 103  *
 104  ******************************************************************************/
 105
 106 ACPI_STATUS
 107 AcpiInitializeTables (
 108     ACPI_TABLE_DESC         *InitialTableArray,
 109     UINT32                  InitialTableCount,
 110     BOOLEAN                 AllowResize)
 111 {
 112     ACPI_PHYSICAL_ADDRESS   RsdpAddress;
 113     ACPI_STATUS             Status;
 114
 115
 116     ACPI_FUNCTION_TRACE (AcpiInitializeTables);
 117
 118
 119     /*
 120      * Setup the Root Table Array and allocate the table array
 121      * if requested
 122      */
 123     if (!InitialTableArray)
 124     {
 125         Status = AcpiAllocateRootTable (InitialTableCount);
 126         if (ACPI_FAILURE (Status))
 127         {
 128             return_ACPI_STATUS (Status);
 129         }
 130     }
 131     else
 132     {
 133         /* Root Table Array has been statically allocated by the host */
 134
 135         memset (InitialTableArray, 0,
 136             (ACPI_SIZE) InitialTableCount * sizeof (ACPI_TABLE_DESC));
 137
 138         AcpiGbl_RootTableList.Tables = InitialTableArray;
 139         AcpiGbl_RootTableList.MaxTableCount = InitialTableCount;
 140         AcpiGbl_RootTableList.Flags = ACPI_ROOT_ORIGIN_UNKNOWN;
 141         if (AllowResize)
 142         {
 143             AcpiGbl_RootTableList.Flags |= ACPI_ROOT_ALLOW_RESIZE;
 144         }
 145     }
 146
 147     /* Get the address of the RSDP */
 148
 149     RsdpAddress = AcpiOsGetRootPointer ();
 150     if (!RsdpAddress)
 151     {
 152         return_ACPI_STATUS (AE_NOT_FOUND);
 153     }
 154
 155     /*
 156      * Get the root table (RSDT or XSDT) and extract all entries to the local
 157      * Root Table Array. This array contains the information of the RSDT/XSDT
 158      * in a common, more useable format.
 159      */
 160     Status = AcpiTbParseRootTable (RsdpAddress);
 161     return_ACPI_STATUS (Status);
 162 }
 163
 164 ACPI_EXPORT_SYMBOL_INIT (AcpiInitializeTables)
 165
 166
 167 /*******************************************************************************
 168  *
 169  * FUNCTION:    AcpiReallocateRootTable
 170  *
 171  * PARAMETERS:  None
 172  *
 173  * RETURN:      Status
 174  *
 175  * DESCRIPTION: Reallocate Root Table List into dynamic memory. Copies the
 176  *              root list from the previously provided scratch area. Should
 177  *              be called once dynamic memory allocation is available in the
 178  *              kernel.
 179  *
 180  ******************************************************************************/
 181
 182 ACPI_STATUS
 183 AcpiReallocateRootTable (
 184     void)
 185 {
 186     ACPI_STATUS             Status;
 187
 188
 189     ACPI_FUNCTION_TRACE (AcpiReallocateRootTable);
 190
 191
 192     /*
 193      * Only reallocate the root table if the host provided a static buffer
 194      * for the table array in the call to AcpiInitializeTables.
 195      */
 196     if (AcpiGbl_RootTableList.Flags & ACPI_ROOT_ORIGIN_ALLOCATED)
 197     {
 198         return_ACPI_STATUS (AE_SUPPORT);
 199     }
 200
 201     AcpiGbl_RootTableList.Flags |= ACPI_ROOT_ALLOW_RESIZE;
 202
 203     Status = AcpiTbResizeRootTableList ();
 204     return_ACPI_STATUS (Status);
 205 }
 206
 207 ACPI_EXPORT_SYMBOL_INIT (AcpiReallocateRootTable)
 208
 209
 210 /*******************************************************************************
 211  *
 212  * FUNCTION:    AcpiGetTableHeader
 213  *
 214  * PARAMETERS:  Signature           - ACPI signature of needed table
 215  *              Instance            - Which instance (for SSDTs)
 216  *              OutTableHeader      - The pointer to the table header to fill
 217  *
 218  * RETURN:      Status and pointer to mapped table header
 219  *
 220  * DESCRIPTION: Finds an ACPI table header.
 221  *
 222  * NOTE:        Caller is responsible in unmapping the header with
 223  *              AcpiOsUnmapMemory
 224  *
 225  ******************************************************************************/
 226
 227 ACPI_STATUS
 228 AcpiGetTableHeader (
 229     char                    *Signature,
 230     UINT32                  Instance,
 231     ACPI_TABLE_HEADER       *OutTableHeader)
 232 {
 233     UINT32                  i;
 234     UINT32                  j;
 235     ACPI_TABLE_HEADER       *Header;
 236
 237
 238     /* Parameter validation */
 239
 240     if (!Signature || !OutTableHeader)
 241     {
 242         return (AE_BAD_PARAMETER);
 243     }
 244
 245     /* Walk the root table list */
 246
 247     for (i = 0, j = 0; i < AcpiGbl_RootTableList.CurrentTableCount; i++)
 248     {
 249         if (!ACPI_COMPARE_NAME (&(AcpiGbl_RootTableList.Tables[i].Signature),
 250                     Signature))
 251         {
 252             continue;
 253         }
 254
 255         if (++j < Instance)
 256         {
 257             continue;
 258         }
 259
 260         if (!AcpiGbl_RootTableList.Tables[i].Pointer)
 261         {
 262             if ((AcpiGbl_RootTableList.Tables[i].Flags &
 263                     ACPI_TABLE_ORIGIN_MASK) ==
 264                 ACPI_TABLE_ORIGIN_INTERNAL_PHYSICAL)
 265             {
 266                 Header = AcpiOsMapMemory (
 267                             AcpiGbl_RootTableList.Tables[i].Address,
 268                             sizeof (ACPI_TABLE_HEADER));
 269                 if (!Header)
 270                 {
 271                     return (AE_NO_MEMORY);
 272                 }
 273
 274                 memcpy (OutTableHeader, Header,
 275                     sizeof (ACPI_TABLE_HEADER));
 276                 AcpiOsUnmapMemory (Header, sizeof (ACPI_TABLE_HEADER));
 277             }
 278             else
 279             {
 280                 return (AE_NOT_FOUND);
 281             }
 282         }
 283         else
 284         {
 285             memcpy (OutTableHeader,
 286                 AcpiGbl_RootTableList.Tables[i].Pointer,
 287                 sizeof (ACPI_TABLE_HEADER));
 288         }
 289
 290         return (AE_OK);
 291     }
 292
 293     return (AE_NOT_FOUND);
 294 }
 295
 296 ACPI_EXPORT_SYMBOL (AcpiGetTableHeader)
 297
 298
 299 /*******************************************************************************
 300  *
 301  * FUNCTION:    AcpiGetTable
 302  *
 303  * PARAMETERS:  Signature           - ACPI signature of needed table
 304  *              Instance            - Which instance (for SSDTs)
 305  *              OutTable            - Where the pointer to the table is returned
 306  *
 307  * RETURN:      Status and pointer to the requested table
 308  *
 309  * DESCRIPTION: Finds and verifies an ACPI table. Table must be in the
 310  *              RSDT/XSDT.
 311  *
 312  ******************************************************************************/
 313
 314 ACPI_STATUS
 315 AcpiGetTable (
 316     char                    *Signature,
 317     UINT32                  Instance,
 318     ACPI_TABLE_HEADER       **OutTable)
 319 {
 320     UINT32                  i;
 321     UINT32                  j;
 322     ACPI_STATUS             Status;
 323
 324
 325     /* Parameter validation */
 326
 327     if (!Signature || !OutTable)
 328     {
 329         return (AE_BAD_PARAMETER);
 330     }
 331
 332     /* Walk the root table list */
 333
 334     for (i = 0, j = 0; i < AcpiGbl_RootTableList.CurrentTableCount; i++)
 335     {
 336         if (!ACPI_COMPARE_NAME (&(AcpiGbl_RootTableList.Tables[i].Signature),
 337                 Signature))
 338         {
 339             continue;
 340         }
 341
 342         if (++j < Instance)
 343         {
 344             continue;
 345         }
 346
 347         Status = AcpiTbValidateTable (&AcpiGbl_RootTableList.Tables[i]);
 348         if (ACPI_SUCCESS (Status))
 349         {
 350             *OutTable = AcpiGbl_RootTableList.Tables[i].Pointer;
 351         }
 352
 353         return (Status);
 354     }
 355
 356     return (AE_NOT_FOUND);
 357 }
 358
 359 ACPI_EXPORT_SYMBOL (AcpiGetTable)
 360
 361
 362 /*******************************************************************************
 363  *
 364  * FUNCTION:    AcpiGetTableByIndex
 365  *
 366  * PARAMETERS:  TableIndex          - Table index
 367  *              Table               - Where the pointer to the table is returned
 368  *
 369  * RETURN:      Status and pointer to the requested table
 370  *
 371  * DESCRIPTION: Obtain a table by an index into the global table list. Used
 372  *              internally also.
 373  *
 374  ******************************************************************************/
 375
 376 ACPI_STATUS
 377 AcpiGetTableByIndex (
 378     UINT32                  TableIndex,
 379     ACPI_TABLE_HEADER       **Table)
 380 {
 381     ACPI_STATUS             Status;
 382
 383
 384     ACPI_FUNCTION_TRACE (AcpiGetTableByIndex);
 385
 386
 387     /* Parameter validation */
 388
 389     if (!Table)
 390     {
 391         return_ACPI_STATUS (AE_BAD_PARAMETER);
 392     }
 393
 394     (void) AcpiUtAcquireMutex (ACPI_MTX_TABLES);
 395
 396     /* Validate index */
 397
 398     if (TableIndex >= AcpiGbl_RootTableList.CurrentTableCount)
 399     {
 400         (void) AcpiUtReleaseMutex (ACPI_MTX_TABLES);
 401         return_ACPI_STATUS (AE_BAD_PARAMETER);
 402     }
 403
 404     if (!AcpiGbl_RootTableList.Tables[TableIndex].Pointer)
 405     {
 406         /* Table is not mapped, map it */
 407
 408         Status = AcpiTbValidateTable (&AcpiGbl_RootTableList.Tables[TableIndex]);
 409         if (ACPI_FAILURE (Status))
 410         {
 411             (void) AcpiUtReleaseMutex (ACPI_MTX_TABLES);
 412             return_ACPI_STATUS (Status);
 413         }
 414     }
 415
 416     *Table = AcpiGbl_RootTableList.Tables[TableIndex].Pointer;
 417     (void) AcpiUtReleaseMutex (ACPI_MTX_TABLES);
 418     return_ACPI_STATUS (AE_OK);
 419 }
 420
 421 ACPI_EXPORT_SYMBOL (AcpiGetTableByIndex)
 422
 423
 424 /*******************************************************************************
 425  *
 426  * FUNCTION:    AcpiInstallTableHandler
 427  *
 428  * PARAMETERS:  Handler         - Table event handler
 429  *              Context         - Value passed to the handler on each event
 430  *
 431  * RETURN:      Status
 432  *
 433  * DESCRIPTION: Install a global table event handler.
 434  *
 435  ******************************************************************************/
 436
 437 ACPI_STATUS
 438 AcpiInstallTableHandler (
 439     ACPI_TABLE_HANDLER      Handler,
 440     void                    *Context)
 441 {
 442     ACPI_STATUS             Status;
 443
 444
 445     ACPI_FUNCTION_TRACE (AcpiInstallTableHandler);
 446
 447
 448     if (!Handler)
 449     {
 450         return_ACPI_STATUS (AE_BAD_PARAMETER);
 451     }
 452
 453     Status = AcpiUtAcquireMutex (ACPI_MTX_EVENTS);
 454     if (ACPI_FAILURE (Status))
 455     {
 456         return_ACPI_STATUS (Status);
 457     }
 458
 459     /* Don't allow more than one handler */
 460
 461     if (AcpiGbl_TableHandler)
 462     {
 463         Status = AE_ALREADY_EXISTS;
 464         goto Cleanup;
 465     }
 466
 467     /* Install the handler */
 468
 469     AcpiGbl_TableHandler = Handler;
 470     AcpiGbl_TableHandlerContext = Context;
 471
 472 Cleanup:
 473     (void) AcpiUtReleaseMutex (ACPI_MTX_EVENTS);
 474     return_ACPI_STATUS (Status);
 475 }
 476
 477 ACPI_EXPORT_SYMBOL (AcpiInstallTableHandler)
 478
 479
 480 /*******************************************************************************
 481  *
 482  * FUNCTION:    AcpiRemoveTableHandler
 483  *
 484  * PARAMETERS:  Handler         - Table event handler that was installed
 485  *                                previously.
 486  *
 487  * RETURN:      Status
 488  *
 489  * DESCRIPTION: Remove a table event handler
 490  *
 491  ******************************************************************************/
 492
 493 ACPI_STATUS
 494 AcpiRemoveTableHandler (
 495     ACPI_TABLE_HANDLER      Handler)
 496 {
 497     ACPI_STATUS             Status;
 498
 499
 500     ACPI_FUNCTION_TRACE (AcpiRemoveTableHandler);
 501
 502
 503     Status = AcpiUtAcquireMutex (ACPI_MTX_EVENTS);
 504     if (ACPI_FAILURE (Status))
 505     {
 506         return_ACPI_STATUS (Status);
 507     }
 508
 509     /* Make sure that the installed handler is the same */
 510
 511     if (!Handler ||
 512         Handler != AcpiGbl_TableHandler)
 513     {
 514         Status = AE_BAD_PARAMETER;
 515         goto Cleanup;
 516     }
 517
 518     /* Remove the handler */
 519
 520     AcpiGbl_TableHandler = NULL;
 521
 522 Cleanup:
 523     (void) AcpiUtReleaseMutex (ACPI_MTX_EVENTS);
 524     return_ACPI_STATUS (Status);
 525 }
 526
 527 ACPI_EXPORT_SYMBOL (AcpiRemoveTableHandler)