sys/contrib/dev/acpica-unix-20061109/events/evmisc.c

   1 /******************************************************************************
   2  *
   3  * Module Name: evmisc - Miscellaneous event manager support functions
   4  *              $Revision: 1.99 $
   5  *
   6  *****************************************************************************/
   7
   8 /******************************************************************************
   9  *
  10  * 1. Copyright Notice
  11  *
  12  * Some or all of this work - Copyright (c) 1999 - 2006, Intel Corp.
  13  * All rights reserved.
  14  *
  15  * 2. License
  16  *
  17  * 2.1. This is your license from Intel Corp. under its intellectual property
  18  * rights.  You may have additional license terms from the party that provided
  19  * you this software, covering your right to use that party's intellectual
  20  * property rights.
  21  *
  22  * 2.2. Intel grants, free of charge, to any person ("Licensee") obtaining a
  23  * copy of the source code appearing in this file ("Covered Code") an
  24  * irrevocable, perpetual, worldwide license under Intel's copyrights in the
  25  * base code distributed originally by Intel ("Original Intel Code") to copy,
  26  * make derivatives, distribute, use and display any portion of the Covered
  27  * Code in any form, with the right to sublicense such rights; and
  28  *
  29  * 2.3. Intel grants Licensee a non-exclusive and non-transferable patent
  30  * license (with the right to sublicense), under only those claims of Intel
  31  * patents that are infringed by the Original Intel Code, to make, use, sell,
  32  * offer to sell, and import the Covered Code and derivative works thereof
  33  * solely to the minimum extent necessary to exercise the above copyright
  34  * license, and in no event shall the patent license extend to any additions
  35  * to or modifications of the Original Intel Code.  No other license or right
  36  * is granted directly or by implication, estoppel or otherwise;
  37  *
  38  * The above copyright and patent license is granted only if the following
  39  * conditions are met:
  40  *
  41  * 3. Conditions
  42  *
  43  * 3.1. Redistribution of Source with Rights to Further Distribute Source.
  44  * Redistribution of source code of any substantial portion of the Covered
  45  * Code or modification with rights to further distribute source must include
  46  * the above Copyright Notice, the above License, this list of Conditions,
  47  * and the following Disclaimer and Export Compliance provision.  In addition,
  48  * Licensee must cause all Covered Code to which Licensee contributes to
  49  * contain a file documenting the changes Licensee made to create that Covered
  50  * Code and the date of any change.  Licensee must include in that file the
  51  * documentation of any changes made by any predecessor Licensee.  Licensee
  52  * must include a prominent statement that the modification is derived,
  53  * directly or indirectly, from Original Intel Code.
  54  *
  55  * 3.2. Redistribution of Source with no Rights to Further Distribute Source.
  56  * Redistribution of source code of any substantial portion of the Covered
  57  * Code or modification without rights to further distribute source must
  58  * include the following Disclaimer and Export Compliance provision in the
  59  * documentation and/or other materials provided with distribution.  In
  60  * addition, Licensee may not authorize further sublicense of source of any
  61  * portion of the Covered Code, and must include terms to the effect that the
  62  * license from Licensee to its licensee is limited to the intellectual
  63  * property embodied in the software Licensee provides to its licensee, and
  64  * not to intellectual property embodied in modifications its licensee may
  65  * make.
  66  *
  67  * 3.3. Redistribution of Executable. Redistribution in executable form of any
  68  * substantial portion of the Covered Code or modification must reproduce the
  69  * above Copyright Notice, and the following Disclaimer and Export Compliance
  70  * provision in the documentation and/or other materials provided with the
  71  * distribution.
  72  *
  73  * 3.4. Intel retains all right, title, and interest in and to the Original
  74  * Intel Code.
  75  *
  76  * 3.5. Neither the name Intel nor any other trademark owned or controlled by
  77  * Intel shall be used in advertising or otherwise to promote the sale, use or
  78  * other dealings in products derived from or relating to the Covered Code
  79  * without prior written authorization from Intel.
  80  *
  81  * 4. Disclaimer and Export Compliance
  82  *
  83  * 4.1. INTEL MAKES NO WARRANTY OF ANY KIND REGARDING ANY SOFTWARE PROVIDED
  84  * HERE.  ANY SOFTWARE ORIGINATING FROM INTEL OR DERIVED FROM INTEL SOFTWARE
  85  * IS PROVIDED "AS IS," AND INTEL WILL NOT PROVIDE ANY SUPPORT,  ASSISTANCE,
  86  * INSTALLATION, TRAINING OR OTHER SERVICES.  INTEL WILL NOT PROVIDE ANY
  87  * UPDATES, ENHANCEMENTS OR EXTENSIONS.  INTEL SPECIFICALLY DISCLAIMS ANY
  88  * IMPLIED WARRANTIES OF MERCHANTABILITY, NONINFRINGEMENT AND FITNESS FOR A
  89  * PARTICULAR PURPOSE.
  90  *
  91  * 4.2. IN NO EVENT SHALL INTEL HAVE ANY LIABILITY TO LICENSEE, ITS LICENSEES
  92  * OR ANY OTHER THIRD PARTY, FOR ANY LOST PROFITS, LOST DATA, LOSS OF USE OR
  93  * COSTS OF PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES, OR FOR ANY INDIRECT,
  94  * SPECIAL OR CONSEQUENTIAL DAMAGES ARISING OUT OF THIS AGREEMENT, UNDER ANY
  95  * CAUSE OF ACTION OR THEORY OF LIABILITY, AND IRRESPECTIVE OF WHETHER INTEL
  96  * HAS ADVANCE NOTICE OF THE POSSIBILITY OF SUCH DAMAGES.  THESE LIMITATIONS
  97  * SHALL APPLY NOTWITHSTANDING THE FAILURE OF THE ESSENTIAL PURPOSE OF ANY
  98  * LIMITED REMEDY.
  99  *
 100  * 4.3. Licensee shall not export, either directly or indirectly, any of this
 101  * software or system incorporating such software without first obtaining any
 102  * required license or other approval from the U. S. Department of Commerce or
 103  * any other agency or department of the United States Government.  In the
 104  * event Licensee exports any such software from the United States or
 105  * re-exports any such software from a foreign destination, Licensee shall
 106  * ensure that the distribution and export/re-export of the software is in
 107  * compliance with all laws, regulations, orders, or other restrictions of the
 108  * U.S. Export Administration Regulations. Licensee agrees that neither it nor
 109  * any of its subsidiaries will export/re-export any technical data, process,
 110  * software, or service, directly or indirectly, to any country for which the
 111  * United States government or any agency thereof requires an export license,
 112  * other governmental approval, or letter of assurance, without first obtaining
 113  * such license, approval or letter.
 114  *
 115  *****************************************************************************/
 116
 117 #include "acpi.h"
 118 #include "acevents.h"
 119 #include "acnamesp.h"
 120 #include "acinterp.h"
 121
 122 #define _COMPONENT          ACPI_EVENTS
 123         ACPI_MODULE_NAME    ("evmisc")
 124
 125
 126 /* Names for Notify() values, used for debug output */
 127
 128 #ifdef ACPI_DEBUG_OUTPUT
 129 static const char        *AcpiNotifyValueNames[] =
 130 {
 131     "Bus Check",
 132     "Device Check",
 133     "Device Wake",
 134     "Eject Request",
 135     "Device Check Light",
 136     "Frequency Mismatch",
 137     "Bus Mode Mismatch",
 138     "Power Fault"
 139 };
 140 #endif
 141
 142 /* Pointer to FACS needed for the Global Lock */
 143
 144 static ACPI_TABLE_FACS      *Facs = NULL;
 145
 146 /* Local prototypes */
 147
 148 static void ACPI_SYSTEM_XFACE
 149 AcpiEvNotifyDispatch (
 150     void                    *Context);
 151
 152 static UINT32
 153 AcpiEvGlobalLockHandler (
 154     void                    *Context);
 155
 156
 157 /*******************************************************************************
 158  *
 159  * FUNCTION:    AcpiEvIsNotifyObject
 160  *
 161  * PARAMETERS:  Node            - Node to check
 162  *
 163  * RETURN:      TRUE if notifies allowed on this object
 164  *
 165  * DESCRIPTION: Check type of node for a object that supports notifies.
 166  *
 167  *              TBD: This could be replaced by a flag bit in the node.
 168  *
 169  ******************************************************************************/
 170
 171 BOOLEAN
 172 AcpiEvIsNotifyObject (
 173     ACPI_NAMESPACE_NODE     *Node)
 174 {
 175     switch (Node->Type)
 176     {
 177     case ACPI_TYPE_DEVICE:
 178     case ACPI_TYPE_PROCESSOR:
 179     case ACPI_TYPE_POWER:
 180     case ACPI_TYPE_THERMAL:
 181         /*
 182          * These are the ONLY objects that can receive ACPI notifications
 183          */
 184         return (TRUE);
 185
 186     default:
 187         return (FALSE);
 188     }
 189 }
 190
 191
 192 /*******************************************************************************
 193  *
 194  * FUNCTION:    AcpiEvQueueNotifyRequest
 195  *
 196  * PARAMETERS:  Node            - NS node for the notified object
 197  *              NotifyValue     - Value from the Notify() request
 198  *
 199  * RETURN:      Status
 200  *
 201  * DESCRIPTION: Dispatch a device notification event to a previously
 202  *              installed handler.
 203  *
 204  ******************************************************************************/
 205
 206 ACPI_STATUS
 207 AcpiEvQueueNotifyRequest (
 208     ACPI_NAMESPACE_NODE     *Node,
 209     UINT32                  NotifyValue)
 210 {
 211     ACPI_OPERAND_OBJECT     *ObjDesc;
 212     ACPI_OPERAND_OBJECT     *HandlerObj = NULL;
 213     ACPI_GENERIC_STATE      *NotifyInfo;
 214     ACPI_STATUS             Status = AE_OK;
 215
 216
 217     ACPI_FUNCTION_NAME (EvQueueNotifyRequest);
 218
 219
 220     /*
 221      * For value 3 (Ejection Request), some device method may need to be run.
 222      * For value 2 (Device Wake) if _PRW exists, the _PS0 method may need
 223      *   to be run.
 224      * For value 0x80 (Status Change) on the power button or sleep button,
 225      *   initiate soft-off or sleep operation?
 226      */
 227     ACPI_DEBUG_PRINT ((ACPI_DB_INFO,
 228         "Dispatching Notify(%X) on node %p\n", NotifyValue, Node));
 229
 230     if (NotifyValue <= 7)
 231     {
 232         ACPI_DEBUG_PRINT ((ACPI_DB_INFO, "Notify value: %s\n",
 233             AcpiNotifyValueNames[NotifyValue]));
 234     }
 235     else
 236     {
 237         ACPI_DEBUG_PRINT ((ACPI_DB_INFO,
 238             "Notify value: 0x%2.2X **Device Specific**\n",
 239             NotifyValue));
 240     }
 241
 242     /* Get the notify object attached to the NS Node */
 243
 244     ObjDesc = AcpiNsGetAttachedObject (Node);
 245     if (ObjDesc)
 246     {
 247         /* We have the notify object, Get the right handler */
 248
 249         switch (Node->Type)
 250         {
 251         case ACPI_TYPE_DEVICE:
 252         case ACPI_TYPE_THERMAL:
 253         case ACPI_TYPE_PROCESSOR:
 254         case ACPI_TYPE_POWER:
 255
 256             if (NotifyValue <= ACPI_MAX_SYS_NOTIFY)
 257             {
 258                 HandlerObj = ObjDesc->CommonNotify.SystemNotify;
 259             }
 260             else
 261             {
 262                 HandlerObj = ObjDesc->CommonNotify.DeviceNotify;
 263             }
 264             break;
 265
 266         default:
 267             /* All other types are not supported */
 268             return (AE_TYPE);
 269         }
 270     }
 271
 272     /* If there is any handler to run, schedule the dispatcher */
 273
 274     if ((AcpiGbl_SystemNotify.Handler && (NotifyValue <= ACPI_MAX_SYS_NOTIFY)) ||
 275         (AcpiGbl_DeviceNotify.Handler && (NotifyValue > ACPI_MAX_SYS_NOTIFY))  ||
 276         HandlerObj)
 277     {
 278         NotifyInfo = AcpiUtCreateGenericState ();
 279         if (!NotifyInfo)
 280         {
 281             return (AE_NO_MEMORY);
 282         }
 283
 284         NotifyInfo->Common.DescriptorType = ACPI_DESC_TYPE_STATE_NOTIFY;
 285         NotifyInfo->Notify.Node = Node;
 286         NotifyInfo->Notify.Value = (UINT16) NotifyValue;
 287         NotifyInfo->Notify.HandlerObj = HandlerObj;
 288
 289         Status = AcpiOsExecute (
 290                     OSL_NOTIFY_HANDLER, AcpiEvNotifyDispatch, NotifyInfo);
 291         if (ACPI_FAILURE (Status))
 292         {
 293             AcpiUtDeleteGenericState (NotifyInfo);
 294         }
 295     }
 296
 297     if (!HandlerObj)
 298     {
 299         /*
 300          * There is no per-device notify handler for this device.
 301          * This may or may not be a problem.
 302          */
 303         ACPI_DEBUG_PRINT ((ACPI_DB_INFO,
 304             "No notify handler for Notify(%4.4s, %X) node %p\n",
 305             AcpiUtGetNodeName (Node), NotifyValue, Node));
 306     }
 307
 308     return (Status);
 309 }
 310
 311
 312 /*******************************************************************************
 313  *
 314  * FUNCTION:    AcpiEvNotifyDispatch
 315  *
 316  * PARAMETERS:  Context         - To be passed to the notify handler
 317  *
 318  * RETURN:      None.
 319  *
 320  * DESCRIPTION: Dispatch a device notification event to a previously
 321  *              installed handler.
 322  *
 323  ******************************************************************************/
 324
 325 static void ACPI_SYSTEM_XFACE
 326 AcpiEvNotifyDispatch (
 327     void                    *Context)
 328 {
 329     ACPI_GENERIC_STATE      *NotifyInfo = (ACPI_GENERIC_STATE *) Context;
 330     ACPI_NOTIFY_HANDLER     GlobalHandler = NULL;
 331     void                    *GlobalContext = NULL;
 332     ACPI_OPERAND_OBJECT     *HandlerObj;
 333
 334
 335     ACPI_FUNCTION_ENTRY ();
 336
 337
 338     /*
 339      * We will invoke a global notify handler if installed.
 340      * This is done _before_ we invoke the per-device handler attached
 341      * to the device.
 342      */
 343     if (NotifyInfo->Notify.Value <= ACPI_MAX_SYS_NOTIFY)
 344     {
 345         /* Global system notification handler */
 346
 347         if (AcpiGbl_SystemNotify.Handler)
 348         {
 349             GlobalHandler = AcpiGbl_SystemNotify.Handler;
 350             GlobalContext = AcpiGbl_SystemNotify.Context;
 351         }
 352     }
 353     else
 354     {
 355         /* Global driver notification handler */
 356
 357         if (AcpiGbl_DeviceNotify.Handler)
 358         {
 359             GlobalHandler = AcpiGbl_DeviceNotify.Handler;
 360             GlobalContext = AcpiGbl_DeviceNotify.Context;
 361         }
 362     }
 363
 364     /* Invoke the system handler first, if present */
 365
 366     if (GlobalHandler)
 367     {
 368         GlobalHandler (NotifyInfo->Notify.Node, NotifyInfo->Notify.Value,
 369             GlobalContext);
 370     }
 371
 372     /* Now invoke the per-device handler, if present */
 373
 374     HandlerObj = NotifyInfo->Notify.HandlerObj;
 375     if (HandlerObj)
 376     {
 377         HandlerObj->Notify.Handler (NotifyInfo->Notify.Node,
 378             NotifyInfo->Notify.Value,
 379             HandlerObj->Notify.Context);
 380     }
 381
 382     /* All done with the info object */
 383
 384     AcpiUtDeleteGenericState (NotifyInfo);
 385 }
 386
 387
 388 /*******************************************************************************
 389  *
 390  * FUNCTION:    AcpiEvGlobalLockHandler
 391  *
 392  * PARAMETERS:  Context         - From thread interface, not used
 393  *
 394  * RETURN:      ACPI_INTERRUPT_HANDLED
 395  *
 396  * DESCRIPTION: Invoked directly from the SCI handler when a global lock
 397  *              release interrupt occurs. Attempt to acquire the global lock,
 398  *              if successful, signal the thread waiting for the lock.
 399  *
 400  * NOTE: Assumes that the semaphore can be signaled from interrupt level. If
 401  * this is not possible for some reason, a separate thread will have to be
 402  * scheduled to do this.
 403  *
 404  ******************************************************************************/
 405
 406 static UINT32
 407 AcpiEvGlobalLockHandler (
 408     void                    *Context)
 409 {
 410     BOOLEAN                 Acquired = FALSE;
 411     ACPI_STATUS             Status;
 412
 413
 414     /*
 415      * Attempt to get the lock.
 416      *
 417      * If we don't get it now, it will be marked pending and we will
 418      * take another interrupt when it becomes free.
 419      */
 420     ACPI_ACQUIRE_GLOBAL_LOCK (Facs, Acquired);
 421     if (Acquired)
 422     {
 423         /* Got the lock, now wake the thread waiting for it */
 424
 425         AcpiGbl_GlobalLockAcquired = TRUE;
 426
 427         /* Send a unit to the semaphore */
 428
 429         Status = AcpiOsSignalSemaphore (AcpiGbl_GlobalLockSemaphore, 1);
 430         if (ACPI_FAILURE (Status))
 431         {
 432             ACPI_ERROR ((AE_INFO, "Could not signal Global Lock semaphore"));
 433         }
 434     }
 435
 436     return (ACPI_INTERRUPT_HANDLED);
 437 }
 438
 439
 440 /*******************************************************************************
 441  *
 442  * FUNCTION:    AcpiEvInitGlobalLockHandler
 443  *
 444  * PARAMETERS:  None
 445  *
 446  * RETURN:      Status
 447  *
 448  * DESCRIPTION: Install a handler for the global lock release event
 449  *
 450  ******************************************************************************/
 451
 452 ACPI_STATUS
 453 AcpiEvInitGlobalLockHandler (
 454     void)
 455 {
 456     ACPI_STATUS             Status;
 457
 458
 459     ACPI_FUNCTION_TRACE (EvInitGlobalLockHandler);
 460
 461
 462     Status = AcpiGetTableByIndex (ACPI_TABLE_INDEX_FACS, (ACPI_TABLE_HEADER **) &Facs);
 463     if (ACPI_FAILURE (Status))
 464     {
 465         return_ACPI_STATUS (Status);
 466     }
 467
 468     AcpiGbl_GlobalLockPresent = TRUE;
 469     Status = AcpiInstallFixedEventHandler (ACPI_EVENT_GLOBAL,
 470                 AcpiEvGlobalLockHandler, NULL);
 471
 472     /*
 473      * If the global lock does not exist on this platform, the attempt
 474      * to enable GBL_STATUS will fail (the GBL_ENABLE bit will not stick)
 475      * Map to AE_OK, but mark global lock as not present.
 476      * Any attempt to actually use the global lock will be flagged
 477      * with an error.
 478      */
 479     if (Status == AE_NO_HARDWARE_RESPONSE)
 480     {
 481         ACPI_ERROR ((AE_INFO,
 482             "No response from Global Lock hardware, disabling lock"));
 483
 484         AcpiGbl_GlobalLockPresent = FALSE;
 485         Status = AE_OK;
 486     }
 487
 488     return_ACPI_STATUS (Status);
 489 }
 490
 491
 492 /******************************************************************************
 493  *
 494  * FUNCTION:    AcpiEvAcquireGlobalLock
 495  *
 496  * PARAMETERS:  Timeout         - Max time to wait for the lock, in millisec.
 497  *
 498  * RETURN:      Status
 499  *
 500  * DESCRIPTION: Attempt to gain ownership of the Global Lock.
 501  *
 502  * MUTEX:       Interpreter must be locked
 503  *
 504  * Note: The original implementation allowed multiple threads to "acquire" the
 505  * Global Lock, and the OS would hold the lock until the last thread had
 506  * released it. However, this could potentially starve the BIOS out of the
 507  * lock, especially in the case where there is a tight handshake between the
 508  * Embedded Controller driver and the BIOS. Therefore, this implementation
 509  * allows only one thread to acquire the HW Global Lock at a time, and makes
 510  * the global lock appear as a standard mutex on the OS side.
 511  *
 512  *****************************************************************************/
 513
 514 ACPI_STATUS
 515 AcpiEvAcquireGlobalLock (
 516     UINT16                  Timeout)
 517 {
 518     ACPI_STATUS             Status = AE_OK;
 519     BOOLEAN                 Acquired = FALSE;
 520
 521
 522     ACPI_FUNCTION_TRACE (EvAcquireGlobalLock);
 523
 524
 525     /*
 526      * Only one thread can acquire the GL at a time, the GlobalLockMutex
 527      * enforces this. This interface releases the interpreter if we must wait.
 528      */
 529     Status = AcpiExSystemWaitMutex (AcpiGbl_GlobalLockMutex, Timeout);
 530     if (ACPI_FAILURE (Status))
 531     {
 532         return_ACPI_STATUS (Status);
 533     }
 534
 535     /*
 536      * Make sure that a global lock actually exists. If not, just treat
 537      * the lock as a standard mutex.
 538      */
 539     if (!AcpiGbl_GlobalLockPresent)
 540     {
 541         AcpiGbl_GlobalLockAcquired = TRUE;
 542         return_ACPI_STATUS (AE_OK);
 543     }
 544
 545     /* Attempt to acquire the actual hardware lock */
 546
 547     ACPI_ACQUIRE_GLOBAL_LOCK (Facs, Acquired);
 548     if (Acquired)
 549     {
 550        /* We got the lock */
 551
 552         ACPI_DEBUG_PRINT ((ACPI_DB_EXEC, "Acquired hardware Global Lock\n"));
 553
 554         AcpiGbl_GlobalLockAcquired = TRUE;
 555         return_ACPI_STATUS (AE_OK);
 556     }
 557
 558     /*
 559      * Did not get the lock. The pending bit was set above, and we must now
 560      * wait until we get the global lock released interrupt.
 561      */
 562     ACPI_DEBUG_PRINT ((ACPI_DB_EXEC, "Waiting for hardware Global Lock\n"));
 563
 564     /*
 565      * Wait for handshake with the global lock interrupt handler.
 566      * This interface releases the interpreter if we must wait.
 567      */
 568     Status = AcpiExSystemWaitSemaphore (AcpiGbl_GlobalLockSemaphore,
 569                 ACPI_WAIT_FOREVER);
 570
 571     return_ACPI_STATUS (Status);
 572 }
 573
 574
 575 /*******************************************************************************
 576  *
 577  * FUNCTION:    AcpiEvReleaseGlobalLock
 578  *
 579  * PARAMETERS:  None
 580  *
 581  * RETURN:      Status
 582  *
 583  * DESCRIPTION: Releases ownership of the Global Lock.
 584  *
 585  ******************************************************************************/
 586
 587 ACPI_STATUS
 588 AcpiEvReleaseGlobalLock (
 589     void)
 590 {
 591     BOOLEAN                 Pending = FALSE;
 592     ACPI_STATUS             Status = AE_OK;
 593
 594
 595     ACPI_FUNCTION_TRACE (EvReleaseGlobalLock);
 596
 597
 598     /* Lock must be already acquired */
 599
 600     if (!AcpiGbl_GlobalLockAcquired)
 601     {
 602         ACPI_WARNING ((AE_INFO,
 603             "Cannot release the ACPI Global Lock, it has not been acquired"));
 604         return_ACPI_STATUS (AE_NOT_ACQUIRED);
 605     }
 606
 607     if (AcpiGbl_GlobalLockPresent)
 608     {
 609         /* Allow any thread to release the lock */
 610
 611         ACPI_RELEASE_GLOBAL_LOCK (Facs, Pending);
 612
 613         /*
 614          * If the pending bit was set, we must write GBL_RLS to the control
 615          * register
 616          */
 617         if (Pending)
 618         {
 619             Status = AcpiSetRegister (
 620                         ACPI_BITREG_GLOBAL_LOCK_RELEASE, 1);
 621         }
 622
 623         ACPI_DEBUG_PRINT ((ACPI_DB_EXEC, "Released hardware Global Lock\n"));
 624     }
 625
 626     AcpiGbl_GlobalLockAcquired = FALSE;
 627
 628     /* Release the local GL mutex */
 629
 630     AcpiOsReleaseMutex (AcpiGbl_GlobalLockMutex);
 631     return_ACPI_STATUS (Status);
 632 }
 633
 634
 635 /******************************************************************************
 636  *
 637  * FUNCTION:    AcpiEvTerminate
 638  *
 639  * PARAMETERS:  none
 640  *
 641  * RETURN:      none
 642  *
 643  * DESCRIPTION: Disable events and free memory allocated for table storage.
 644  *
 645  ******************************************************************************/
 646
 647 void
 648 AcpiEvTerminate (
 649     void)
 650 {
 651     ACPI_NATIVE_UINT        i;
 652     ACPI_STATUS             Status;
 653
 654
 655     ACPI_FUNCTION_TRACE (EvTerminate);
 656
 657
 658     if (AcpiGbl_EventsInitialized)
 659     {
 660         /*
 661          * Disable all event-related functionality.
 662          * In all cases, on error, print a message but obviously we don't abort.
 663          */
 664
 665         /* Disable all fixed events */
 666
 667         for (i = 0; i < ACPI_NUM_FIXED_EVENTS; i++)
 668         {
 669             Status = AcpiDisableEvent ((UINT32) i, 0);
 670             if (ACPI_FAILURE (Status))
 671             {
 672                 ACPI_ERROR ((AE_INFO,
 673                     "Could not disable fixed event %d", (UINT32) i));
 674             }
 675         }
 676
 677         /* Disable all GPEs in all GPE blocks */
 678
 679         Status = AcpiEvWalkGpeList (AcpiHwDisableGpeBlock);
 680
 681         /* Remove SCI handler */
 682
 683         Status = AcpiEvRemoveSciHandler ();
 684         if (ACPI_FAILURE(Status))
 685         {
 686             ACPI_ERROR ((AE_INFO,
 687                 "Could not remove SCI handler"));
 688         }
 689     }
 690
 691     /* Deallocate all handler objects installed within GPE info structs */
 692
 693     Status = AcpiEvWalkGpeList (AcpiEvDeleteGpeHandlers);
 694
 695     /* Return to original mode if necessary */
 696
 697     if (AcpiGbl_OriginalMode == ACPI_SYS_MODE_LEGACY)
 698     {
 699         Status = AcpiDisable ();
 700         if (ACPI_FAILURE (Status))
 701         {
 702             ACPI_WARNING ((AE_INFO, "AcpiDisable failed"));
 703         }
 704     }
 705     return_VOID;
 706 }
 707