drivers/acpi/acpica/evglock.c

   1 // SPDX-License-Identifier: BSD-3-Clause OR GPL-2.0
   2 /******************************************************************************
   3  *
   4  * Module Name: evglock - Global Lock support
   5  *
   6  * Copyright (C) 2000 - 2020, Intel Corp.
   7  *
   8  *****************************************************************************/
   9
  10 #include <acpi/acpi.h>
  11 #include "accommon.h"
  12 #include "acevents.h"
  13 #include "acinterp.h"
  14
  15 #define _COMPONENT          ACPI_EVENTS
  16 ACPI_MODULE_NAME("evglock")
  17 #if (!ACPI_REDUCED_HARDWARE)    /* Entire module */
  18 /* Local prototypes */
  19 static u32 acpi_ev_global_lock_handler(void *context);
  20
  21 /*******************************************************************************
  22  *
  23  * FUNCTION:    acpi_ev_init_global_lock_handler
  24  *
  25  * PARAMETERS:  None
  26  *
  27  * RETURN:      Status
  28  *
  29  * DESCRIPTION: Install a handler for the global lock release event
  30  *
  31  ******************************************************************************/
  32
  33 acpi_status acpi_ev_init_global_lock_handler(void)
  34 {
  35         acpi_status status;
  36
  37         ACPI_FUNCTION_TRACE(ev_init_global_lock_handler);
  38
  39         /* If Hardware Reduced flag is set, there is no global lock */
  40
  41         if (acpi_gbl_reduced_hardware) {
  42                 return_ACPI_STATUS(AE_OK);
  43         }
  44
  45         /* Attempt installation of the global lock handler */
  46
  47         status = acpi_install_fixed_event_handler(ACPI_EVENT_GLOBAL,
  48                                                   acpi_ev_global_lock_handler,
  49                                                   NULL);
  50
  51         /*
  52          * If the global lock does not exist on this platform, the attempt to
  53          * enable GBL_STATUS will fail (the GBL_ENABLE bit will not stick).
  54          * Map to AE_OK, but mark global lock as not present. Any attempt to
  55          * actually use the global lock will be flagged with an error.
  56          */
  57         acpi_gbl_global_lock_present = FALSE;
  58         if (status == AE_NO_HARDWARE_RESPONSE) {
  59                 ACPI_ERROR((AE_INFO,
  60                             "No response from Global Lock hardware, disabling lock"));
  61
  62                 return_ACPI_STATUS(AE_OK);
  63         }
  64
  65         status = acpi_os_create_lock(&acpi_gbl_global_lock_pending_lock);
  66         if (ACPI_FAILURE(status)) {
  67                 return_ACPI_STATUS(status);
  68         }
  69
  70         acpi_gbl_global_lock_pending = FALSE;
  71         acpi_gbl_global_lock_present = TRUE;
  72         return_ACPI_STATUS(status);
  73 }
  74
  75 /*******************************************************************************
  76  *
  77  * FUNCTION:    acpi_ev_remove_global_lock_handler
  78  *
  79  * PARAMETERS:  None
  80  *
  81  * RETURN:      Status
  82  *
  83  * DESCRIPTION: Remove the handler for the Global Lock
  84  *
  85  ******************************************************************************/
  86
  87 acpi_status acpi_ev_remove_global_lock_handler(void)
  88 {
  89         acpi_status status;
  90
  91         ACPI_FUNCTION_TRACE(ev_remove_global_lock_handler);
  92
  93         acpi_gbl_global_lock_present = FALSE;
  94         status = acpi_remove_fixed_event_handler(ACPI_EVENT_GLOBAL,
  95                                                  acpi_ev_global_lock_handler);
  96
  97         acpi_os_delete_lock(acpi_gbl_global_lock_pending_lock);
  98         return_ACPI_STATUS(status);
  99 }
 100
 101 /*******************************************************************************
 102  *
 103  * FUNCTION:    acpi_ev_global_lock_handler
 104  *
 105  * PARAMETERS:  context         - From thread interface, not used
 106  *
 107  * RETURN:      ACPI_INTERRUPT_HANDLED
 108  *
 109  * DESCRIPTION: Invoked directly from the SCI handler when a global lock
 110  *              release interrupt occurs. If there is actually a pending
 111  *              request for the lock, signal the waiting thread.
 112  *
 113  ******************************************************************************/
 114
 115 static u32 acpi_ev_global_lock_handler(void *context)
 116 {
 117         acpi_status status;
 118         acpi_cpu_flags flags;
 119
 120         flags = acpi_os_acquire_lock(acpi_gbl_global_lock_pending_lock);
 121
 122         /*
 123          * If a request for the global lock is not actually pending,
 124          * we are done. This handles "spurious" global lock interrupts
 125          * which are possible (and have been seen) with bad BIOSs.
 126          */
 127         if (!acpi_gbl_global_lock_pending) {
 128                 goto cleanup_and_exit;
 129         }
 130
 131         /*
 132          * Send a unit to the global lock semaphore. The actual acquisition
 133          * of the global lock will be performed by the waiting thread.
 134          */
 135         status = acpi_os_signal_semaphore(acpi_gbl_global_lock_semaphore, 1);
 136         if (ACPI_FAILURE(status)) {
 137                 ACPI_ERROR((AE_INFO, "Could not signal Global Lock semaphore"));
 138         }
 139
 140         acpi_gbl_global_lock_pending = FALSE;
 141
 142 cleanup_and_exit:
 143
 144         acpi_os_release_lock(acpi_gbl_global_lock_pending_lock, flags);
 145         return (ACPI_INTERRUPT_HANDLED);
 146 }
 147
 148 /******************************************************************************
 149  *
 150  * FUNCTION:    acpi_ev_acquire_global_lock
 151  *
 152  * PARAMETERS:  timeout         - Max time to wait for the lock, in millisec.
 153  *
 154  * RETURN:      Status
 155  *
 156  * DESCRIPTION: Attempt to gain ownership of the Global Lock.
 157  *
 158  * MUTEX:       Interpreter must be locked
 159  *
 160  * Note: The original implementation allowed multiple threads to "acquire" the
 161  * Global Lock, and the OS would hold the lock until the last thread had
 162  * released it. However, this could potentially starve the BIOS out of the
 163  * lock, especially in the case where there is a tight handshake between the
 164  * Embedded Controller driver and the BIOS. Therefore, this implementation
 165  * allows only one thread to acquire the HW Global Lock at a time, and makes
 166  * the global lock appear as a standard mutex on the OS side.
 167  *
 168  *****************************************************************************/
 169
 170 acpi_status acpi_ev_acquire_global_lock(u16 timeout)
 171 {
 172         acpi_cpu_flags flags;
 173         acpi_status status;
 174         u8 acquired = FALSE;
 175
 176         ACPI_FUNCTION_TRACE(ev_acquire_global_lock);
 177
 178         /*
 179          * Only one thread can acquire the GL at a time, the global_lock_mutex
 180          * enforces this. This interface releases the interpreter if we must wait.
 181          */
 182         status =
 183             acpi_ex_system_wait_mutex(acpi_gbl_global_lock_mutex->mutex.
 184                                       os_mutex, timeout);
 185         if (ACPI_FAILURE(status)) {
 186                 return_ACPI_STATUS(status);
 187         }
 188
 189         /*
 190          * Update the global lock handle and check for wraparound. The handle is
 191          * only used for the external global lock interfaces, but it is updated
 192          * here to properly handle the case where a single thread may acquire the
 193          * lock via both the AML and the acpi_acquire_global_lock interfaces. The
 194          * handle is therefore updated on the first acquire from a given thread
 195          * regardless of where the acquisition request originated.
 196          */
 197         acpi_gbl_global_lock_handle++;
 198         if (acpi_gbl_global_lock_handle == 0) {
 199                 acpi_gbl_global_lock_handle = 1;
 200         }
 201
 202         /*
 203          * Make sure that a global lock actually exists. If not, just
 204          * treat the lock as a standard mutex.
 205          */
 206         if (!acpi_gbl_global_lock_present) {
 207                 acpi_gbl_global_lock_acquired = TRUE;
 208                 return_ACPI_STATUS(AE_OK);
 209         }
 210
 211         flags = acpi_os_acquire_lock(acpi_gbl_global_lock_pending_lock);
 212
 213         do {
 214
 215                 /* Attempt to acquire the actual hardware lock */
 216
 217                 ACPI_ACQUIRE_GLOBAL_LOCK(acpi_gbl_FACS, acquired);
 218                 if (acquired) {
 219                         acpi_gbl_global_lock_acquired = TRUE;
 220                         ACPI_DEBUG_PRINT((ACPI_DB_EXEC,
 221                                           "Acquired hardware Global Lock\n"));
 222                         break;
 223                 }
 224
 225                 /*
 226                  * Did not get the lock. The pending bit was set above, and
 227                  * we must now wait until we receive the global lock
 228                  * released interrupt.
 229                  */
 230                 acpi_gbl_global_lock_pending = TRUE;
 231                 acpi_os_release_lock(acpi_gbl_global_lock_pending_lock, flags);
 232
 233                 ACPI_DEBUG_PRINT((ACPI_DB_EXEC,
 234                                   "Waiting for hardware Global Lock\n"));
 235
 236                 /*
 237                  * Wait for handshake with the global lock interrupt handler.
 238                  * This interface releases the interpreter if we must wait.
 239                  */
 240                 status =
 241                     acpi_ex_system_wait_semaphore
 242                     (acpi_gbl_global_lock_semaphore, ACPI_WAIT_FOREVER);
 243
 244                 flags = acpi_os_acquire_lock(acpi_gbl_global_lock_pending_lock);
 245
 246         } while (ACPI_SUCCESS(status));
 247
 248         acpi_gbl_global_lock_pending = FALSE;
 249         acpi_os_release_lock(acpi_gbl_global_lock_pending_lock, flags);
 250
 251         return_ACPI_STATUS(status);
 252 }
 253
 254 /*******************************************************************************
 255  *
 256  * FUNCTION:    acpi_ev_release_global_lock
 257  *
 258  * PARAMETERS:  None
 259  *
 260  * RETURN:      Status
 261  *
 262  * DESCRIPTION: Releases ownership of the Global Lock.
 263  *
 264  ******************************************************************************/
 265
 266 acpi_status acpi_ev_release_global_lock(void)
 267 {
 268         u8 pending = FALSE;
 269         acpi_status status = AE_OK;
 270
 271         ACPI_FUNCTION_TRACE(ev_release_global_lock);
 272
 273         /* Lock must be already acquired */
 274
 275         if (!acpi_gbl_global_lock_acquired) {
 276                 ACPI_WARNING((AE_INFO,
 277                               "Cannot release the ACPI Global Lock, it has not been acquired"));
 278                 return_ACPI_STATUS(AE_NOT_ACQUIRED);
 279         }
 280
 281         if (acpi_gbl_global_lock_present) {
 282
 283                 /* Allow any thread to release the lock */
 284
 285                 ACPI_RELEASE_GLOBAL_LOCK(acpi_gbl_FACS, pending);
 286
 287                 /*
 288                  * If the pending bit was set, we must write GBL_RLS to the control
 289                  * register
 290                  */
 291                 if (pending) {
 292                         status =
 293                             acpi_write_bit_register
 294                             (ACPI_BITREG_GLOBAL_LOCK_RELEASE,
 295                              ACPI_ENABLE_EVENT);
 296                 }
 297
 298                 ACPI_DEBUG_PRINT((ACPI_DB_EXEC,
 299                                   "Released hardware Global Lock\n"));
 300         }
 301
 302         acpi_gbl_global_lock_acquired = FALSE;
 303
 304         /* Release the local GL mutex */
 305
 306         acpi_os_release_mutex(acpi_gbl_global_lock_mutex->mutex.os_mutex);
 307         return_ACPI_STATUS(status);
 308 }
 309
 310 #endif                          /* !ACPI_REDUCED_HARDWARE */