sys/contrib/dev/acpica-unix-20031203/events/evxface.c

   1 /******************************************************************************
   2  *
   3  * Module Name: evxface - External interfaces for ACPI events
   4  *              $Revision: 141 $
   5  *
   6  *****************************************************************************/
   7
   8 /******************************************************************************
   9  *
  10  * 1. Copyright Notice
  11  *
  12  * Some or all of this work - Copyright (c) 1999 - 2003, 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 prton 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
 118 #define __EVXFACE_C__
 119
 120 #include "acpi.h"
 121 #include "acnamesp.h"
 122 #include "acevents.h"
 123 #include "acinterp.h"
 124
 125 #define _COMPONENT          ACPI_EVENTS
 126         ACPI_MODULE_NAME    ("evxface")
 127
 128
 129 /*******************************************************************************
 130  *
 131  * FUNCTION:    AcpiInstallFixedEventHandler
 132  *
 133  * PARAMETERS:  Event           - Event type to enable.
 134  *              Handler         - Pointer to the handler function for the
 135  *                                event
 136  *              Context         - Value passed to the handler on each GPE
 137  *
 138  * RETURN:      Status
 139  *
 140  * DESCRIPTION: Saves the pointer to the handler function and then enables the
 141  *              event.
 142  *
 143  ******************************************************************************/
 144
 145 ACPI_STATUS
 146 AcpiInstallFixedEventHandler (
 147     UINT32                  Event,
 148     ACPI_EVENT_HANDLER      Handler,
 149     void                    *Context)
 150 {
 151     ACPI_STATUS             Status;
 152
 153
 154     ACPI_FUNCTION_TRACE ("AcpiInstallFixedEventHandler");
 155
 156
 157     /* Parameter validation */
 158
 159     if (Event > ACPI_EVENT_MAX)
 160     {
 161         return_ACPI_STATUS (AE_BAD_PARAMETER);
 162     }
 163
 164     Status = AcpiUtAcquireMutex (ACPI_MTX_EVENTS);
 165     if (ACPI_FAILURE (Status))
 166     {
 167         return_ACPI_STATUS (Status);
 168     }
 169
 170     /* Don't allow two handlers. */
 171
 172     if (NULL != AcpiGbl_FixedEventHandlers[Event].Handler)
 173     {
 174         Status = AE_ALREADY_EXISTS;
 175         goto Cleanup;
 176     }
 177
 178     /* Install the handler before enabling the event */
 179
 180     AcpiGbl_FixedEventHandlers[Event].Handler = Handler;
 181     AcpiGbl_FixedEventHandlers[Event].Context = Context;
 182
 183     Status = AcpiEnableEvent (Event, 0);
 184     if (ACPI_FAILURE (Status))
 185     {
 186         ACPI_DEBUG_PRINT ((ACPI_DB_WARN, "Could not enable fixed event.\n"));
 187
 188         /* Remove the handler */
 189
 190         AcpiGbl_FixedEventHandlers[Event].Handler = NULL;
 191         AcpiGbl_FixedEventHandlers[Event].Context = NULL;
 192     }
 193     else
 194     {
 195         ACPI_DEBUG_PRINT ((ACPI_DB_INFO,
 196             "Enabled fixed event %X, Handler=%p\n", Event, Handler));
 197     }
 198
 199
 200 Cleanup:
 201     (void) AcpiUtReleaseMutex (ACPI_MTX_EVENTS);
 202     return_ACPI_STATUS (Status);
 203 }
 204
 205
 206 /*******************************************************************************
 207  *
 208  * FUNCTION:    AcpiRemoveFixedEventHandler
 209  *
 210  * PARAMETERS:  Event           - Event type to disable.
 211  *              Handler         - Address of the handler
 212  *
 213  * RETURN:      Status
 214  *
 215  * DESCRIPTION: Disables the event and unregisters the event handler.
 216  *
 217  ******************************************************************************/
 218
 219 ACPI_STATUS
 220 AcpiRemoveFixedEventHandler (
 221     UINT32                  Event,
 222     ACPI_EVENT_HANDLER      Handler)
 223 {
 224     ACPI_STATUS             Status = AE_OK;
 225
 226
 227     ACPI_FUNCTION_TRACE ("AcpiRemoveFixedEventHandler");
 228
 229
 230     /* Parameter validation */
 231
 232     if (Event > ACPI_EVENT_MAX)
 233     {
 234         return_ACPI_STATUS (AE_BAD_PARAMETER);
 235     }
 236
 237     Status = AcpiUtAcquireMutex (ACPI_MTX_EVENTS);
 238     if (ACPI_FAILURE (Status))
 239     {
 240         return_ACPI_STATUS (Status);
 241     }
 242
 243     /* Disable the event before removing the handler */
 244
 245     Status = AcpiDisableEvent (Event, 0);
 246
 247     /* Always Remove the handler */
 248
 249     AcpiGbl_FixedEventHandlers[Event].Handler = NULL;
 250     AcpiGbl_FixedEventHandlers[Event].Context = NULL;
 251
 252     if (ACPI_FAILURE (Status))
 253     {
 254         ACPI_DEBUG_PRINT ((ACPI_DB_WARN,
 255             "Could not write to fixed event enable register.\n"));
 256     }
 257     else
 258     {
 259         ACPI_DEBUG_PRINT ((ACPI_DB_INFO, "Disabled fixed event %X.\n", Event));
 260     }
 261
 262     (void) AcpiUtReleaseMutex (ACPI_MTX_EVENTS);
 263     return_ACPI_STATUS (Status);
 264 }
 265
 266
 267 /*******************************************************************************
 268  *
 269  * FUNCTION:    AcpiInstallNotifyHandler
 270  *
 271  * PARAMETERS:  Device          - The device for which notifies will be handled
 272  *              HandlerType     - The type of handler:
 273  *                                  ACPI_SYSTEM_NOTIFY: SystemHandler (00-7f)
 274  *                                  ACPI_DEVICE_NOTIFY: DriverHandler (80-ff)
 275  *              Handler         - Address of the handler
 276  *              Context         - Value passed to the handler on each GPE
 277  *
 278  * RETURN:      Status
 279  *
 280  * DESCRIPTION: Install a handler for notifies on an ACPI device
 281  *
 282  ******************************************************************************/
 283
 284 ACPI_STATUS
 285 AcpiInstallNotifyHandler (
 286     ACPI_HANDLE             Device,
 287     UINT32                  HandlerType,
 288     ACPI_NOTIFY_HANDLER     Handler,
 289     void                    *Context)
 290 {
 291     ACPI_OPERAND_OBJECT     *ObjDesc;
 292     ACPI_OPERAND_OBJECT     *NotifyObj;
 293     ACPI_NAMESPACE_NODE     *Node;
 294     ACPI_STATUS             Status;
 295
 296
 297     ACPI_FUNCTION_TRACE ("AcpiInstallNotifyHandler");
 298
 299
 300     /* Parameter validation */
 301
 302     if ((!Device)  ||
 303         (!Handler) ||
 304         (HandlerType > ACPI_MAX_NOTIFY_HANDLER_TYPE))
 305     {
 306         return_ACPI_STATUS (AE_BAD_PARAMETER);
 307     }
 308
 309     Status = AcpiUtAcquireMutex (ACPI_MTX_NAMESPACE);
 310     if (ACPI_FAILURE (Status))
 311     {
 312         return_ACPI_STATUS (Status);
 313     }
 314
 315     /* Convert and validate the device handle */
 316
 317     Node = AcpiNsMapHandleToNode (Device);
 318     if (!Node)
 319     {
 320         Status = AE_BAD_PARAMETER;
 321         goto UnlockAndExit;
 322     }
 323
 324     /*
 325      * Root Object:
 326      * Registering a notify handler on the root object indicates that the
 327      * caller wishes to receive notifications for all objects.  Note that
 328      * only one <external> global handler can be regsitered (per notify type).
 329      */
 330     if (Device == ACPI_ROOT_OBJECT)
 331     {
 332         /* Make sure the handler is not already installed */
 333
 334         if (((HandlerType == ACPI_SYSTEM_NOTIFY) &&
 335                 AcpiGbl_SystemNotify.Handler)          ||
 336             ((HandlerType == ACPI_DEVICE_NOTIFY) &&
 337                 AcpiGbl_DeviceNotify.Handler))
 338         {
 339             Status = AE_ALREADY_EXISTS;
 340             goto UnlockAndExit;
 341         }
 342
 343         if (HandlerType == ACPI_SYSTEM_NOTIFY)
 344         {
 345             AcpiGbl_SystemNotify.Node    = Node;
 346             AcpiGbl_SystemNotify.Handler = Handler;
 347             AcpiGbl_SystemNotify.Context = Context;
 348         }
 349         else /* ACPI_DEVICE_NOTIFY */
 350         {
 351             AcpiGbl_DeviceNotify.Node    = Node;
 352             AcpiGbl_DeviceNotify.Handler = Handler;
 353             AcpiGbl_DeviceNotify.Context = Context;
 354         }
 355
 356         /* Global notify handler installed */
 357     }
 358
 359     /*
 360      * All Other Objects:
 361      * Caller will only receive notifications specific to the target object.
 362      * Note that only certain object types can receive notifications.
 363      */
 364     else
 365     {
 366         /* Notifies allowed on this object? */
 367
 368         if (!AcpiEvIsNotifyObject (Node))
 369         {
 370             Status = AE_TYPE;
 371             goto UnlockAndExit;
 372         }
 373
 374         /* Check for an existing internal object */
 375
 376         ObjDesc = AcpiNsGetAttachedObject (Node);
 377         if (ObjDesc)
 378         {
 379             /* Object exists - make sure there's no handler */
 380
 381             if (((HandlerType == ACPI_SYSTEM_NOTIFY) &&
 382                     ObjDesc->CommonNotify.SystemNotify)   ||
 383                 ((HandlerType == ACPI_DEVICE_NOTIFY) &&
 384                     ObjDesc->CommonNotify.DeviceNotify))
 385             {
 386                 Status = AE_ALREADY_EXISTS;
 387                 goto UnlockAndExit;
 388             }
 389         }
 390         else
 391         {
 392             /* Create a new object */
 393
 394             ObjDesc = AcpiUtCreateInternalObject (Node->Type);
 395             if (!ObjDesc)
 396             {
 397                 Status = AE_NO_MEMORY;
 398                 goto UnlockAndExit;
 399             }
 400
 401             /* Attach new object to the Node */
 402
 403             Status = AcpiNsAttachObject (Device, ObjDesc, Node->Type);
 404
 405             /* Remove local reference to the object */
 406
 407             AcpiUtRemoveReference (ObjDesc);
 408
 409             if (ACPI_FAILURE (Status))
 410             {
 411                 goto UnlockAndExit;
 412             }
 413         }
 414
 415         /* Install the handler */
 416
 417         NotifyObj = AcpiUtCreateInternalObject (ACPI_TYPE_LOCAL_NOTIFY);
 418         if (!NotifyObj)
 419         {
 420             Status = AE_NO_MEMORY;
 421             goto UnlockAndExit;
 422         }
 423
 424         NotifyObj->Notify.Node    = Node;
 425         NotifyObj->Notify.Handler = Handler;
 426         NotifyObj->Notify.Context = Context;
 427
 428         if (HandlerType == ACPI_SYSTEM_NOTIFY)
 429         {
 430             ObjDesc->CommonNotify.SystemNotify = NotifyObj;
 431         }
 432         else /* ACPI_DEVICE_NOTIFY */
 433         {
 434             ObjDesc->CommonNotify.DeviceNotify = NotifyObj;
 435         }
 436     }
 437
 438
 439 UnlockAndExit:
 440     (void) AcpiUtReleaseMutex (ACPI_MTX_NAMESPACE);
 441     return_ACPI_STATUS (Status);
 442 }
 443
 444
 445 /*******************************************************************************
 446  *
 447  * FUNCTION:    AcpiRemoveNotifyHandler
 448  *
 449  * PARAMETERS:  Device          - The device for which notifies will be handled
 450  *              HandlerType     - The type of handler:
 451  *                                  ACPI_SYSTEM_NOTIFY: SystemHandler (00-7f)
 452  *                                  ACPI_DEVICE_NOTIFY: DriverHandler (80-ff)
 453  *              Handler         - Address of the handler
 454  * RETURN:      Status
 455  *
 456  * DESCRIPTION: Remove a handler for notifies on an ACPI device
 457  *
 458  ******************************************************************************/
 459
 460 ACPI_STATUS
 461 AcpiRemoveNotifyHandler (
 462     ACPI_HANDLE             Device,
 463     UINT32                  HandlerType,
 464     ACPI_NOTIFY_HANDLER     Handler)
 465 {
 466     ACPI_OPERAND_OBJECT     *NotifyObj;
 467     ACPI_OPERAND_OBJECT     *ObjDesc;
 468     ACPI_NAMESPACE_NODE     *Node;
 469     ACPI_STATUS             Status;
 470
 471
 472     ACPI_FUNCTION_TRACE ("AcpiRemoveNotifyHandler");
 473
 474
 475     /* Parameter validation */
 476
 477     if ((!Device)  ||
 478         (!Handler) ||
 479         (HandlerType > ACPI_MAX_NOTIFY_HANDLER_TYPE))
 480     {
 481         return_ACPI_STATUS (AE_BAD_PARAMETER);
 482     }
 483
 484     Status = AcpiUtAcquireMutex (ACPI_MTX_NAMESPACE);
 485     if (ACPI_FAILURE (Status))
 486     {
 487         return_ACPI_STATUS (Status);
 488     }
 489
 490     /* Convert and validate the device handle */
 491
 492     Node = AcpiNsMapHandleToNode (Device);
 493     if (!Node)
 494     {
 495         Status = AE_BAD_PARAMETER;
 496         goto UnlockAndExit;
 497     }
 498
 499     /*
 500      * Root Object
 501      */
 502     if (Device == ACPI_ROOT_OBJECT)
 503     {
 504         ACPI_DEBUG_PRINT ((ACPI_DB_INFO, "Removing notify handler for ROOT object.\n"));
 505
 506         if (((HandlerType == ACPI_SYSTEM_NOTIFY) &&
 507               !AcpiGbl_SystemNotify.Handler) ||
 508             ((HandlerType == ACPI_DEVICE_NOTIFY) &&
 509               !AcpiGbl_DeviceNotify.Handler))
 510         {
 511             Status = AE_NOT_EXIST;
 512             goto UnlockAndExit;
 513         }
 514
 515         if (HandlerType == ACPI_SYSTEM_NOTIFY)
 516         {
 517             AcpiGbl_SystemNotify.Node    = NULL;
 518             AcpiGbl_SystemNotify.Handler = NULL;
 519             AcpiGbl_SystemNotify.Context = NULL;
 520         }
 521         else
 522         {
 523             AcpiGbl_DeviceNotify.Node    = NULL;
 524             AcpiGbl_DeviceNotify.Handler = NULL;
 525             AcpiGbl_DeviceNotify.Context = NULL;
 526         }
 527     }
 528
 529     /*
 530      * All Other Objects
 531      */
 532     else
 533     {
 534         /* Notifies allowed on this object? */
 535
 536         if (!AcpiEvIsNotifyObject (Node))
 537         {
 538             Status = AE_TYPE;
 539             goto UnlockAndExit;
 540         }
 541
 542         /* Check for an existing internal object */
 543
 544         ObjDesc = AcpiNsGetAttachedObject (Node);
 545         if (!ObjDesc)
 546         {
 547             Status = AE_NOT_EXIST;
 548             goto UnlockAndExit;
 549         }
 550
 551         /* Object exists - make sure there's an existing handler */
 552
 553         if (HandlerType == ACPI_SYSTEM_NOTIFY)
 554         {
 555             NotifyObj = ObjDesc->CommonNotify.SystemNotify;
 556         }
 557         else
 558         {
 559             NotifyObj = ObjDesc->CommonNotify.DeviceNotify;
 560         }
 561
 562         if ((!NotifyObj) ||
 563             (NotifyObj->Notify.Handler != Handler))
 564         {
 565             Status = AE_BAD_PARAMETER;
 566             goto UnlockAndExit;
 567         }
 568
 569         /* Remove the handler */
 570
 571         if (HandlerType == ACPI_SYSTEM_NOTIFY)
 572         {
 573             ObjDesc->CommonNotify.SystemNotify = NULL;
 574         }
 575         else
 576         {
 577             ObjDesc->CommonNotify.DeviceNotify = NULL;
 578         }
 579
 580         AcpiUtRemoveReference (NotifyObj);
 581     }
 582
 583
 584 UnlockAndExit:
 585     (void) AcpiUtReleaseMutex (ACPI_MTX_NAMESPACE);
 586     return_ACPI_STATUS (Status);
 587 }
 588
 589
 590 /*******************************************************************************
 591  *
 592  * FUNCTION:    AcpiInstallGpeHandler
 593  *
 594  * PARAMETERS:  GpeNumber       - The GPE number within the GPE block
 595  *              GpeBlock        - GPE block (NULL == FADT GPEs)
 596  *              Type            - Whether this GPE should be treated as an
 597  *                                edge- or level-triggered interrupt.
 598  *              Handler         - Address of the handler
 599  *              Context         - Value passed to the handler on each GPE
 600  *
 601  * RETURN:      Status
 602  *
 603  * DESCRIPTION: Install a handler for a General Purpose Event.
 604  *
 605  ******************************************************************************/
 606
 607 ACPI_STATUS
 608 AcpiInstallGpeHandler (
 609     ACPI_HANDLE             GpeDevice,
 610     UINT32                  GpeNumber,
 611     UINT32                  Type,
 612     ACPI_GPE_HANDLER        Handler,
 613     void                    *Context)
 614 {
 615     ACPI_STATUS             Status;
 616     ACPI_GPE_EVENT_INFO     *GpeEventInfo;
 617
 618
 619     ACPI_FUNCTION_TRACE ("AcpiInstallGpeHandler");
 620
 621
 622     /* Parameter validation */
 623
 624     if (!Handler)
 625     {
 626         return_ACPI_STATUS (AE_BAD_PARAMETER);
 627     }
 628
 629     Status = AcpiUtAcquireMutex (ACPI_MTX_EVENTS);
 630     if (ACPI_FAILURE (Status))
 631     {
 632         return_ACPI_STATUS (Status);
 633     }
 634
 635     /* Ensure that we have a valid GPE number */
 636
 637     GpeEventInfo = AcpiEvGetGpeEventInfo (GpeDevice, GpeNumber);
 638     if (!GpeEventInfo)
 639     {
 640         Status = AE_BAD_PARAMETER;
 641         goto UnlockAndExit;
 642     }
 643
 644     /* Make sure that there isn't a handler there already */
 645
 646     if (GpeEventInfo->Handler)
 647     {
 648         Status = AE_ALREADY_EXISTS;
 649         goto UnlockAndExit;
 650     }
 651
 652     /* Install the handler */
 653
 654     AcpiOsAcquireLock (AcpiGbl_GpeLock, ACPI_NOT_ISR);
 655     GpeEventInfo->Handler = Handler;
 656     GpeEventInfo->Context = Context;
 657     GpeEventInfo->Flags   = (UINT8) Type;
 658     AcpiOsReleaseLock (AcpiGbl_GpeLock, ACPI_NOT_ISR);
 659
 660     /* Clear the GPE (of stale events), the enable it */
 661
 662     Status = AcpiHwClearGpe (GpeEventInfo);
 663     if (ACPI_FAILURE (Status))
 664     {
 665         goto UnlockAndExit;
 666     }
 667
 668     Status = AcpiHwEnableGpe (GpeEventInfo);
 669
 670
 671 UnlockAndExit:
 672     (void) AcpiUtReleaseMutex (ACPI_MTX_EVENTS);
 673     return_ACPI_STATUS (Status);
 674 }
 675
 676
 677 /*******************************************************************************
 678  *
 679  * FUNCTION:    AcpiRemoveGpeHandler
 680  *
 681  * PARAMETERS:  GpeNumber       - The event to remove a handler
 682  *              GpeBlock        - GPE block (NULL == FADT GPEs)
 683  *              Handler         - Address of the handler
 684  *
 685  * RETURN:      Status
 686  *
 687  * DESCRIPTION: Remove a handler for a General Purpose AcpiEvent.
 688  *
 689  ******************************************************************************/
 690
 691 ACPI_STATUS
 692 AcpiRemoveGpeHandler (
 693     ACPI_HANDLE             GpeDevice,
 694     UINT32                  GpeNumber,
 695     ACPI_GPE_HANDLER        Handler)
 696 {
 697     ACPI_STATUS             Status;
 698     ACPI_GPE_EVENT_INFO     *GpeEventInfo;
 699
 700
 701     ACPI_FUNCTION_TRACE ("AcpiRemoveGpeHandler");
 702
 703
 704     /* Parameter validation */
 705
 706     if (!Handler)
 707     {
 708         return_ACPI_STATUS (AE_BAD_PARAMETER);
 709     }
 710
 711     Status = AcpiUtAcquireMutex (ACPI_MTX_EVENTS);
 712     if (ACPI_FAILURE (Status))
 713     {
 714         return_ACPI_STATUS (Status);
 715     }
 716
 717     /* Ensure that we have a valid GPE number */
 718
 719     GpeEventInfo = AcpiEvGetGpeEventInfo (GpeDevice, GpeNumber);
 720     if (!GpeEventInfo)
 721     {
 722         Status = AE_BAD_PARAMETER;
 723         goto UnlockAndExit;
 724     }
 725
 726     /* Disable the GPE before removing the handler */
 727
 728     Status = AcpiHwDisableGpe (GpeEventInfo);
 729     if (ACPI_FAILURE (Status))
 730     {
 731         goto UnlockAndExit;
 732     }
 733
 734     /* Make sure that the installed handler is the same */
 735
 736     if (GpeEventInfo->Handler != Handler)
 737     {
 738         (void) AcpiHwEnableGpe (GpeEventInfo);
 739         Status = AE_BAD_PARAMETER;
 740         goto UnlockAndExit;
 741     }
 742
 743     /* Remove the handler */
 744
 745     AcpiOsAcquireLock (AcpiGbl_GpeLock, ACPI_NOT_ISR);
 746     GpeEventInfo->Handler = NULL;
 747     GpeEventInfo->Context = NULL;
 748     AcpiOsReleaseLock (AcpiGbl_GpeLock, ACPI_NOT_ISR);
 749
 750
 751 UnlockAndExit:
 752     (void) AcpiUtReleaseMutex (ACPI_MTX_EVENTS);
 753     return_ACPI_STATUS (Status);
 754 }
 755
 756
 757 /*******************************************************************************
 758  *
 759  * FUNCTION:    AcpiAcquireGlobalLock
 760  *
 761  * PARAMETERS:  Timeout         - How long the caller is willing to wait
 762  *              OutHandle       - A handle to the lock if acquired
 763  *
 764  * RETURN:      Status
 765  *
 766  * DESCRIPTION: Acquire the ACPI Global Lock
 767  *
 768  ******************************************************************************/
 769
 770 ACPI_STATUS
 771 AcpiAcquireGlobalLock (
 772     UINT16                  Timeout,
 773     UINT32                  *Handle)
 774 {
 775     ACPI_STATUS             Status;
 776
 777
 778     if (!Handle)
 779     {
 780         return (AE_BAD_PARAMETER);
 781     }
 782
 783     Status = AcpiExEnterInterpreter ();
 784     if (ACPI_FAILURE (Status))
 785     {
 786         return (Status);
 787     }
 788
 789     Status = AcpiEvAcquireGlobalLock (Timeout);
 790     AcpiExExitInterpreter ();
 791
 792     if (ACPI_SUCCESS (Status))
 793     {
 794         AcpiGbl_GlobalLockHandle++;
 795         *Handle = AcpiGbl_GlobalLockHandle;
 796     }
 797
 798     return (Status);
 799 }
 800
 801
 802 /*******************************************************************************
 803  *
 804  * FUNCTION:    AcpiReleaseGlobalLock
 805  *
 806  * PARAMETERS:  Handle      - Returned from AcpiAcquireGlobalLock
 807  *
 808  * RETURN:      Status
 809  *
 810  * DESCRIPTION: Release the ACPI Global Lock
 811  *
 812  ******************************************************************************/
 813
 814 ACPI_STATUS
 815 AcpiReleaseGlobalLock (
 816     UINT32                  Handle)
 817 {
 818     ACPI_STATUS             Status;
 819
 820
 821     if (Handle != AcpiGbl_GlobalLockHandle)
 822     {
 823         return (AE_NOT_ACQUIRED);
 824     }
 825
 826     Status = AcpiEvReleaseGlobalLock ();
 827     return (Status);
 828 }
 829
 830