1 /******************************************************************************
   2  *
   3  * Module Name: evxface - External interfaces for ACPI events
   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 __EVXFACE_C__
  46 #define EXPORT_ACPI_INTERFACES
  47 
  48 #include "acpi.h"
  49 #include "accommon.h"
  50 #include "acnamesp.h"
  51 #include "acevents.h"
  52 #include "acinterp.h"
  53 
  54 #define _COMPONENT          ACPI_EVENTS
  55         ACPI_MODULE_NAME    ("evxface")
  56 
  57 
  58 /*******************************************************************************
  59  *
  60  * FUNCTION:    AcpiInstallNotifyHandler
  61  *
  62  * PARAMETERS:  Device          - The device for which notifies will be handled
  63  *              HandlerType     - The type of handler:
  64  *                                  ACPI_SYSTEM_NOTIFY: System Handler (00-7F)
  65  *                                  ACPI_DEVICE_NOTIFY: Device Handler (80-FF)
  66  *                                  ACPI_ALL_NOTIFY:    Both System and Device
  67  *              Handler         - Address of the handler
  68  *              Context         - Value passed to the handler on each GPE
  69  *
  70  * RETURN:      Status
  71  *
  72  * DESCRIPTION: Install a handler for notifications on an ACPI Device,
  73  *              ThermalZone, or Processor object.
  74  *
  75  * NOTES:       The Root namespace object may have only one handler for each
  76  *              type of notify (System/Device). Device/Thermal/Processor objects
  77  *              may have one device notify handler, and multiple system notify
  78  *              handlers.
  79  *
  80  ******************************************************************************/
  81 
  82 ACPI_STATUS
  83 AcpiInstallNotifyHandler (
  84     ACPI_HANDLE             Device,
  85     UINT32                  HandlerType,
  86     ACPI_NOTIFY_HANDLER     Handler,
  87     void                    *Context)
  88 {
  89     ACPI_NAMESPACE_NODE     *Node = ACPI_CAST_PTR (ACPI_NAMESPACE_NODE, Device);
  90     ACPI_OPERAND_OBJECT     *ObjDesc;
  91     ACPI_OPERAND_OBJECT     *HandlerObj;
  92     ACPI_STATUS             Status;
  93     UINT32                  i;
  94 
  95 
  96     ACPI_FUNCTION_TRACE (AcpiInstallNotifyHandler);
  97 
  98 
  99     /* Parameter validation */
 100 
 101     if ((!Device) || (!Handler) || (!HandlerType) ||
 102         (HandlerType > ACPI_MAX_NOTIFY_HANDLER_TYPE))
 103     {
 104         return_ACPI_STATUS (AE_BAD_PARAMETER);
 105     }
 106 
 107     Status = AcpiUtAcquireMutex (ACPI_MTX_NAMESPACE);
 108     if (ACPI_FAILURE (Status))
 109     {
 110         return_ACPI_STATUS (Status);
 111     }
 112 
 113     /*
 114      * Root Object:
 115      * Registering a notify handler on the root object indicates that the
 116      * caller wishes to receive notifications for all objects. Note that
 117      * only one global handler can be registered per notify type.
 118      * Ensure that a handler is not already installed.
 119      */
 120     if (Device == ACPI_ROOT_OBJECT)
 121     {
 122         for (i = 0; i < ACPI_NUM_NOTIFY_TYPES; i++)
 123         {
 124             if (HandlerType & (i+1))
 125             {
 126                 if (AcpiGbl_GlobalNotify[i].Handler)
 127                 {
 128                     Status = AE_ALREADY_EXISTS;
 129                     goto UnlockAndExit;
 130                 }
 131 
 132                 AcpiGbl_GlobalNotify[i].Handler = Handler;
 133                 AcpiGbl_GlobalNotify[i].Context = Context;
 134             }
 135         }
 136 
 137         goto UnlockAndExit; /* Global notify handler installed, all done */
 138     }
 139 
 140     /*
 141      * All Other Objects:
 142      * Caller will only receive notifications specific to the target
 143      * object. Note that only certain object types are allowed to
 144      * receive notifications.
 145      */
 146 
 147     /* Are Notifies allowed on this object? */
 148 
 149     if (!AcpiEvIsNotifyObject (Node))
 150     {
 151         Status = AE_TYPE;
 152         goto UnlockAndExit;
 153     }
 154 
 155     /* Check for an existing internal object, might not exist */
 156 
 157     ObjDesc = AcpiNsGetAttachedObject (Node);
 158     if (!ObjDesc)
 159     {
 160         /* Create a new object */
 161 
 162         ObjDesc = AcpiUtCreateInternalObject (Node->Type);
 163         if (!ObjDesc)
 164         {
 165             Status = AE_NO_MEMORY;
 166             goto UnlockAndExit;
 167         }
 168 
 169         /* Attach new object to the Node, remove local reference */
 170 
 171         Status = AcpiNsAttachObject (Device, ObjDesc, Node->Type);
 172         AcpiUtRemoveReference (ObjDesc);
 173         if (ACPI_FAILURE (Status))
 174         {
 175             goto UnlockAndExit;
 176         }
 177     }
 178 
 179     /* Ensure that the handler is not already installed in the lists */
 180 
 181     for (i = 0; i < ACPI_NUM_NOTIFY_TYPES; i++)
 182     {
 183         if (HandlerType & (i+1))
 184         {
 185             HandlerObj = ObjDesc->CommonNotify.NotifyList[i];
 186             while (HandlerObj)
 187             {
 188                 if (HandlerObj->Notify.Handler == Handler)
 189                 {
 190                     Status = AE_ALREADY_EXISTS;
 191                     goto UnlockAndExit;
 192                 }
 193 
 194                 HandlerObj = HandlerObj->Notify.Next[i];
 195             }
 196         }
 197     }
 198 
 199     /* Create and populate a new notify handler object */
 200 
 201     HandlerObj = AcpiUtCreateInternalObject (ACPI_TYPE_LOCAL_NOTIFY);
 202     if (!HandlerObj)
 203     {
 204         Status = AE_NO_MEMORY;
 205         goto UnlockAndExit;
 206     }
 207 
 208     HandlerObj->Notify.Node = Node;
 209     HandlerObj->Notify.HandlerType = HandlerType;
 210     HandlerObj->Notify.Handler = Handler;
 211     HandlerObj->Notify.Context = Context;
 212 
 213     /* Install the handler at the list head(s) */
 214 
 215     for (i = 0; i < ACPI_NUM_NOTIFY_TYPES; i++)
 216     {
 217         if (HandlerType & (i+1))
 218         {
 219             HandlerObj->Notify.Next[i] =
 220                 ObjDesc->CommonNotify.NotifyList[i];
 221 
 222             ObjDesc->CommonNotify.NotifyList[i] = HandlerObj;
 223         }
 224     }
 225 
 226     /* Add an extra reference if handler was installed in both lists */
 227 
 228     if (HandlerType == ACPI_ALL_NOTIFY)
 229     {
 230         AcpiUtAddReference (HandlerObj);
 231     }
 232 
 233 
 234 UnlockAndExit:
 235     (void) AcpiUtReleaseMutex (ACPI_MTX_NAMESPACE);
 236     return_ACPI_STATUS (Status);
 237 }
 238 
 239 ACPI_EXPORT_SYMBOL (AcpiInstallNotifyHandler)
 240 
 241 
 242 /*******************************************************************************
 243  *
 244  * FUNCTION:    AcpiRemoveNotifyHandler
 245  *
 246  * PARAMETERS:  Device          - The device for which the handler is installed
 247  *              HandlerType     - The type of handler:
 248  *                                  ACPI_SYSTEM_NOTIFY: System Handler (00-7F)
 249  *                                  ACPI_DEVICE_NOTIFY: Device Handler (80-FF)
 250  *                                  ACPI_ALL_NOTIFY:    Both System and Device
 251  *              Handler         - Address of the handler
 252  *
 253  * RETURN:      Status
 254  *
 255  * DESCRIPTION: Remove a handler for notifies on an ACPI device
 256  *
 257  ******************************************************************************/
 258 
 259 ACPI_STATUS
 260 AcpiRemoveNotifyHandler (
 261     ACPI_HANDLE             Device,
 262     UINT32                  HandlerType,
 263     ACPI_NOTIFY_HANDLER     Handler)
 264 {
 265     ACPI_NAMESPACE_NODE     *Node = ACPI_CAST_PTR (ACPI_NAMESPACE_NODE, Device);
 266     ACPI_OPERAND_OBJECT     *ObjDesc;
 267     ACPI_OPERAND_OBJECT     *HandlerObj;
 268     ACPI_OPERAND_OBJECT     *PreviousHandlerObj;
 269     ACPI_STATUS             Status;
 270     UINT32                  i;
 271 
 272 
 273     ACPI_FUNCTION_TRACE (AcpiRemoveNotifyHandler);
 274 
 275 
 276     /* Parameter validation */
 277 
 278     if ((!Device) || (!Handler) || (!HandlerType) ||
 279         (HandlerType > ACPI_MAX_NOTIFY_HANDLER_TYPE))
 280     {
 281         return_ACPI_STATUS (AE_BAD_PARAMETER);
 282     }
 283 
 284     /* Make sure all deferred notify tasks are completed */
 285 
 286     AcpiOsWaitEventsComplete ();
 287 
 288     Status = AcpiUtAcquireMutex (ACPI_MTX_NAMESPACE);
 289     if (ACPI_FAILURE (Status))
 290     {
 291         return_ACPI_STATUS (Status);
 292     }
 293 
 294     /* Root Object. Global handlers are removed here */
 295 
 296     if (Device == ACPI_ROOT_OBJECT)
 297     {
 298         for (i = 0; i < ACPI_NUM_NOTIFY_TYPES; i++)
 299         {
 300             if (HandlerType & (i+1))
 301             {
 302                 if (!AcpiGbl_GlobalNotify[i].Handler ||
 303                     (AcpiGbl_GlobalNotify[i].Handler != Handler))
 304                 {
 305                     Status = AE_NOT_EXIST;
 306                     goto UnlockAndExit;
 307                 }
 308 
 309                 ACPI_DEBUG_PRINT ((ACPI_DB_INFO,
 310                     "Removing global notify handler\n"));
 311 
 312                 AcpiGbl_GlobalNotify[i].Handler = NULL;
 313                 AcpiGbl_GlobalNotify[i].Context = NULL;
 314             }
 315         }
 316 
 317         goto UnlockAndExit;
 318     }
 319 
 320     /* All other objects: Are Notifies allowed on this object? */
 321 
 322     if (!AcpiEvIsNotifyObject (Node))
 323     {
 324         Status = AE_TYPE;
 325         goto UnlockAndExit;
 326     }
 327 
 328     /* Must have an existing internal object */
 329 
 330     ObjDesc = AcpiNsGetAttachedObject (Node);
 331     if (!ObjDesc)
 332     {
 333         Status = AE_NOT_EXIST;
 334         goto UnlockAndExit;
 335     }
 336 
 337     /* Internal object exists. Find the handler and remove it */
 338 
 339     for (i = 0; i < ACPI_NUM_NOTIFY_TYPES; i++)
 340     {
 341         if (HandlerType & (i+1))
 342         {
 343             HandlerObj = ObjDesc->CommonNotify.NotifyList[i];
 344             PreviousHandlerObj = NULL;
 345 
 346             /* Attempt to find the handler in the handler list */
 347 
 348             while (HandlerObj &&
 349                   (HandlerObj->Notify.Handler != Handler))
 350             {
 351                 PreviousHandlerObj = HandlerObj;
 352                 HandlerObj = HandlerObj->Notify.Next[i];
 353             }
 354 
 355             if (!HandlerObj)
 356             {
 357                 Status = AE_NOT_EXIST;
 358                 goto UnlockAndExit;
 359             }
 360 
 361             /* Remove the handler object from the list */
 362 
 363             if (PreviousHandlerObj) /* Handler is not at the list head */
 364             {
 365                 PreviousHandlerObj->Notify.Next[i] =
 366                     HandlerObj->Notify.Next[i];
 367             }
 368             else /* Handler is at the list head */
 369             {
 370                 ObjDesc->CommonNotify.NotifyList[i] =
 371                     HandlerObj->Notify.Next[i];
 372             }
 373 
 374             AcpiUtRemoveReference (HandlerObj);
 375         }
 376     }
 377 
 378 
 379 UnlockAndExit:
 380     (void) AcpiUtReleaseMutex (ACPI_MTX_NAMESPACE);
 381     return_ACPI_STATUS (Status);
 382 }
 383 
 384 ACPI_EXPORT_SYMBOL (AcpiRemoveNotifyHandler)
 385 
 386 
 387 /*******************************************************************************
 388  *
 389  * FUNCTION:    AcpiInstallExceptionHandler
 390  *
 391  * PARAMETERS:  Handler         - Pointer to the handler function for the
 392  *                                event
 393  *
 394  * RETURN:      Status
 395  *
 396  * DESCRIPTION: Saves the pointer to the handler function
 397  *
 398  ******************************************************************************/
 399 
 400 ACPI_STATUS
 401 AcpiInstallExceptionHandler (
 402     ACPI_EXCEPTION_HANDLER  Handler)
 403 {
 404     ACPI_STATUS             Status;
 405 
 406 
 407     ACPI_FUNCTION_TRACE (AcpiInstallExceptionHandler);
 408 
 409 
 410     Status = AcpiUtAcquireMutex (ACPI_MTX_EVENTS);
 411     if (ACPI_FAILURE (Status))
 412     {
 413         return_ACPI_STATUS (Status);
 414     }
 415 
 416     /* Don't allow two handlers. */
 417 
 418     if (AcpiGbl_ExceptionHandler)
 419     {
 420         Status = AE_ALREADY_EXISTS;
 421         goto Cleanup;
 422     }
 423 
 424     /* Install the handler */
 425 
 426     AcpiGbl_ExceptionHandler = Handler;
 427 
 428 Cleanup:
 429     (void) AcpiUtReleaseMutex (ACPI_MTX_EVENTS);
 430     return_ACPI_STATUS (Status);
 431 }
 432 
 433 ACPI_EXPORT_SYMBOL (AcpiInstallExceptionHandler)
 434 
 435 
 436 #if (!ACPI_REDUCED_HARDWARE)
 437 /*******************************************************************************
 438  *
 439  * FUNCTION:    AcpiInstallSciHandler
 440  *
 441  * PARAMETERS:  Address             - Address of the handler
 442  *              Context             - Value passed to the handler on each SCI
 443  *
 444  * RETURN:      Status
 445  *
 446  * DESCRIPTION: Install a handler for a System Control Interrupt.
 447  *
 448  ******************************************************************************/
 449 
 450 ACPI_STATUS
 451 AcpiInstallSciHandler (
 452     ACPI_SCI_HANDLER        Address,
 453     void                    *Context)
 454 {
 455     ACPI_SCI_HANDLER_INFO   *NewSciHandler;
 456     ACPI_SCI_HANDLER_INFO   *SciHandler;
 457     ACPI_CPU_FLAGS          Flags;
 458     ACPI_STATUS             Status;
 459 
 460 
 461     ACPI_FUNCTION_TRACE (AcpiInstallSciHandler);
 462 
 463 
 464     if (!Address)
 465     {
 466         return_ACPI_STATUS (AE_BAD_PARAMETER);
 467     }
 468 
 469     /* Allocate and init a handler object */
 470 
 471     NewSciHandler = ACPI_ALLOCATE (sizeof (ACPI_SCI_HANDLER_INFO));
 472     if (!NewSciHandler)
 473     {
 474         return_ACPI_STATUS (AE_NO_MEMORY);
 475     }
 476 
 477     NewSciHandler->Address = Address;
 478     NewSciHandler->Context = Context;
 479 
 480     Status = AcpiUtAcquireMutex (ACPI_MTX_EVENTS);
 481     if (ACPI_FAILURE (Status))
 482     {
 483         goto Exit;
 484     }
 485 
 486     /* Lock list during installation */
 487 
 488     Flags = AcpiOsAcquireLock (AcpiGbl_GpeLock);
 489     SciHandler = AcpiGbl_SciHandlerList;
 490 
 491     /* Ensure handler does not already exist */
 492 
 493     while (SciHandler)
 494     {
 495         if (Address == SciHandler->Address)
 496         {
 497             Status = AE_ALREADY_EXISTS;
 498             goto UnlockAndExit;
 499         }
 500 
 501         SciHandler = SciHandler->Next;
 502     }
 503 
 504     /* Install the new handler into the global list (at head) */
 505 
 506     NewSciHandler->Next = AcpiGbl_SciHandlerList;
 507     AcpiGbl_SciHandlerList = NewSciHandler;
 508 
 509 
 510 UnlockAndExit:
 511 
 512     AcpiOsReleaseLock (AcpiGbl_GpeLock, Flags);
 513     (void) AcpiUtReleaseMutex (ACPI_MTX_EVENTS);
 514 
 515 Exit:
 516     if (ACPI_FAILURE (Status))
 517     {
 518         ACPI_FREE (NewSciHandler);
 519     }
 520     return_ACPI_STATUS (Status);
 521 }
 522 
 523 
 524 /*******************************************************************************
 525  *
 526  * FUNCTION:    AcpiRemoveSciHandler
 527  *
 528  * PARAMETERS:  Address             - Address of the handler
 529  *
 530  * RETURN:      Status
 531  *
 532  * DESCRIPTION: Remove a handler for a System Control Interrupt.
 533  *
 534  ******************************************************************************/
 535 
 536 ACPI_STATUS
 537 AcpiRemoveSciHandler (
 538     ACPI_SCI_HANDLER        Address)
 539 {
 540     ACPI_SCI_HANDLER_INFO   *PrevSciHandler;
 541     ACPI_SCI_HANDLER_INFO   *NextSciHandler;
 542     ACPI_CPU_FLAGS          Flags;
 543     ACPI_STATUS             Status;
 544 
 545 
 546     ACPI_FUNCTION_TRACE (AcpiRemoveSciHandler);
 547 
 548 
 549     if (!Address)
 550     {
 551         return_ACPI_STATUS (AE_BAD_PARAMETER);
 552     }
 553 
 554     Status = AcpiUtAcquireMutex (ACPI_MTX_EVENTS);
 555     if (ACPI_FAILURE (Status))
 556     {
 557         return_ACPI_STATUS (Status);
 558     }
 559 
 560     /* Remove the SCI handler with lock */
 561 
 562     Flags = AcpiOsAcquireLock (AcpiGbl_GpeLock);
 563 
 564     PrevSciHandler = NULL;
 565     NextSciHandler = AcpiGbl_SciHandlerList;
 566     while (NextSciHandler)
 567     {
 568         if (NextSciHandler->Address == Address)
 569         {
 570             /* Unlink and free the SCI handler info block */
 571 
 572             if (PrevSciHandler)
 573             {
 574                 PrevSciHandler->Next = NextSciHandler->Next;
 575             }
 576             else
 577             {
 578                 AcpiGbl_SciHandlerList = NextSciHandler->Next;
 579             }
 580 
 581             AcpiOsReleaseLock (AcpiGbl_GpeLock, Flags);
 582             ACPI_FREE (NextSciHandler);
 583             goto UnlockAndExit;
 584         }
 585 
 586         PrevSciHandler = NextSciHandler;
 587         NextSciHandler = NextSciHandler->Next;
 588     }
 589 
 590     AcpiOsReleaseLock (AcpiGbl_GpeLock, Flags);
 591     Status = AE_NOT_EXIST;
 592 
 593 
 594 UnlockAndExit:
 595     (void) AcpiUtReleaseMutex (ACPI_MTX_EVENTS);
 596     return_ACPI_STATUS (Status);
 597 }
 598 
 599 
 600 /*******************************************************************************
 601  *
 602  * FUNCTION:    AcpiInstallGlobalEventHandler
 603  *
 604  * PARAMETERS:  Handler         - Pointer to the global event handler function
 605  *              Context         - Value passed to the handler on each event
 606  *
 607  * RETURN:      Status
 608  *
 609  * DESCRIPTION: Saves the pointer to the handler function. The global handler
 610  *              is invoked upon each incoming GPE and Fixed Event. It is
 611  *              invoked at interrupt level at the time of the event dispatch.
 612  *              Can be used to update event counters, etc.
 613  *
 614  ******************************************************************************/
 615 
 616 ACPI_STATUS
 617 AcpiInstallGlobalEventHandler (
 618     ACPI_GBL_EVENT_HANDLER  Handler,
 619     void                    *Context)
 620 {
 621     ACPI_STATUS             Status;
 622 
 623 
 624     ACPI_FUNCTION_TRACE (AcpiInstallGlobalEventHandler);
 625 
 626 
 627     /* Parameter validation */
 628 
 629     if (!Handler)
 630     {
 631         return_ACPI_STATUS (AE_BAD_PARAMETER);
 632     }
 633 
 634     Status = AcpiUtAcquireMutex (ACPI_MTX_EVENTS);
 635     if (ACPI_FAILURE (Status))
 636     {
 637         return_ACPI_STATUS (Status);
 638     }
 639 
 640     /* Don't allow two handlers. */
 641 
 642     if (AcpiGbl_GlobalEventHandler)
 643     {
 644         Status = AE_ALREADY_EXISTS;
 645         goto Cleanup;
 646     }
 647 
 648     AcpiGbl_GlobalEventHandler = Handler;
 649     AcpiGbl_GlobalEventHandlerContext = Context;
 650 
 651 
 652 Cleanup:
 653     (void) AcpiUtReleaseMutex (ACPI_MTX_EVENTS);
 654     return_ACPI_STATUS (Status);
 655 }
 656 
 657 ACPI_EXPORT_SYMBOL (AcpiInstallGlobalEventHandler)
 658 
 659 
 660 /*******************************************************************************
 661  *
 662  * FUNCTION:    AcpiInstallFixedEventHandler
 663  *
 664  * PARAMETERS:  Event           - Event type to enable.
 665  *              Handler         - Pointer to the handler function for the
 666  *                                event
 667  *              Context         - Value passed to the handler on each GPE
 668  *
 669  * RETURN:      Status
 670  *
 671  * DESCRIPTION: Saves the pointer to the handler function and then enables the
 672  *              event.
 673  *
 674  ******************************************************************************/
 675 
 676 ACPI_STATUS
 677 AcpiInstallFixedEventHandler (
 678     UINT32                  Event,
 679     ACPI_EVENT_HANDLER      Handler,
 680     void                    *Context)
 681 {
 682     ACPI_STATUS             Status;
 683 
 684 
 685     ACPI_FUNCTION_TRACE (AcpiInstallFixedEventHandler);
 686 
 687 
 688     /* Parameter validation */
 689 
 690     if (Event > ACPI_EVENT_MAX)
 691     {
 692         return_ACPI_STATUS (AE_BAD_PARAMETER);
 693     }
 694 
 695     Status = AcpiUtAcquireMutex (ACPI_MTX_EVENTS);
 696     if (ACPI_FAILURE (Status))
 697     {
 698         return_ACPI_STATUS (Status);
 699     }
 700 
 701     /* Do not allow multiple handlers */
 702 
 703     if (AcpiGbl_FixedEventHandlers[Event].Handler)
 704     {
 705         Status = AE_ALREADY_EXISTS;
 706         goto Cleanup;
 707     }
 708 
 709     /* Install the handler before enabling the event */
 710 
 711     AcpiGbl_FixedEventHandlers[Event].Handler = Handler;
 712     AcpiGbl_FixedEventHandlers[Event].Context = Context;
 713 
 714     Status = AcpiEnableEvent (Event, 0);
 715     if (ACPI_FAILURE (Status))
 716     {
 717         ACPI_WARNING ((AE_INFO,
 718             "Could not enable fixed event - %s (%u)",
 719             AcpiUtGetEventName (Event), Event));
 720 
 721         /* Remove the handler */
 722 
 723         AcpiGbl_FixedEventHandlers[Event].Handler = NULL;
 724         AcpiGbl_FixedEventHandlers[Event].Context = NULL;
 725     }
 726     else
 727     {
 728         ACPI_DEBUG_PRINT ((ACPI_DB_INFO,
 729             "Enabled fixed event %s (%X), Handler=%p\n",
 730             AcpiUtGetEventName (Event), Event, Handler));
 731     }
 732 
 733 
 734 Cleanup:
 735     (void) AcpiUtReleaseMutex (ACPI_MTX_EVENTS);
 736     return_ACPI_STATUS (Status);
 737 }
 738 
 739 ACPI_EXPORT_SYMBOL (AcpiInstallFixedEventHandler)
 740 
 741 
 742 /*******************************************************************************
 743  *
 744  * FUNCTION:    AcpiRemoveFixedEventHandler
 745  *
 746  * PARAMETERS:  Event           - Event type to disable.
 747  *              Handler         - Address of the handler
 748  *
 749  * RETURN:      Status
 750  *
 751  * DESCRIPTION: Disables the event and unregisters the event handler.
 752  *
 753  ******************************************************************************/
 754 
 755 ACPI_STATUS
 756 AcpiRemoveFixedEventHandler (
 757     UINT32                  Event,
 758     ACPI_EVENT_HANDLER      Handler)
 759 {
 760     ACPI_STATUS             Status = AE_OK;
 761 
 762 
 763     ACPI_FUNCTION_TRACE (AcpiRemoveFixedEventHandler);
 764 
 765 
 766     /* Parameter validation */
 767 
 768     if (Event > ACPI_EVENT_MAX)
 769     {
 770         return_ACPI_STATUS (AE_BAD_PARAMETER);
 771     }
 772 
 773     Status = AcpiUtAcquireMutex (ACPI_MTX_EVENTS);
 774     if (ACPI_FAILURE (Status))
 775     {
 776         return_ACPI_STATUS (Status);
 777     }
 778 
 779     /* Disable the event before removing the handler */
 780 
 781     Status = AcpiDisableEvent (Event, 0);
 782 
 783     /* Always Remove the handler */
 784 
 785     AcpiGbl_FixedEventHandlers[Event].Handler = NULL;
 786     AcpiGbl_FixedEventHandlers[Event].Context = NULL;
 787 
 788     if (ACPI_FAILURE (Status))
 789     {
 790         ACPI_WARNING ((AE_INFO,
 791             "Could not disable fixed event - %s (%u)",
 792             AcpiUtGetEventName (Event), Event));
 793     }
 794     else
 795     {
 796         ACPI_DEBUG_PRINT ((ACPI_DB_INFO,
 797             "Disabled fixed event - %s (%X)\n",
 798             AcpiUtGetEventName (Event), Event));
 799     }
 800 
 801     (void) AcpiUtReleaseMutex (ACPI_MTX_EVENTS);
 802     return_ACPI_STATUS (Status);
 803 }
 804 
 805 ACPI_EXPORT_SYMBOL (AcpiRemoveFixedEventHandler)
 806 
 807 
 808 /*******************************************************************************
 809  *
 810  * FUNCTION:    AcpiInstallGpeHandler
 811  *
 812  * PARAMETERS:  GpeDevice       - Namespace node for the GPE (NULL for FADT
 813  *                                defined GPEs)
 814  *              GpeNumber       - The GPE number within the GPE block
 815  *              Type            - Whether this GPE should be treated as an
 816  *                                edge- or level-triggered interrupt.
 817  *              Address         - Address of the handler
 818  *              Context         - Value passed to the handler on each GPE
 819  *
 820  * RETURN:      Status
 821  *
 822  * DESCRIPTION: Install a handler for a General Purpose Event.
 823  *
 824  ******************************************************************************/
 825 
 826 ACPI_STATUS
 827 AcpiInstallGpeHandler (
 828     ACPI_HANDLE             GpeDevice,
 829     UINT32                  GpeNumber,
 830     UINT32                  Type,
 831     ACPI_GPE_HANDLER        Address,
 832     void                    *Context)
 833 {
 834     ACPI_GPE_EVENT_INFO     *GpeEventInfo;
 835     ACPI_GPE_HANDLER_INFO   *Handler;
 836     ACPI_STATUS             Status;
 837     ACPI_CPU_FLAGS          Flags;
 838 
 839 
 840     ACPI_FUNCTION_TRACE (AcpiInstallGpeHandler);
 841 
 842 
 843     /* Parameter validation */
 844 
 845     if ((!Address) || (Type & ~ACPI_GPE_XRUPT_TYPE_MASK))
 846     {
 847         return_ACPI_STATUS (AE_BAD_PARAMETER);
 848     }
 849 
 850     Status = AcpiUtAcquireMutex (ACPI_MTX_EVENTS);
 851     if (ACPI_FAILURE (Status))
 852     {
 853         return_ACPI_STATUS (Status);
 854     }
 855 
 856     /* Allocate and init handler object (before lock) */
 857 
 858     Handler = ACPI_ALLOCATE_ZEROED (sizeof (ACPI_GPE_HANDLER_INFO));
 859     if (!Handler)
 860     {
 861         Status = AE_NO_MEMORY;
 862         goto UnlockAndExit;
 863     }
 864 
 865     Flags = AcpiOsAcquireLock (AcpiGbl_GpeLock);
 866 
 867     /* Ensure that we have a valid GPE number */
 868 
 869     GpeEventInfo = AcpiEvGetGpeEventInfo (GpeDevice, GpeNumber);
 870     if (!GpeEventInfo)
 871     {
 872         Status = AE_BAD_PARAMETER;
 873         goto FreeAndExit;
 874     }
 875 
 876     /* Make sure that there isn't a handler there already */
 877 
 878     if ((GpeEventInfo->Flags & ACPI_GPE_DISPATCH_MASK) ==
 879             ACPI_GPE_DISPATCH_HANDLER)
 880     {
 881         Status = AE_ALREADY_EXISTS;
 882         goto FreeAndExit;
 883     }
 884 
 885     Handler->Address = Address;
 886     Handler->Context = Context;
 887     Handler->MethodNode = GpeEventInfo->Dispatch.MethodNode;
 888     Handler->OriginalFlags = (UINT8) (GpeEventInfo->Flags &
 889         (ACPI_GPE_XRUPT_TYPE_MASK | ACPI_GPE_DISPATCH_MASK));
 890 
 891     /*
 892      * If the GPE is associated with a method, it may have been enabled
 893      * automatically during initialization, in which case it has to be
 894      * disabled now to avoid spurious execution of the handler.
 895      */
 896     if (((Handler->OriginalFlags & ACPI_GPE_DISPATCH_METHOD) ||
 897          (Handler->OriginalFlags & ACPI_GPE_DISPATCH_NOTIFY)) &&
 898         GpeEventInfo->RuntimeCount)
 899     {
 900         Handler->OriginallyEnabled = TRUE;
 901         (void) AcpiEvRemoveGpeReference (GpeEventInfo);
 902 
 903         /* Sanity check of original type against new type */
 904 
 905         if (Type != (UINT32) (GpeEventInfo->Flags & ACPI_GPE_XRUPT_TYPE_MASK))
 906         {
 907             ACPI_WARNING ((AE_INFO, "GPE type mismatch (level/edge)"));
 908         }
 909     }
 910 
 911     /* Install the handler */
 912 
 913     GpeEventInfo->Dispatch.Handler = Handler;
 914 
 915     /* Setup up dispatch flags to indicate handler (vs. method/notify) */
 916 
 917     GpeEventInfo->Flags &= ~(ACPI_GPE_XRUPT_TYPE_MASK | ACPI_GPE_DISPATCH_MASK);
 918     GpeEventInfo->Flags |= (UINT8) (Type | ACPI_GPE_DISPATCH_HANDLER);
 919 
 920     AcpiOsReleaseLock (AcpiGbl_GpeLock, Flags);
 921 
 922 
 923 UnlockAndExit:
 924     (void) AcpiUtReleaseMutex (ACPI_MTX_EVENTS);
 925     return_ACPI_STATUS (Status);
 926 
 927 FreeAndExit:
 928     AcpiOsReleaseLock (AcpiGbl_GpeLock, Flags);
 929     ACPI_FREE (Handler);
 930     goto UnlockAndExit;
 931 }
 932 
 933 ACPI_EXPORT_SYMBOL (AcpiInstallGpeHandler)
 934 
 935 
 936 /*******************************************************************************
 937  *
 938  * FUNCTION:    AcpiRemoveGpeHandler
 939  *
 940  * PARAMETERS:  GpeDevice       - Namespace node for the GPE (NULL for FADT
 941  *                                defined GPEs)
 942  *              GpeNumber       - The event to remove a handler
 943  *              Address         - Address of the handler
 944  *
 945  * RETURN:      Status
 946  *
 947  * DESCRIPTION: Remove a handler for a General Purpose AcpiEvent.
 948  *
 949  ******************************************************************************/
 950 
 951 ACPI_STATUS
 952 AcpiRemoveGpeHandler (
 953     ACPI_HANDLE             GpeDevice,
 954     UINT32                  GpeNumber,
 955     ACPI_GPE_HANDLER        Address)
 956 {
 957     ACPI_GPE_EVENT_INFO     *GpeEventInfo;
 958     ACPI_GPE_HANDLER_INFO   *Handler;
 959     ACPI_STATUS             Status;
 960     ACPI_CPU_FLAGS          Flags;
 961 
 962 
 963     ACPI_FUNCTION_TRACE (AcpiRemoveGpeHandler);
 964 
 965 
 966     /* Parameter validation */
 967 
 968     if (!Address)
 969     {
 970         return_ACPI_STATUS (AE_BAD_PARAMETER);
 971     }
 972 
 973     /* Make sure all deferred GPE tasks are completed */
 974 
 975     AcpiOsWaitEventsComplete ();
 976 
 977     Status = AcpiUtAcquireMutex (ACPI_MTX_EVENTS);
 978     if (ACPI_FAILURE (Status))
 979     {
 980         return_ACPI_STATUS (Status);
 981     }
 982 
 983     Flags = AcpiOsAcquireLock (AcpiGbl_GpeLock);
 984 
 985     /* Ensure that we have a valid GPE number */
 986 
 987     GpeEventInfo = AcpiEvGetGpeEventInfo (GpeDevice, GpeNumber);
 988     if (!GpeEventInfo)
 989     {
 990         Status = AE_BAD_PARAMETER;
 991         goto UnlockAndExit;
 992     }
 993 
 994     /* Make sure that a handler is indeed installed */
 995 
 996     if ((GpeEventInfo->Flags & ACPI_GPE_DISPATCH_MASK) !=
 997             ACPI_GPE_DISPATCH_HANDLER)
 998     {
 999         Status = AE_NOT_EXIST;
1000         goto UnlockAndExit;
1001     }
1002 
1003     /* Make sure that the installed handler is the same */
1004 
1005     if (GpeEventInfo->Dispatch.Handler->Address != Address)
1006     {
1007         Status = AE_BAD_PARAMETER;
1008         goto UnlockAndExit;
1009     }
1010 
1011     /* Remove the handler */
1012 
1013     Handler = GpeEventInfo->Dispatch.Handler;
1014 
1015     /* Restore Method node (if any), set dispatch flags */
1016 
1017     GpeEventInfo->Dispatch.MethodNode = Handler->MethodNode;
1018     GpeEventInfo->Flags &=
1019         ~(ACPI_GPE_XRUPT_TYPE_MASK | ACPI_GPE_DISPATCH_MASK);
1020     GpeEventInfo->Flags |= Handler->OriginalFlags;
1021 
1022     /*
1023      * If the GPE was previously associated with a method and it was
1024      * enabled, it should be enabled at this point to restore the
1025      * post-initialization configuration.
1026      */
1027     if ((Handler->OriginalFlags & ACPI_GPE_DISPATCH_METHOD) &&
1028         Handler->OriginallyEnabled)
1029     {
1030         (void) AcpiEvAddGpeReference (GpeEventInfo);
1031     }
1032 
1033     /* Now we can free the handler object */
1034 
1035     ACPI_FREE (Handler);
1036 
1037 
1038 UnlockAndExit:
1039     AcpiOsReleaseLock (AcpiGbl_GpeLock, Flags);
1040     (void) AcpiUtReleaseMutex (ACPI_MTX_EVENTS);
1041     return_ACPI_STATUS (Status);
1042 }
1043 
1044 ACPI_EXPORT_SYMBOL (AcpiRemoveGpeHandler)
1045 
1046 
1047 /*******************************************************************************
1048  *
1049  * FUNCTION:    AcpiAcquireGlobalLock
1050  *
1051  * PARAMETERS:  Timeout         - How long the caller is willing to wait
1052  *              Handle          - Where the handle to the lock is returned
1053  *                                (if acquired)
1054  *
1055  * RETURN:      Status
1056  *
1057  * DESCRIPTION: Acquire the ACPI Global Lock
1058  *
1059  * Note: Allows callers with the same thread ID to acquire the global lock
1060  * multiple times. In other words, externally, the behavior of the global lock
1061  * is identical to an AML mutex. On the first acquire, a new handle is
1062  * returned. On any subsequent calls to acquire by the same thread, the same
1063  * handle is returned.
1064  *
1065  ******************************************************************************/
1066 
1067 ACPI_STATUS
1068 AcpiAcquireGlobalLock (
1069     UINT16                  Timeout,
1070     UINT32                  *Handle)
1071 {
1072     ACPI_STATUS             Status;
1073 
1074 
1075     if (!Handle)
1076     {
1077         return (AE_BAD_PARAMETER);
1078     }
1079 
1080     /* Must lock interpreter to prevent race conditions */
1081 
1082     AcpiExEnterInterpreter ();
1083 
1084     Status = AcpiExAcquireMutexObject (Timeout,
1085                 AcpiGbl_GlobalLockMutex, AcpiOsGetThreadId ());
1086 
1087     if (ACPI_SUCCESS (Status))
1088     {
1089         /* Return the global lock handle (updated in AcpiEvAcquireGlobalLock) */
1090 
1091         *Handle = AcpiGbl_GlobalLockHandle;
1092     }
1093 
1094     AcpiExExitInterpreter ();
1095     return (Status);
1096 }
1097 
1098 ACPI_EXPORT_SYMBOL (AcpiAcquireGlobalLock)
1099 
1100 
1101 /*******************************************************************************
1102  *
1103  * FUNCTION:    AcpiReleaseGlobalLock
1104  *
1105  * PARAMETERS:  Handle      - Returned from AcpiAcquireGlobalLock
1106  *
1107  * RETURN:      Status
1108  *
1109  * DESCRIPTION: Release the ACPI Global Lock. The handle must be valid.
1110  *
1111  ******************************************************************************/
1112 
1113 ACPI_STATUS
1114 AcpiReleaseGlobalLock (
1115     UINT32                  Handle)
1116 {
1117     ACPI_STATUS             Status;
1118 
1119 
1120     if (!Handle || (Handle != AcpiGbl_GlobalLockHandle))
1121     {
1122         return (AE_NOT_ACQUIRED);
1123     }
1124 
1125     Status = AcpiExReleaseMutexObject (AcpiGbl_GlobalLockMutex);
1126     return (Status);
1127 }
1128 
1129 ACPI_EXPORT_SYMBOL (AcpiReleaseGlobalLock)
1130 
1131 #endif /* !ACPI_REDUCED_HARDWARE */