evmisc.c revision 193529
1219567Smarius/****************************************************************************** 2219567Smarius * 3146392Smarius * Module Name: evmisc - Miscellaneous event manager support functions 4146392Smarius * 5146392Smarius *****************************************************************************/ 6146392Smarius 7146392Smarius/****************************************************************************** 8146392Smarius * 9146392Smarius * 1. Copyright Notice 10146392Smarius * 11146392Smarius * Some or all of this work - Copyright (c) 1999 - 2009, Intel Corp. 12146392Smarius * All rights reserved. 13146392Smarius * 14146392Smarius * 2. License 15146392Smarius * 16146392Smarius * 2.1. This is your license from Intel Corp. under its intellectual property 17146392Smarius * rights. You may have additional license terms from the party that provided 18146392Smarius * you this software, covering your right to use that party's intellectual 19146392Smarius * property rights. 20146392Smarius * 21146392Smarius * 2.2. Intel grants, free of charge, to any person ("Licensee") obtaining a 22146392Smarius * copy of the source code appearing in this file ("Covered Code") an 23146392Smarius * irrevocable, perpetual, worldwide license under Intel's copyrights in the 24146392Smarius * base code distributed originally by Intel ("Original Intel Code") to copy, 25146392Smarius * make derivatives, distribute, use and display any portion of the Covered 26146392Smarius * Code in any form, with the right to sublicense such rights; and 27146392Smarius * 28146392Smarius * 2.3. Intel grants Licensee a non-exclusive and non-transferable patent 29146392Smarius * license (with the right to sublicense), under only those claims of Intel 30146392Smarius * patents that are infringed by the Original Intel Code, to make, use, sell, 31146392Smarius * offer to sell, and import the Covered Code and derivative works thereof 32146392Smarius * solely to the minimum extent necessary to exercise the above copyright 33146392Smarius * license, and in no event shall the patent license extend to any additions 34146392Smarius * to or modifications of the Original Intel Code. No other license or right 35146392Smarius * is granted directly or by implication, estoppel or otherwise; 36146392Smarius * 37146392Smarius * The above copyright and patent license is granted only if the following 38146392Smarius * conditions are met: 39146392Smarius * 40146392Smarius * 3. Conditions 41146392Smarius * 42146392Smarius * 3.1. Redistribution of Source with Rights to Further Distribute Source. 43146392Smarius * Redistribution of source code of any substantial portion of the Covered 44146392Smarius * Code or modification with rights to further distribute source must include 45146392Smarius * the above Copyright Notice, the above License, this list of Conditions, 46146392Smarius * and the following Disclaimer and Export Compliance provision. In addition, 47146392Smarius * Licensee must cause all Covered Code to which Licensee contributes to 48146392Smarius * contain a file documenting the changes Licensee made to create that Covered 49146392Smarius * Code and the date of any change. Licensee must include in that file the 50146392Smarius * documentation of any changes made by any predecessor Licensee. Licensee 51146392Smarius * must include a prominent statement that the modification is derived, 52146392Smarius * directly or indirectly, from Original Intel Code. 53146392Smarius * 54146392Smarius * 3.2. Redistribution of Source with no Rights to Further Distribute Source. 55146392Smarius * Redistribution of source code of any substantial portion of the Covered 56146392Smarius * Code or modification without rights to further distribute source must 57146392Smarius * include the following Disclaimer and Export Compliance provision in the 58146392Smarius * documentation and/or other materials provided with distribution. In 59146392Smarius * addition, Licensee may not authorize further sublicense of source of any 60146392Smarius * portion of the Covered Code, and must include terms to the effect that the 61146392Smarius * license from Licensee to its licensee is limited to the intellectual 62146392Smarius * property embodied in the software Licensee provides to its licensee, and 63146392Smarius * not to intellectual property embodied in modifications its licensee may 64146392Smarius * make. 65146392Smarius * 66146392Smarius * 3.3. Redistribution of Executable. Redistribution in executable form of any 67146392Smarius * substantial portion of the Covered Code or modification must reproduce the 68146392Smarius * above Copyright Notice, and the following Disclaimer and Export Compliance 69152684Smarius * provision in the documentation and/or other materials provided with the 70146392Smarius * distribution. 71146392Smarius * 72146392Smarius * 3.4. Intel retains all right, title, and interest in and to the Original 73146392Smarius * Intel Code. 74146392Smarius * 75146392Smarius * 3.5. Neither the name Intel nor any other trademark owned or controlled by 76146392Smarius * Intel shall be used in advertising or otherwise to promote the sale, use or 77146392Smarius * other dealings in products derived from or relating to the Covered Code 78146392Smarius * without prior written authorization from Intel. 79146392Smarius * 80146392Smarius * 4. Disclaimer and Export Compliance 81146392Smarius * 82146392Smarius * 4.1. INTEL MAKES NO WARRANTY OF ANY KIND REGARDING ANY SOFTWARE PROVIDED 83152684Smarius * HERE. ANY SOFTWARE ORIGINATING FROM INTEL OR DERIVED FROM INTEL SOFTWARE 84146392Smarius * IS PROVIDED "AS IS," AND INTEL WILL NOT PROVIDE ANY SUPPORT, ASSISTANCE, 85146392Smarius * INSTALLATION, TRAINING OR OTHER SERVICES. INTEL WILL NOT PROVIDE ANY 86146392Smarius * UPDATES, ENHANCEMENTS OR EXTENSIONS. INTEL SPECIFICALLY DISCLAIMS ANY 87146392Smarius * IMPLIED WARRANTIES OF MERCHANTABILITY, NONINFRINGEMENT AND FITNESS FOR A 88146392Smarius * PARTICULAR PURPOSE. 89146392Smarius * 90146392Smarius * 4.2. IN NO EVENT SHALL INTEL HAVE ANY LIABILITY TO LICENSEE, ITS LICENSEES 91146392Smarius * OR ANY OTHER THIRD PARTY, FOR ANY LOST PROFITS, LOST DATA, LOSS OF USE OR 92146392Smarius * COSTS OF PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES, OR FOR ANY INDIRECT, 93146392Smarius * SPECIAL OR CONSEQUENTIAL DAMAGES ARISING OUT OF THIS AGREEMENT, UNDER ANY 94146392Smarius * CAUSE OF ACTION OR THEORY OF LIABILITY, AND IRRESPECTIVE OF WHETHER INTEL 95146392Smarius * HAS ADVANCE NOTICE OF THE POSSIBILITY OF SUCH DAMAGES. THESE LIMITATIONS 96146392Smarius * SHALL APPLY NOTWITHSTANDING THE FAILURE OF THE ESSENTIAL PURPOSE OF ANY 97146392Smarius * LIMITED REMEDY. 98146392Smarius * 99146392Smarius * 4.3. Licensee shall not export, either directly or indirectly, any of this 100152684Smarius * software or system incorporating such software without first obtaining any 101146392Smarius * required license or other approval from the U. S. Department of Commerce or 102152684Smarius * any other agency or department of the United States Government. In the 103152684Smarius * event Licensee exports any such software from the United States or 104146392Smarius * re-exports any such software from a foreign destination, Licensee shall 105152684Smarius * ensure that the distribution and export/re-export of the software is in 106146392Smarius * compliance with all laws, regulations, orders, or other restrictions of the 107146392Smarius * U.S. Export Administration Regulations. Licensee agrees that neither it nor 108166147Smarius * any of its subsidiaries will export/re-export any technical data, process, 109146392Smarius * software, or service, directly or indirectly, to any country for which the 110146392Smarius * United States government or any agency thereof requires an export license, 111154870Smarius * other governmental approval, or letter of assurance, without first obtaining 112154870Smarius * such license, approval or letter. 113154870Smarius * 114146392Smarius *****************************************************************************/ 115146392Smarius 116146392Smarius#include <contrib/dev/acpica/include/acpi.h> 117146392Smarius#include <contrib/dev/acpica/include/accommon.h> 118146392Smarius#include <contrib/dev/acpica/include/acevents.h> 119146392Smarius#include <contrib/dev/acpica/include/acnamesp.h> 120146392Smarius#include <contrib/dev/acpica/include/acinterp.h> 121225931Smarius 122190099Smarius#define _COMPONENT ACPI_EVENTS 123190099Smarius ACPI_MODULE_NAME ("evmisc") 124190099Smarius 125190099Smarius 126146392Smarius/* Local prototypes */ 127190114Smarius 128146392Smariusstatic void ACPI_SYSTEM_XFACE 129146392SmariusAcpiEvNotifyDispatch ( 130152684Smarius void *Context); 131152684Smarius 132152684Smariusstatic UINT32 133152684SmariusAcpiEvGlobalLockHandler ( 134152684Smarius void *Context); 135152684Smarius 136146392Smariusstatic ACPI_STATUS 137227848SmariusAcpiEvRemoveGlobalLockHandler ( 138146392Smarius void); 139146392Smarius 140146392Smarius 141146392Smarius/******************************************************************************* 142146392Smarius * 143146392Smarius * FUNCTION: AcpiEvIsNotifyObject 144146392Smarius * 145146392Smarius * PARAMETERS: Node - Node to check 146200874Smarius * 147200874Smarius * RETURN: TRUE if notifies allowed on this object 148200874Smarius * 149200874Smarius * DESCRIPTION: Check type of node for a object that supports notifies. 150200874Smarius * 151200874Smarius * TBD: This could be replaced by a flag bit in the node. 152200874Smarius * 153182062Smarius ******************************************************************************/ 154182062Smarius 155146392SmariusBOOLEAN 156146392SmariusAcpiEvIsNotifyObject ( 157146392Smarius ACPI_NAMESPACE_NODE *Node) 158146392Smarius{ 159146392Smarius switch (Node->Type) 160146392Smarius { 161146392Smarius case ACPI_TYPE_DEVICE: 162146392Smarius case ACPI_TYPE_PROCESSOR: 163146392Smarius case ACPI_TYPE_THERMAL: 164166147Smarius /* 165166147Smarius * These are the ONLY objects that can receive ACPI notifications 166146392Smarius */ 167166147Smarius return (TRUE); 168146392Smarius 169146392Smarius default: 170146392Smarius return (FALSE); 171146392Smarius } 172146392Smarius} 173146392Smarius 174146392Smarius 175146392Smarius/******************************************************************************* 176146392Smarius * 177146392Smarius * FUNCTION: AcpiEvQueueNotifyRequest 178152684Smarius * 179146392Smarius * PARAMETERS: Node - NS node for the notified object 180146392Smarius * NotifyValue - Value from the Notify() request 181182876Smarius * 182146392Smarius * RETURN: Status 183146392Smarius * 184146392Smarius * DESCRIPTION: Dispatch a device notification event to a previously 185146392Smarius * installed handler. 186146392Smarius * 187146392Smarius ******************************************************************************/ 188146392Smarius 189146392SmariusACPI_STATUS 190146392SmariusAcpiEvQueueNotifyRequest ( 191182876Smarius ACPI_NAMESPACE_NODE *Node, 192182876Smarius UINT32 NotifyValue) 193146392Smarius{ 194146392Smarius ACPI_OPERAND_OBJECT *ObjDesc; 195146392Smarius ACPI_OPERAND_OBJECT *HandlerObj = NULL; 196146392Smarius ACPI_GENERIC_STATE *NotifyInfo; 197146392Smarius ACPI_STATUS Status = AE_OK; 198146392Smarius 199146392Smarius 200146392Smarius ACPI_FUNCTION_NAME (EvQueueNotifyRequest); 201146392Smarius 202146392Smarius 203146392Smarius /* 204146392Smarius * For value 3 (Ejection Request), some device method may need to be run. 205146392Smarius * For value 2 (Device Wake) if _PRW exists, the _PS0 method may need 206146392Smarius * to be run. 207146392Smarius * For value 0x80 (Status Change) on the power button or sleep button, 208146392Smarius * initiate soft-off or sleep operation? 209146392Smarius */ 210146392Smarius ACPI_DEBUG_PRINT ((ACPI_DB_INFO, 211146392Smarius "Dispatching Notify on [%4.4s] Node %p Value 0x%2.2X (%s)\n", 212146392Smarius AcpiUtGetNodeName (Node), Node, NotifyValue, 213146392Smarius AcpiUtGetNotifyName (NotifyValue))); 214146392Smarius 215146392Smarius /* Get the notify object attached to the NS Node */ 216146392Smarius 217146392Smarius ObjDesc = AcpiNsGetAttachedObject (Node); 218146392Smarius if (ObjDesc) 219146392Smarius { 220146392Smarius /* We have the notify object, Get the right handler */ 221146392Smarius 222146392Smarius switch (Node->Type) 223146392Smarius { 224146392Smarius /* Notify allowed only on these types */ 225146392Smarius 226146392Smarius case ACPI_TYPE_DEVICE: 227146392Smarius case ACPI_TYPE_THERMAL: 228146392Smarius case ACPI_TYPE_PROCESSOR: 229146392Smarius 230146392Smarius if (NotifyValue <= ACPI_MAX_SYS_NOTIFY) 231166147Smarius { 232166147Smarius HandlerObj = ObjDesc->CommonNotify.SystemNotify; 233146392Smarius } 234146392Smarius else 235146392Smarius { 236226948Smarius HandlerObj = ObjDesc->CommonNotify.DeviceNotify; 237226948Smarius } 238226948Smarius break; 239146392Smarius 240146392Smarius default: 241146392Smarius 242146392Smarius /* All other types are not supported */ 243146392Smarius 244146392Smarius return (AE_TYPE); 245146392Smarius } 246146392Smarius } 247182876Smarius 248182876Smarius /* 249182876Smarius * If there is any handler to run, schedule the dispatcher. 250146392Smarius * Check for: 251146392Smarius * 1) Global system notify handler 252146392Smarius * 2) Global device notify handler 253182876Smarius * 3) Per-device notify handler 254146392Smarius */ 255152684Smarius if ((AcpiGbl_SystemNotify.Handler && 256146392Smarius (NotifyValue <= ACPI_MAX_SYS_NOTIFY)) || 257182876Smarius (AcpiGbl_DeviceNotify.Handler && 258152684Smarius (NotifyValue > ACPI_MAX_SYS_NOTIFY)) || 259152684Smarius HandlerObj) 260152684Smarius { 261146392Smarius NotifyInfo = AcpiUtCreateGenericState (); 262146392Smarius if (!NotifyInfo) 263146392Smarius { 264146392Smarius return (AE_NO_MEMORY); 265146392Smarius } 266152684Smarius 267146392Smarius if (!HandlerObj) 268146392Smarius { 269146392Smarius ACPI_DEBUG_PRINT ((ACPI_DB_INFO, 270146392Smarius "Executing system notify handler for Notify (%4.4s, %X) " 271182876Smarius "node %p\n", 272146392Smarius AcpiUtGetNodeName (Node), NotifyValue, Node)); 273152684Smarius } 274146392Smarius 275146392Smarius NotifyInfo->Common.DescriptorType = ACPI_DESC_TYPE_STATE_NOTIFY; 276182876Smarius NotifyInfo->Notify.Node = Node; 277182876Smarius NotifyInfo->Notify.Value = (UINT16) NotifyValue; 278146392Smarius NotifyInfo->Notify.HandlerObj = HandlerObj; 279146392Smarius 280146392Smarius Status = AcpiOsExecute ( 281146392Smarius OSL_NOTIFY_HANDLER, AcpiEvNotifyDispatch, NotifyInfo); 282152684Smarius if (ACPI_FAILURE (Status)) 283146392Smarius { 284146392Smarius AcpiUtDeleteGenericState (NotifyInfo); 285146392Smarius } 286146392Smarius } 287146392Smarius else 288146392Smarius { 289146392Smarius /* There is no notify handler (per-device or system) for this device */ 290152684Smarius 291152684Smarius ACPI_DEBUG_PRINT ((ACPI_DB_INFO, 292146392Smarius "No notify handler for Notify (%4.4s, %X) node %p\n", 293152684Smarius AcpiUtGetNodeName (Node), NotifyValue, Node)); 294146392Smarius } 295146392Smarius 296146392Smarius return (Status); 297146392Smarius} 298152684Smarius 299152684Smarius 300152684Smarius/******************************************************************************* 301146392Smarius * 302146392Smarius * FUNCTION: AcpiEvNotifyDispatch 303146392Smarius * 304146392Smarius * PARAMETERS: Context - To be passed to the notify handler 305146392Smarius * 306146392Smarius * RETURN: None. 307146392Smarius * 308146392Smarius * DESCRIPTION: Dispatch a device notification event to a previously 309146392Smarius * installed handler. 310152684Smarius * 311152684Smarius ******************************************************************************/ 312146392Smarius 313152684Smariusstatic void ACPI_SYSTEM_XFACE 314146392SmariusAcpiEvNotifyDispatch ( 315146392Smarius void *Context) 316146392Smarius{ 317146392Smarius ACPI_GENERIC_STATE *NotifyInfo = (ACPI_GENERIC_STATE *) Context; 318146392Smarius ACPI_NOTIFY_HANDLER GlobalHandler = NULL; 319146392Smarius void *GlobalContext = NULL; 320146392Smarius ACPI_OPERAND_OBJECT *HandlerObj; 321146392Smarius 322146392Smarius 323152684Smarius ACPI_FUNCTION_ENTRY (); 324152684Smarius 325146392Smarius 326146392Smarius /* 327146392Smarius * We will invoke a global notify handler if installed. This is done 328146392Smarius * _before_ we invoke the per-device handler attached to the device. 329146392Smarius */ 330146392Smarius if (NotifyInfo->Notify.Value <= ACPI_MAX_SYS_NOTIFY) 331146392Smarius { 332146392Smarius /* Global system notification handler */ 333146392Smarius 334146392Smarius if (AcpiGbl_SystemNotify.Handler) 335146392Smarius { 336146392Smarius GlobalHandler = AcpiGbl_SystemNotify.Handler; 337146392Smarius GlobalContext = AcpiGbl_SystemNotify.Context; 338146392Smarius } 339146392Smarius } 340146392Smarius else 341146392Smarius { 342146392Smarius /* Global driver notification handler */ 343146392Smarius 344146392Smarius if (AcpiGbl_DeviceNotify.Handler) 345146392Smarius { 346146392Smarius GlobalHandler = AcpiGbl_DeviceNotify.Handler; 347146392Smarius GlobalContext = AcpiGbl_DeviceNotify.Context; 348146392Smarius } 349152684Smarius } 350152684Smarius 351152684Smarius /* Invoke the system handler first, if present */ 352152684Smarius 353146392Smarius if (GlobalHandler) 354146392Smarius { 355146392Smarius GlobalHandler (NotifyInfo->Notify.Node, NotifyInfo->Notify.Value, 356146392Smarius GlobalContext); 357146392Smarius } 358146392Smarius 359146392Smarius /* Now invoke the per-device handler, if present */ 360152684Smarius 361146392Smarius HandlerObj = NotifyInfo->Notify.HandlerObj; 362146392Smarius if (HandlerObj) 363146392Smarius { 364146392Smarius HandlerObj->Notify.Handler (NotifyInfo->Notify.Node, 365146392Smarius NotifyInfo->Notify.Value, 366146392Smarius HandlerObj->Notify.Context); 367146392Smarius } 368146392Smarius 369146392Smarius /* All done with the info object */ 370152684Smarius 371146392Smarius AcpiUtDeleteGenericState (NotifyInfo); 372146392Smarius} 373146392Smarius 374146392Smarius 375146392Smarius/******************************************************************************* 376146392Smarius * 377146392Smarius * FUNCTION: AcpiEvGlobalLockHandler 378152684Smarius * 379146392Smarius * PARAMETERS: Context - From thread interface, not used 380152684Smarius * 381152684Smarius * RETURN: ACPI_INTERRUPT_HANDLED 382152684Smarius * 383152684Smarius * DESCRIPTION: Invoked directly from the SCI handler when a global lock 384152684Smarius * release interrupt occurs. Attempt to acquire the global lock, 385146392Smarius * if successful, signal the thread waiting for the lock. 386146392Smarius * 387146392Smarius * NOTE: Assumes that the semaphore can be signaled from interrupt level. If 388146392Smarius * this is not possible for some reason, a separate thread will have to be 389146392Smarius * scheduled to do this. 390146392Smarius * 391146392Smarius ******************************************************************************/ 392146392Smarius 393146392Smariusstatic UINT32 394146392SmariusAcpiEvGlobalLockHandler ( 395146392Smarius void *Context) 396152684Smarius{ 397152684Smarius BOOLEAN Acquired = FALSE; 398146392Smarius ACPI_STATUS Status; 399152684Smarius 400146392Smarius 401152684Smarius /* 402152684Smarius * Attempt to get the lock. 403146392Smarius * 404146392Smarius * If we don't get it now, it will be marked pending and we will 405152684Smarius * take another interrupt when it becomes free. 406152684Smarius */ 407146392Smarius ACPI_ACQUIRE_GLOBAL_LOCK (AcpiGbl_FACS, Acquired); 408152684Smarius if (Acquired) 409146392Smarius { 410152684Smarius /* Got the lock, now wake the thread waiting for it */ 411152684Smarius 412152684Smarius AcpiGbl_GlobalLockAcquired = TRUE; 413152684Smarius 414152684Smarius /* Send a unit to the semaphore */ 415146392Smarius 416 Status = AcpiOsSignalSemaphore (AcpiGbl_GlobalLockSemaphore, 1); 417 if (ACPI_FAILURE (Status)) 418 { 419 ACPI_ERROR ((AE_INFO, "Could not signal Global Lock semaphore")); 420 } 421 } 422 423 return (ACPI_INTERRUPT_HANDLED); 424} 425 426 427/******************************************************************************* 428 * 429 * FUNCTION: AcpiEvInitGlobalLockHandler 430 * 431 * PARAMETERS: None 432 * 433 * RETURN: Status 434 * 435 * DESCRIPTION: Install a handler for the global lock release event 436 * 437 ******************************************************************************/ 438 439ACPI_STATUS 440AcpiEvInitGlobalLockHandler ( 441 void) 442{ 443 ACPI_STATUS Status; 444 445 446 ACPI_FUNCTION_TRACE (EvInitGlobalLockHandler); 447 448 449 /* Attempt installation of the global lock handler */ 450 451 Status = AcpiInstallFixedEventHandler (ACPI_EVENT_GLOBAL, 452 AcpiEvGlobalLockHandler, NULL); 453 454 /* 455 * If the global lock does not exist on this platform, the attempt to 456 * enable GBL_STATUS will fail (the GBL_ENABLE bit will not stick). 457 * Map to AE_OK, but mark global lock as not present. Any attempt to 458 * actually use the global lock will be flagged with an error. 459 */ 460 if (Status == AE_NO_HARDWARE_RESPONSE) 461 { 462 ACPI_ERROR ((AE_INFO, 463 "No response from Global Lock hardware, disabling lock")); 464 465 AcpiGbl_GlobalLockPresent = FALSE; 466 return_ACPI_STATUS (AE_OK); 467 } 468 469 AcpiGbl_GlobalLockPresent = TRUE; 470 return_ACPI_STATUS (Status); 471} 472 473 474/******************************************************************************* 475 * 476 * FUNCTION: AcpiEvRemoveGlobalLockHandler 477 * 478 * PARAMETERS: None 479 * 480 * RETURN: Status 481 * 482 * DESCRIPTION: Remove the handler for the Global Lock 483 * 484 ******************************************************************************/ 485 486static ACPI_STATUS 487AcpiEvRemoveGlobalLockHandler ( 488 void) 489{ 490 ACPI_STATUS Status; 491 492 493 ACPI_FUNCTION_TRACE (EvRemoveGlobalLockHandler); 494 495 AcpiGbl_GlobalLockPresent = FALSE; 496 Status = AcpiRemoveFixedEventHandler (ACPI_EVENT_GLOBAL, 497 AcpiEvGlobalLockHandler); 498 499 return_ACPI_STATUS (Status); 500} 501 502 503/****************************************************************************** 504 * 505 * FUNCTION: AcpiEvAcquireGlobalLock 506 * 507 * PARAMETERS: Timeout - Max time to wait for the lock, in millisec. 508 * 509 * RETURN: Status 510 * 511 * DESCRIPTION: Attempt to gain ownership of the Global Lock. 512 * 513 * MUTEX: Interpreter must be locked 514 * 515 * Note: The original implementation allowed multiple threads to "acquire" the 516 * Global Lock, and the OS would hold the lock until the last thread had 517 * released it. However, this could potentially starve the BIOS out of the 518 * lock, especially in the case where there is a tight handshake between the 519 * Embedded Controller driver and the BIOS. Therefore, this implementation 520 * allows only one thread to acquire the HW Global Lock at a time, and makes 521 * the global lock appear as a standard mutex on the OS side. 522 * 523 *****************************************************************************/ 524 525ACPI_STATUS 526AcpiEvAcquireGlobalLock ( 527 UINT16 Timeout) 528{ 529 ACPI_STATUS Status = AE_OK; 530 BOOLEAN Acquired = FALSE; 531 532 533 ACPI_FUNCTION_TRACE (EvAcquireGlobalLock); 534 535 536 /* 537 * Only one thread can acquire the GL at a time, the GlobalLockMutex 538 * enforces this. This interface releases the interpreter if we must wait. 539 */ 540 Status = AcpiExSystemWaitMutex (AcpiGbl_GlobalLockMutex->Mutex.OsMutex, 541 Timeout); 542 if (ACPI_FAILURE (Status)) 543 { 544 return_ACPI_STATUS (Status); 545 } 546 547 /* 548 * Update the global lock handle and check for wraparound. The handle is 549 * only used for the external global lock interfaces, but it is updated 550 * here to properly handle the case where a single thread may acquire the 551 * lock via both the AML and the AcpiAcquireGlobalLock interfaces. The 552 * handle is therefore updated on the first acquire from a given thread 553 * regardless of where the acquisition request originated. 554 */ 555 AcpiGbl_GlobalLockHandle++; 556 if (AcpiGbl_GlobalLockHandle == 0) 557 { 558 AcpiGbl_GlobalLockHandle = 1; 559 } 560 561 /* 562 * Make sure that a global lock actually exists. If not, just treat the 563 * lock as a standard mutex. 564 */ 565 if (!AcpiGbl_GlobalLockPresent) 566 { 567 AcpiGbl_GlobalLockAcquired = TRUE; 568 return_ACPI_STATUS (AE_OK); 569 } 570 571 /* Attempt to acquire the actual hardware lock */ 572 573 ACPI_ACQUIRE_GLOBAL_LOCK (AcpiGbl_FACS, Acquired); 574 if (Acquired) 575 { 576 /* We got the lock */ 577 578 ACPI_DEBUG_PRINT ((ACPI_DB_EXEC, "Acquired hardware Global Lock\n")); 579 580 AcpiGbl_GlobalLockAcquired = TRUE; 581 return_ACPI_STATUS (AE_OK); 582 } 583 584 /* 585 * Did not get the lock. The pending bit was set above, and we must now 586 * wait until we get the global lock released interrupt. 587 */ 588 ACPI_DEBUG_PRINT ((ACPI_DB_EXEC, "Waiting for hardware Global Lock\n")); 589 590 /* 591 * Wait for handshake with the global lock interrupt handler. 592 * This interface releases the interpreter if we must wait. 593 */ 594 Status = AcpiExSystemWaitSemaphore (AcpiGbl_GlobalLockSemaphore, 595 ACPI_WAIT_FOREVER); 596 597 return_ACPI_STATUS (Status); 598} 599 600 601/******************************************************************************* 602 * 603 * FUNCTION: AcpiEvReleaseGlobalLock 604 * 605 * PARAMETERS: None 606 * 607 * RETURN: Status 608 * 609 * DESCRIPTION: Releases ownership of the Global Lock. 610 * 611 ******************************************************************************/ 612 613ACPI_STATUS 614AcpiEvReleaseGlobalLock ( 615 void) 616{ 617 BOOLEAN Pending = FALSE; 618 ACPI_STATUS Status = AE_OK; 619 620 621 ACPI_FUNCTION_TRACE (EvReleaseGlobalLock); 622 623 624 /* Lock must be already acquired */ 625 626 if (!AcpiGbl_GlobalLockAcquired) 627 { 628 ACPI_WARNING ((AE_INFO, 629 "Cannot release the ACPI Global Lock, it has not been acquired")); 630 return_ACPI_STATUS (AE_NOT_ACQUIRED); 631 } 632 633 if (AcpiGbl_GlobalLockPresent) 634 { 635 /* Allow any thread to release the lock */ 636 637 ACPI_RELEASE_GLOBAL_LOCK (AcpiGbl_FACS, Pending); 638 639 /* 640 * If the pending bit was set, we must write GBL_RLS to the control 641 * register 642 */ 643 if (Pending) 644 { 645 Status = AcpiWriteBitRegister ( 646 ACPI_BITREG_GLOBAL_LOCK_RELEASE, ACPI_ENABLE_EVENT); 647 } 648 649 ACPI_DEBUG_PRINT ((ACPI_DB_EXEC, "Released hardware Global Lock\n")); 650 } 651 652 AcpiGbl_GlobalLockAcquired = FALSE; 653 654 /* Release the local GL mutex */ 655 656 AcpiOsReleaseMutex (AcpiGbl_GlobalLockMutex->Mutex.OsMutex); 657 return_ACPI_STATUS (Status); 658} 659 660 661/****************************************************************************** 662 * 663 * FUNCTION: AcpiEvTerminate 664 * 665 * PARAMETERS: none 666 * 667 * RETURN: none 668 * 669 * DESCRIPTION: Disable events and free memory allocated for table storage. 670 * 671 ******************************************************************************/ 672 673void 674AcpiEvTerminate ( 675 void) 676{ 677 UINT32 i; 678 ACPI_STATUS Status; 679 680 681 ACPI_FUNCTION_TRACE (EvTerminate); 682 683 684 if (AcpiGbl_EventsInitialized) 685 { 686 /* 687 * Disable all event-related functionality. In all cases, on error, 688 * print a message but obviously we don't abort. 689 */ 690 691 /* Disable all fixed events */ 692 693 for (i = 0; i < ACPI_NUM_FIXED_EVENTS; i++) 694 { 695 Status = AcpiDisableEvent (i, 0); 696 if (ACPI_FAILURE (Status)) 697 { 698 ACPI_ERROR ((AE_INFO, 699 "Could not disable fixed event %d", (UINT32) i)); 700 } 701 } 702 703 /* Disable all GPEs in all GPE blocks */ 704 705 Status = AcpiEvWalkGpeList (AcpiHwDisableGpeBlock, NULL); 706 707 /* Remove SCI handler */ 708 709 Status = AcpiEvRemoveSciHandler (); 710 if (ACPI_FAILURE(Status)) 711 { 712 ACPI_ERROR ((AE_INFO, 713 "Could not remove SCI handler")); 714 } 715 716 Status = AcpiEvRemoveGlobalLockHandler (); 717 if (ACPI_FAILURE(Status)) 718 { 719 ACPI_ERROR ((AE_INFO, 720 "Could not remove Global Lock handler")); 721 } 722 } 723 724 /* Deallocate all handler objects installed within GPE info structs */ 725 726 Status = AcpiEvWalkGpeList (AcpiEvDeleteGpeHandlers, NULL); 727 728 /* Return to original mode if necessary */ 729 730 if (AcpiGbl_OriginalMode == ACPI_SYS_MODE_LEGACY) 731 { 732 Status = AcpiDisable (); 733 if (ACPI_FAILURE (Status)) 734 { 735 ACPI_WARNING ((AE_INFO, "AcpiDisable failed")); 736 } 737 } 738 return_VOID; 739} 740 741