arch/all-pc/acpica/source/components/utilities/utxface.c

   1 /******************************************************************************
   2  *
   3  * Module Name: utxface - External interfaces, miscellaneous utility functions
   4  *
   5  *****************************************************************************/
   6
   7 /*
   8  * Copyright (C) 2000 - 2013, 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
  45 #define __UTXFACE_C__
  46 #define EXPORT_ACPI_INTERFACES
  47
  48 #include "acpi.h"
  49 #include "accommon.h"
  50 #include "acdebug.h"
  51
  52 #define _COMPONENT          ACPI_UTILITIES
  53         ACPI_MODULE_NAME    ("utxface")
  54
  55
  56 /*******************************************************************************
  57  *
  58  * FUNCTION:    AcpiTerminate
  59  *
  60  * PARAMETERS:  None
  61  *
  62  * RETURN:      Status
  63  *
  64  * DESCRIPTION: Shutdown the ACPICA subsystem and release all resources.
  65  *
  66  ******************************************************************************/
  67
  68 ACPI_STATUS
  69 AcpiTerminate (
  70     void)
  71 {
  72     ACPI_STATUS         Status;
  73
  74
  75     ACPI_FUNCTION_TRACE (AcpiTerminate);
  76
  77
  78     /* Just exit if subsystem is already shutdown */
  79
  80     if (AcpiGbl_Shutdown)
  81     {
  82         ACPI_ERROR ((AE_INFO, "ACPI Subsystem is already terminated"));
  83         return_ACPI_STATUS (AE_OK);
  84     }
  85
  86     /* Subsystem appears active, go ahead and shut it down */
  87
  88     AcpiGbl_Shutdown = TRUE;
  89     AcpiGbl_StartupFlags = 0;
  90     ACPI_DEBUG_PRINT ((ACPI_DB_INFO, "Shutting down ACPI Subsystem\n"));
  91
  92     /* Terminate the AML Debugger if present */
  93
  94     ACPI_DEBUGGER_EXEC (AcpiGbl_DbTerminateThreads = TRUE);
  95
  96     /* Shutdown and free all resources */
  97
  98     AcpiUtSubsystemShutdown ();
  99
 100     /* Free the mutex objects */
 101
 102     AcpiUtMutexTerminate ();
 103
 104
 105 #ifdef ACPI_DEBUGGER
 106
 107     /* Shut down the debugger */
 108
 109     AcpiDbTerminate ();
 110 #endif
 111
 112     /* Now we can shutdown the OS-dependent layer */
 113
 114     Status = AcpiOsTerminate ();
 115     return_ACPI_STATUS (Status);
 116 }
 117
 118 ACPI_EXPORT_SYMBOL_INIT (AcpiTerminate)
 119
 120
 121 #ifndef ACPI_ASL_COMPILER
 122 /*******************************************************************************
 123  *
 124  * FUNCTION:    AcpiSubsystemStatus
 125  *
 126  * PARAMETERS:  None
 127  *
 128  * RETURN:      Status of the ACPI subsystem
 129  *
 130  * DESCRIPTION: Other drivers that use the ACPI subsystem should call this
 131  *              before making any other calls, to ensure the subsystem
 132  *              initialized successfully.
 133  *
 134  ******************************************************************************/
 135
 136 ACPI_STATUS
 137 AcpiSubsystemStatus (
 138     void)
 139 {
 140
 141     if (AcpiGbl_StartupFlags & ACPI_INITIALIZED_OK)
 142     {
 143         return (AE_OK);
 144     }
 145     else
 146     {
 147         return (AE_ERROR);
 148     }
 149 }
 150
 151 ACPI_EXPORT_SYMBOL (AcpiSubsystemStatus)
 152
 153
 154 /*******************************************************************************
 155  *
 156  * FUNCTION:    AcpiGetSystemInfo
 157  *
 158  * PARAMETERS:  OutBuffer       - A buffer to receive the resources for the
 159  *                                device
 160  *
 161  * RETURN:      Status          - the status of the call
 162  *
 163  * DESCRIPTION: This function is called to get information about the current
 164  *              state of the ACPI subsystem. It will return system information
 165  *              in the OutBuffer.
 166  *
 167  *              If the function fails an appropriate status will be returned
 168  *              and the value of OutBuffer is undefined.
 169  *
 170  ******************************************************************************/
 171
 172 ACPI_STATUS
 173 AcpiGetSystemInfo (
 174     ACPI_BUFFER             *OutBuffer)
 175 {
 176     ACPI_SYSTEM_INFO        *InfoPtr;
 177     ACPI_STATUS             Status;
 178
 179
 180     ACPI_FUNCTION_TRACE (AcpiGetSystemInfo);
 181
 182
 183     /* Parameter validation */
 184
 185     Status = AcpiUtValidateBuffer (OutBuffer);
 186     if (ACPI_FAILURE (Status))
 187     {
 188         return_ACPI_STATUS (Status);
 189     }
 190
 191     /* Validate/Allocate/Clear caller buffer */
 192
 193     Status = AcpiUtInitializeBuffer (OutBuffer, sizeof (ACPI_SYSTEM_INFO));
 194     if (ACPI_FAILURE (Status))
 195     {
 196         return_ACPI_STATUS (Status);
 197     }
 198
 199     /*
 200      * Populate the return buffer
 201      */
 202     InfoPtr = (ACPI_SYSTEM_INFO *) OutBuffer->Pointer;
 203
 204     InfoPtr->AcpiCaVersion = ACPI_CA_VERSION;
 205
 206     /* System flags (ACPI capabilities) */
 207
 208     InfoPtr->Flags = ACPI_SYS_MODE_ACPI;
 209
 210     /* Timer resolution - 24 or 32 bits  */
 211
 212     if (AcpiGbl_FADT.Flags & ACPI_FADT_32BIT_TIMER)
 213     {
 214         InfoPtr->TimerResolution = 24;
 215     }
 216     else
 217     {
 218         InfoPtr->TimerResolution = 32;
 219     }
 220
 221     /* Clear the reserved fields */
 222
 223     InfoPtr->Reserved1 = 0;
 224     InfoPtr->Reserved2 = 0;
 225
 226     /* Current debug levels */
 227
 228     InfoPtr->DebugLayer = AcpiDbgLayer;
 229     InfoPtr->DebugLevel = AcpiDbgLevel;
 230
 231     return_ACPI_STATUS (AE_OK);
 232 }
 233
 234 ACPI_EXPORT_SYMBOL (AcpiGetSystemInfo)
 235
 236
 237 /*******************************************************************************
 238  *
 239  * FUNCTION:    AcpiGetStatistics
 240  *
 241  * PARAMETERS:  Stats           - Where the statistics are returned
 242  *
 243  * RETURN:      Status          - the status of the call
 244  *
 245  * DESCRIPTION: Get the contents of the various system counters
 246  *
 247  ******************************************************************************/
 248
 249 ACPI_STATUS
 250 AcpiGetStatistics (
 251     ACPI_STATISTICS         *Stats)
 252 {
 253     ACPI_FUNCTION_TRACE (AcpiGetStatistics);
 254
 255
 256     /* Parameter validation */
 257
 258     if (!Stats)
 259     {
 260         return_ACPI_STATUS (AE_BAD_PARAMETER);
 261     }
 262
 263     /* Various interrupt-based event counters */
 264
 265     Stats->SciCount = AcpiSciCount;
 266     Stats->GpeCount = AcpiGpeCount;
 267
 268     ACPI_MEMCPY (Stats->FixedEventCount, AcpiFixedEventCount,
 269         sizeof (AcpiFixedEventCount));
 270
 271
 272     /* Other counters */
 273
 274     Stats->MethodCount = AcpiMethodCount;
 275
 276     return_ACPI_STATUS (AE_OK);
 277 }
 278
 279 ACPI_EXPORT_SYMBOL (AcpiGetStatistics)
 280
 281
 282 /*****************************************************************************
 283  *
 284  * FUNCTION:    AcpiInstallInitializationHandler
 285  *
 286  * PARAMETERS:  Handler             - Callback procedure
 287  *              Function            - Not (currently) used, see below
 288  *
 289  * RETURN:      Status
 290  *
 291  * DESCRIPTION: Install an initialization handler
 292  *
 293  * TBD: When a second function is added, must save the Function also.
 294  *
 295  ****************************************************************************/
 296
 297 ACPI_STATUS
 298 AcpiInstallInitializationHandler (
 299     ACPI_INIT_HANDLER       Handler,
 300     UINT32                  Function)
 301 {
 302
 303     if (!Handler)
 304     {
 305         return (AE_BAD_PARAMETER);
 306     }
 307
 308     if (AcpiGbl_InitHandler)
 309     {
 310         return (AE_ALREADY_EXISTS);
 311     }
 312
 313     AcpiGbl_InitHandler = Handler;
 314     return (AE_OK);
 315 }
 316
 317 ACPI_EXPORT_SYMBOL (AcpiInstallInitializationHandler)
 318
 319
 320 /*****************************************************************************
 321  *
 322  * FUNCTION:    AcpiPurgeCachedObjects
 323  *
 324  * PARAMETERS:  None
 325  *
 326  * RETURN:      Status
 327  *
 328  * DESCRIPTION: Empty all caches (delete the cached objects)
 329  *
 330  ****************************************************************************/
 331
 332 ACPI_STATUS
 333 AcpiPurgeCachedObjects (
 334     void)
 335 {
 336     ACPI_FUNCTION_TRACE (AcpiPurgeCachedObjects);
 337
 338
 339     (void) AcpiOsPurgeCache (AcpiGbl_StateCache);
 340     (void) AcpiOsPurgeCache (AcpiGbl_OperandCache);
 341     (void) AcpiOsPurgeCache (AcpiGbl_PsNodeCache);
 342     (void) AcpiOsPurgeCache (AcpiGbl_PsNodeExtCache);
 343
 344     return_ACPI_STATUS (AE_OK);
 345 }
 346
 347 ACPI_EXPORT_SYMBOL (AcpiPurgeCachedObjects)
 348
 349
 350 /*****************************************************************************
 351  *
 352  * FUNCTION:    AcpiInstallInterface
 353  *
 354  * PARAMETERS:  InterfaceName       - The interface to install
 355  *
 356  * RETURN:      Status
 357  *
 358  * DESCRIPTION: Install an _OSI interface to the global list
 359  *
 360  ****************************************************************************/
 361
 362 ACPI_STATUS
 363 AcpiInstallInterface (
 364     ACPI_STRING             InterfaceName)
 365 {
 366     ACPI_STATUS             Status;
 367     ACPI_INTERFACE_INFO     *InterfaceInfo;
 368
 369
 370     /* Parameter validation */
 371
 372     if (!InterfaceName || (ACPI_STRLEN (InterfaceName) == 0))
 373     {
 374         return (AE_BAD_PARAMETER);
 375     }
 376
 377     Status = AcpiOsAcquireMutex (AcpiGbl_OsiMutex, ACPI_WAIT_FOREVER);
 378     if (ACPI_FAILURE (Status))
 379     {
 380         return (Status);
 381     }
 382
 383     /* Check if the interface name is already in the global list */
 384
 385     InterfaceInfo = AcpiUtGetInterface (InterfaceName);
 386     if (InterfaceInfo)
 387     {
 388         /*
 389          * The interface already exists in the list. This is OK if the
 390          * interface has been marked invalid -- just clear the bit.
 391          */
 392         if (InterfaceInfo->Flags & ACPI_OSI_INVALID)
 393         {
 394             InterfaceInfo->Flags &= ~ACPI_OSI_INVALID;
 395             Status = AE_OK;
 396         }
 397         else
 398         {
 399             Status = AE_ALREADY_EXISTS;
 400         }
 401     }
 402     else
 403     {
 404         /* New interface name, install into the global list */
 405
 406         Status = AcpiUtInstallInterface (InterfaceName);
 407     }
 408
 409     AcpiOsReleaseMutex (AcpiGbl_OsiMutex);
 410     return (Status);
 411 }
 412
 413 ACPI_EXPORT_SYMBOL (AcpiInstallInterface)
 414
 415
 416 /*****************************************************************************
 417  *
 418  * FUNCTION:    AcpiRemoveInterface
 419  *
 420  * PARAMETERS:  InterfaceName       - The interface to remove
 421  *
 422  * RETURN:      Status
 423  *
 424  * DESCRIPTION: Remove an _OSI interface from the global list
 425  *
 426  ****************************************************************************/
 427
 428 ACPI_STATUS
 429 AcpiRemoveInterface (
 430     ACPI_STRING             InterfaceName)
 431 {
 432     ACPI_STATUS             Status;
 433
 434
 435     /* Parameter validation */
 436
 437     if (!InterfaceName || (ACPI_STRLEN (InterfaceName) == 0))
 438     {
 439         return (AE_BAD_PARAMETER);
 440     }
 441
 442     Status = AcpiOsAcquireMutex (AcpiGbl_OsiMutex, ACPI_WAIT_FOREVER);
 443     if (ACPI_FAILURE (Status))
 444     {
 445         return (Status);
 446     }
 447
 448     Status = AcpiUtRemoveInterface (InterfaceName);
 449
 450     AcpiOsReleaseMutex (AcpiGbl_OsiMutex);
 451     return (Status);
 452 }
 453
 454 ACPI_EXPORT_SYMBOL (AcpiRemoveInterface)
 455
 456
 457 /*****************************************************************************
 458  *
 459  * FUNCTION:    AcpiInstallInterfaceHandler
 460  *
 461  * PARAMETERS:  Handler             - The _OSI interface handler to install
 462  *                                    NULL means "remove existing handler"
 463  *
 464  * RETURN:      Status
 465  *
 466  * DESCRIPTION: Install a handler for the predefined _OSI ACPI method.
 467  *              invoked during execution of the internal implementation of
 468  *              _OSI. A NULL handler simply removes any existing handler.
 469  *
 470  ****************************************************************************/
 471
 472 ACPI_STATUS
 473 AcpiInstallInterfaceHandler (
 474     ACPI_INTERFACE_HANDLER  Handler)
 475 {
 476     ACPI_STATUS             Status;
 477
 478
 479     Status = AcpiOsAcquireMutex (AcpiGbl_OsiMutex, ACPI_WAIT_FOREVER);
 480     if (ACPI_FAILURE (Status))
 481     {
 482         return (Status);
 483     }
 484
 485     if (Handler && AcpiGbl_InterfaceHandler)
 486     {
 487         Status = AE_ALREADY_EXISTS;
 488     }
 489     else
 490     {
 491         AcpiGbl_InterfaceHandler = Handler;
 492     }
 493
 494     AcpiOsReleaseMutex (AcpiGbl_OsiMutex);
 495     return (Status);
 496 }
 497
 498 ACPI_EXPORT_SYMBOL (AcpiInstallInterfaceHandler)
 499
 500
 501 /*****************************************************************************
 502  *
 503  * FUNCTION:    AcpiUpdateInterfaces
 504  *
 505  * PARAMETERS:  Action              - Actions to be performed during the
 506  *                                    update
 507  *
 508  * RETURN:      Status
 509  *
 510  * DESCRIPTION: Update _OSI interface strings, disabling or enabling OS vendor
 511  *              string or/and feature group strings.
 512  *
 513  ****************************************************************************/
 514
 515 ACPI_STATUS
 516 AcpiUpdateInterfaces (
 517     UINT8                   Action)
 518 {
 519     ACPI_STATUS             Status;
 520
 521
 522     Status = AcpiOsAcquireMutex (AcpiGbl_OsiMutex, ACPI_WAIT_FOREVER);
 523     if (ACPI_FAILURE (Status))
 524     {
 525         return (Status);
 526     }
 527
 528     Status = AcpiUtUpdateInterfaces (Action);
 529
 530     AcpiOsReleaseMutex (AcpiGbl_OsiMutex);
 531     return (Status);
 532 }
 533
 534
 535 /*****************************************************************************
 536  *
 537  * FUNCTION:    AcpiCheckAddressRange
 538  *
 539  * PARAMETERS:  SpaceId             - Address space ID
 540  *              Address             - Start address
 541  *              Length              - Length
 542  *              Warn                - TRUE if warning on overlap desired
 543  *
 544  * RETURN:      Count of the number of conflicts detected.
 545  *
 546  * DESCRIPTION: Check if the input address range overlaps any of the
 547  *              ASL operation region address ranges.
 548  *
 549  ****************************************************************************/
 550
 551 UINT32
 552 AcpiCheckAddressRange (
 553     ACPI_ADR_SPACE_TYPE     SpaceId,
 554     ACPI_PHYSICAL_ADDRESS   Address,
 555     ACPI_SIZE               Length,
 556     BOOLEAN                 Warn)
 557 {
 558     UINT32                  Overlaps;
 559     ACPI_STATUS             Status;
 560
 561
 562     Status = AcpiUtAcquireMutex (ACPI_MTX_NAMESPACE);
 563     if (ACPI_FAILURE (Status))
 564     {
 565         return (0);
 566     }
 567
 568     Overlaps = AcpiUtCheckAddressRange (SpaceId, Address,
 569         (UINT32) Length, Warn);
 570
 571     (void) AcpiUtReleaseMutex (ACPI_MTX_NAMESPACE);
 572     return (Overlaps);
 573 }
 574
 575 ACPI_EXPORT_SYMBOL (AcpiCheckAddressRange)
 576
 577 #endif /* !ACPI_ASL_COMPILER */
 578
 579
 580 /*******************************************************************************
 581  *
 582  * FUNCTION:    AcpiDecodePldBuffer
 583  *
 584  * PARAMETERS:  InBuffer            - Buffer returned by _PLD method
 585  *              Length              - Length of the InBuffer
 586  *              ReturnBuffer        - Where the decode buffer is returned
 587  *
 588  * RETURN:      Status and the decoded _PLD buffer. User must deallocate
 589  *              the buffer via ACPI_FREE.
 590  *
 591  * DESCRIPTION: Decode the bit-packed buffer returned by the _PLD method into
 592  *              a local struct that is much more useful to an ACPI driver.
 593  *
 594  ******************************************************************************/
 595
 596 ACPI_STATUS
 597 AcpiDecodePldBuffer (
 598     UINT8                   *InBuffer,
 599     ACPI_SIZE               Length,
 600     ACPI_PLD_INFO           **ReturnBuffer)
 601 {
 602     ACPI_PLD_INFO           *PldInfo;
 603     UINT32                  *Buffer = ACPI_CAST_PTR (UINT32, InBuffer);
 604     UINT32                  Dword;
 605
 606
 607     /* Parameter validation */
 608
 609     if (!InBuffer || !ReturnBuffer || (Length < 16))
 610     {
 611         return (AE_BAD_PARAMETER);
 612     }
 613
 614     PldInfo = ACPI_ALLOCATE_ZEROED (sizeof (ACPI_PLD_INFO));
 615     if (!PldInfo)
 616     {
 617         return (AE_NO_MEMORY);
 618     }
 619
 620     /* First 32-bit DWord */
 621
 622     ACPI_MOVE_32_TO_32 (&Dword, &Buffer[0]);
 623     PldInfo->Revision =             ACPI_PLD_GET_REVISION (&Dword);
 624     PldInfo->IgnoreColor =          ACPI_PLD_GET_IGNORE_COLOR (&Dword);
 625     PldInfo->Color =                ACPI_PLD_GET_COLOR (&Dword);
 626
 627     /* Second 32-bit DWord */
 628
 629     ACPI_MOVE_32_TO_32 (&Dword, &Buffer[1]);
 630     PldInfo->Width =                ACPI_PLD_GET_WIDTH (&Dword);
 631     PldInfo->Height =               ACPI_PLD_GET_HEIGHT(&Dword);
 632
 633     /* Third 32-bit DWord */
 634
 635     ACPI_MOVE_32_TO_32 (&Dword, &Buffer[2]);
 636     PldInfo->UserVisible =          ACPI_PLD_GET_USER_VISIBLE (&Dword);
 637     PldInfo->Dock =                 ACPI_PLD_GET_DOCK (&Dword);
 638     PldInfo->Lid =                  ACPI_PLD_GET_LID (&Dword);
 639     PldInfo->Panel =                ACPI_PLD_GET_PANEL (&Dword);
 640     PldInfo->VerticalPosition =     ACPI_PLD_GET_VERTICAL (&Dword);
 641     PldInfo->HorizontalPosition =   ACPI_PLD_GET_HORIZONTAL (&Dword);
 642     PldInfo->Shape =                ACPI_PLD_GET_SHAPE (&Dword);
 643     PldInfo->GroupOrientation =     ACPI_PLD_GET_ORIENTATION (&Dword);
 644     PldInfo->GroupToken =           ACPI_PLD_GET_TOKEN (&Dword);
 645     PldInfo->GroupPosition =        ACPI_PLD_GET_POSITION (&Dword);
 646     PldInfo->Bay =                  ACPI_PLD_GET_BAY (&Dword);
 647
 648     /* Fourth 32-bit DWord */
 649
 650     ACPI_MOVE_32_TO_32 (&Dword, &Buffer[3]);
 651     PldInfo->Ejectable =            ACPI_PLD_GET_EJECTABLE (&Dword);
 652     PldInfo->OspmEjectRequired =    ACPI_PLD_GET_OSPM_EJECT (&Dword);
 653     PldInfo->CabinetNumber =        ACPI_PLD_GET_CABINET (&Dword);
 654     PldInfo->CardCageNumber =       ACPI_PLD_GET_CARD_CAGE (&Dword);
 655     PldInfo->Reference =            ACPI_PLD_GET_REFERENCE (&Dword);
 656     PldInfo->Rotation =             ACPI_PLD_GET_ROTATION (&Dword);
 657     PldInfo->Order =                ACPI_PLD_GET_ORDER (&Dword);
 658
 659     if (Length >= ACPI_PLD_BUFFER_SIZE)
 660     {
 661         /* Fifth 32-bit DWord (Revision 2 of _PLD) */
 662
 663         ACPI_MOVE_32_TO_32 (&Dword, &Buffer[4]);
 664         PldInfo->VerticalOffset =       ACPI_PLD_GET_VERT_OFFSET (&Dword);
 665         PldInfo->HorizontalOffset =     ACPI_PLD_GET_HORIZ_OFFSET (&Dword);
 666     }
 667
 668     *ReturnBuffer = PldInfo;
 669     return (AE_OK);
 670 }
 671
 672 ACPI_EXPORT_SYMBOL (AcpiDecodePldBuffer)