static u32 acpi_ev_global_lock_handler(void *context) { u8 acquired = FALSE; /* * Attempt to get the lock. * * If we don't get it now, it will be marked pending and we will * take another interrupt when it becomes free. */ ACPI_ACQUIRE_GLOBAL_LOCK(acpi_gbl_FACS, acquired); if (acquired) { /* Got the lock, now wake all threads waiting for it */ acpi_gbl_global_lock_acquired = TRUE; /* Send a unit to the semaphore */ if (ACPI_FAILURE (acpi_os_signal_semaphore (acpi_gbl_global_lock_semaphore, 1))) { ACPI_ERROR((AE_INFO, "Could not signal Global Lock semaphore")); } } return (ACPI_INTERRUPT_HANDLED); }
static u32 acpi_ev_global_lock_handler ( void *context) { u8 acquired = FALSE; acpi_status status; /* * Attempt to get the lock * If we don't get it now, it will be marked pending and we will * take another interrupt when it becomes free. */ ACPI_ACQUIRE_GLOBAL_LOCK (acpi_gbl_common_fACS.global_lock, acquired); if (acquired) { /* Got the lock, now wake all threads waiting for it */ acpi_gbl_global_lock_acquired = TRUE; /* Run the Global Lock thread which will signal all waiting threads */ status = acpi_os_queue_for_execution (OSD_PRIORITY_HIGH, acpi_ev_global_lock_thread, context); if (ACPI_FAILURE (status)) { ACPI_REPORT_ERROR (("Could not queue Global Lock thread, %s\n", acpi_format_exception (status))); return (ACPI_INTERRUPT_NOT_HANDLED); } } return (ACPI_INTERRUPT_HANDLED); }
static u32 acpi_ev_global_lock_handler(void *context) { u8 acquired = FALSE; acpi_status status; /* * Attempt to get the lock * If we don't get it now, it will be marked pending and we will * take another interrupt when it becomes free. */ ACPI_ACQUIRE_GLOBAL_LOCK(acpi_gbl_common_fACS.global_lock, acquired); if (acquired) { /* Got the lock, now wake all threads waiting for it */ acpi_gbl_global_lock_acquired = TRUE; /* Run the Global Lock thread which will signal all waiting threads */ status = acpi_os_execute(OSL_GLOBAL_LOCK_HANDLER, acpi_ev_global_lock_thread, context); if (ACPI_FAILURE(status)) { ACPI_EXCEPTION((AE_INFO, status, "Could not queue Global Lock thread")); return (ACPI_INTERRUPT_NOT_HANDLED); } } return (ACPI_INTERRUPT_HANDLED); }
static UINT32 AcpiEvGlobalLockHandler ( void *Context) { BOOLEAN Acquired = FALSE; ACPI_STATUS Status; /* * Attempt to get the lock. * * If we don't get it now, it will be marked pending and we will * take another interrupt when it becomes free. */ ACPI_ACQUIRE_GLOBAL_LOCK (Facs, Acquired); if (Acquired) { /* Got the lock, now wake the thread waiting for it */ AcpiGbl_GlobalLockAcquired = TRUE; /* Send a unit to the semaphore */ Status = AcpiOsSignalSemaphore (AcpiGbl_GlobalLockSemaphore, 1); if (ACPI_FAILURE (Status)) { ACPI_ERROR ((AE_INFO, "Could not signal Global Lock semaphore")); } } return (ACPI_INTERRUPT_HANDLED); }
acpi_status acpi_ev_acquire_global_lock(u16 timeout) { acpi_cpu_flags flags; acpi_status status; u8 acquired = FALSE; ACPI_FUNCTION_TRACE(ev_acquire_global_lock); status = acpi_ex_system_wait_mutex(acpi_gbl_global_lock_mutex->mutex. os_mutex, timeout); if (ACPI_FAILURE(status)) { return_ACPI_STATUS(status); } acpi_gbl_global_lock_handle++; if (acpi_gbl_global_lock_handle == 0) { acpi_gbl_global_lock_handle = 1; } if (!acpi_gbl_global_lock_present) { acpi_gbl_global_lock_acquired = TRUE; return_ACPI_STATUS(AE_OK); } flags = acpi_os_acquire_lock(acpi_gbl_global_lock_pending_lock); do { ACPI_ACQUIRE_GLOBAL_LOCK(acpi_gbl_FACS, acquired); if (acquired) { acpi_gbl_global_lock_acquired = TRUE; ACPI_DEBUG_PRINT((ACPI_DB_EXEC, "Acquired hardware Global Lock\n")); break; } acpi_gbl_global_lock_pending = TRUE; acpi_os_release_lock(acpi_gbl_global_lock_pending_lock, flags); ACPI_DEBUG_PRINT((ACPI_DB_EXEC, "Waiting for hardware Global Lock\n")); status = acpi_ex_system_wait_semaphore (acpi_gbl_global_lock_semaphore, ACPI_WAIT_FOREVER); flags = acpi_os_acquire_lock(acpi_gbl_global_lock_pending_lock); } while (ACPI_SUCCESS(status)); acpi_gbl_global_lock_pending = FALSE; acpi_os_release_lock(acpi_gbl_global_lock_pending_lock, flags); return_ACPI_STATUS(status); }
acpi_status acpi_ev_acquire_global_lock ( u16 timeout) { acpi_status status = AE_OK; u8 acquired = FALSE; ACPI_FUNCTION_TRACE ("ev_acquire_global_lock"); #ifndef ACPI_APPLICATION /* Make sure that we actually have a global lock */ if (!acpi_gbl_global_lock_present) { return_ACPI_STATUS (AE_NO_GLOBAL_LOCK); } #endif /* One more thread wants the global lock */ acpi_gbl_global_lock_thread_count++; /* * If we (OS side vs. BIOS side) have the hardware lock already, * we are done */ if (acpi_gbl_global_lock_acquired) { return_ACPI_STATUS (AE_OK); } /* We must acquire the actual hardware lock */ ACPI_ACQUIRE_GLOBAL_LOCK (acpi_gbl_common_fACS.global_lock, acquired); if (acquired) { /* We got the lock */ ACPI_DEBUG_PRINT ((ACPI_DB_EXEC, "Acquired the HW Global Lock\n")); acpi_gbl_global_lock_acquired = TRUE; return_ACPI_STATUS (AE_OK); } /* * Did not get the lock. The pending bit was set above, and we must now * wait until we get the global lock released interrupt. */ ACPI_DEBUG_PRINT ((ACPI_DB_EXEC, "Waiting for the HW Global Lock\n")); /* * Acquire the global lock semaphore first. * Since this wait will block, we must release the interpreter */ status = acpi_ex_system_wait_semaphore (acpi_gbl_global_lock_semaphore, timeout); return_ACPI_STATUS (status); }
ACPI_STATUS AcpiEvAcquireGlobalLock ( UINT16 Timeout) { ACPI_CPU_FLAGS Flags; ACPI_STATUS Status; BOOLEAN Acquired = FALSE; ACPI_FUNCTION_TRACE (EvAcquireGlobalLock); /* * Only one thread can acquire the GL at a time, the GlobalLockMutex * enforces this. This interface releases the interpreter if we must wait. */ Status = AcpiExSystemWaitMutex (AcpiGbl_GlobalLockMutex->Mutex.OsMutex, Timeout); if (ACPI_FAILURE (Status)) { return_ACPI_STATUS (Status); } /* * Update the global lock handle and check for wraparound. The handle is * only used for the external global lock interfaces, but it is updated * here to properly handle the case where a single thread may acquire the * lock via both the AML and the AcpiAcquireGlobalLock interfaces. The * handle is therefore updated on the first acquire from a given thread * regardless of where the acquisition request originated. */ AcpiGbl_GlobalLockHandle++; if (AcpiGbl_GlobalLockHandle == 0) { AcpiGbl_GlobalLockHandle = 1; } /* * Make sure that a global lock actually exists. If not, just * treat the lock as a standard mutex. */ if (!AcpiGbl_GlobalLockPresent) { AcpiGbl_GlobalLockAcquired = TRUE; return_ACPI_STATUS (AE_OK); } Flags = AcpiOsAcquireLock (AcpiGbl_GlobalLockPendingLock); do { /* Attempt to acquire the actual hardware lock */ ACPI_ACQUIRE_GLOBAL_LOCK (AcpiGbl_FACS, Acquired); if (Acquired) { AcpiGbl_GlobalLockAcquired = TRUE; ACPI_DEBUG_PRINT ((ACPI_DB_EXEC, "Acquired hardware Global Lock\n")); break; } /* * Did not get the lock. The pending bit was set above, and * we must now wait until we receive the global lock * released interrupt. */ AcpiGbl_GlobalLockPending = TRUE; AcpiOsReleaseLock (AcpiGbl_GlobalLockPendingLock, Flags); ACPI_DEBUG_PRINT ((ACPI_DB_EXEC, "Waiting for hardware Global Lock\n")); /* * Wait for handshake with the global lock interrupt handler. * This interface releases the interpreter if we must wait. */ Status = AcpiExSystemWaitSemaphore (AcpiGbl_GlobalLockSemaphore, ACPI_WAIT_FOREVER); Flags = AcpiOsAcquireLock (AcpiGbl_GlobalLockPendingLock); } while (ACPI_SUCCESS (Status)); AcpiGbl_GlobalLockPending = FALSE; AcpiOsReleaseLock (AcpiGbl_GlobalLockPendingLock, Flags); return_ACPI_STATUS (Status); }
acpi_status acpi_ev_acquire_global_lock(u16 timeout) { acpi_cpu_flags flags; acpi_status status; u8 acquired = FALSE; ACPI_FUNCTION_TRACE(ev_acquire_global_lock); /* * Only one thread can acquire the GL at a time, the global_lock_mutex * enforces this. This interface releases the interpreter if we must wait. */ status = acpi_ex_system_wait_mutex(acpi_gbl_global_lock_mutex->mutex. os_mutex, timeout); if (ACPI_FAILURE(status)) { return_ACPI_STATUS(status); } /* * Update the global lock handle and check for wraparound. The handle is * only used for the external global lock interfaces, but it is updated * here to properly handle the case where a single thread may acquire the * lock via both the AML and the acpi_acquire_global_lock interfaces. The * handle is therefore updated on the first acquire from a given thread * regardless of where the acquisition request originated. */ acpi_gbl_global_lock_handle++; if (acpi_gbl_global_lock_handle == 0) { acpi_gbl_global_lock_handle = 1; } /* * Make sure that a global lock actually exists. If not, just * treat the lock as a standard mutex. */ if (!acpi_gbl_global_lock_present) { acpi_gbl_global_lock_acquired = TRUE; return_ACPI_STATUS(AE_OK); } flags = acpi_os_acquire_lock(acpi_gbl_global_lock_pending_lock); do { /* Attempt to acquire the actual hardware lock */ ACPI_ACQUIRE_GLOBAL_LOCK(acpi_gbl_FACS, acquired); if (acquired) { acpi_gbl_global_lock_acquired = TRUE; ACPI_DEBUG_PRINT((ACPI_DB_EXEC, "Acquired hardware Global Lock\n")); break; } /* * Did not get the lock. The pending bit was set above, and * we must now wait until we receive the global lock * released interrupt. */ acpi_gbl_global_lock_pending = TRUE; acpi_os_release_lock(acpi_gbl_global_lock_pending_lock, flags); ACPI_DEBUG_PRINT((ACPI_DB_EXEC, "Waiting for hardware Global Lock\n")); /* * Wait for handshake with the global lock interrupt handler. * This interface releases the interpreter if we must wait. */ status = acpi_ex_system_wait_semaphore (acpi_gbl_global_lock_semaphore, ACPI_WAIT_FOREVER); flags = acpi_os_acquire_lock(acpi_gbl_global_lock_pending_lock); } while (ACPI_SUCCESS(status)); acpi_gbl_global_lock_pending = FALSE; acpi_os_release_lock(acpi_gbl_global_lock_pending_lock, flags); return_ACPI_STATUS(status); }
acpi_status acpi_ev_acquire_global_lock(u16 timeout) { acpi_status status = AE_OK; u8 acquired = FALSE; ACPI_FUNCTION_TRACE(ev_acquire_global_lock); /* * Only one thread can acquire the GL at a time, the global_lock_mutex * enforces this. This interface releases the interpreter if we must wait. */ status = acpi_ex_system_wait_mutex(acpi_gbl_global_lock_mutex, 0); if (status == AE_TIME) { if (acpi_ev_global_lock_thread_id == acpi_os_get_thread_id()) { acpi_ev_global_lock_acquired++; return AE_OK; } } if (ACPI_FAILURE(status)) { status = acpi_ex_system_wait_mutex(acpi_gbl_global_lock_mutex, timeout); } if (ACPI_FAILURE(status)) { return_ACPI_STATUS(status); } acpi_ev_global_lock_thread_id = acpi_os_get_thread_id(); acpi_ev_global_lock_acquired++; /* * Make sure that a global lock actually exists. If not, just treat * the lock as a standard mutex. */ if (!acpi_gbl_global_lock_present) { acpi_gbl_global_lock_acquired = TRUE; return_ACPI_STATUS(AE_OK); } /* Attempt to acquire the actual hardware lock */ ACPI_ACQUIRE_GLOBAL_LOCK(facs, acquired); if (acquired) { /* We got the lock */ ACPI_DEBUG_PRINT((ACPI_DB_EXEC, "Acquired hardware Global Lock\n")); acpi_gbl_global_lock_acquired = TRUE; return_ACPI_STATUS(AE_OK); } /* * Did not get the lock. The pending bit was set above, and we must now * wait until we get the global lock released interrupt. */ ACPI_DEBUG_PRINT((ACPI_DB_EXEC, "Waiting for hardware Global Lock\n")); /* * Wait for handshake with the global lock interrupt handler. * This interface releases the interpreter if we must wait. */ status = acpi_ex_system_wait_semaphore(acpi_gbl_global_lock_semaphore, ACPI_WAIT_FOREVER); return_ACPI_STATUS(status); }