10 files changed, 336 insertions, 273 deletions

diff --git a/drivers/acpi/events/evevent.c b/drivers/acpi/events/evevent.c
index 919037d6acff..a1f87b5def2a 100644
--- a/drivers/acpi/events/evevent.c
+++ b/drivers/acpi/events/evevent.c
@@ -5,7 +5,7 @@
  *****************************************************************************/
 
 /*
- * Copyright (C) 2000 - 2006, R. Byron Moore
+ * Copyright (C) 2000 - 2007, R. Byron Moore
  * All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without
@@ -70,13 +70,6 @@ acpi_status acpi_ev_initialize_events(void)
 
         ACPI_FUNCTION_TRACE(ev_initialize_events);
 
-        /* Make sure we have ACPI tables */
-
-        if (!acpi_gbl_DSDT) {
-                ACPI_WARNING((AE_INFO, "No ACPI tables present!"));
-                return_ACPI_STATUS(AE_NO_ACPI_TABLES);
-        }
-
         /*
          * Initialize the Fixed and General Purpose Events. This is done prior to
          * enabling SCIs to prevent interrupts from occurring before the handlers are
@@ -211,8 +204,7 @@ static acpi_status acpi_ev_fixed_event_initialize(void)
                 if (acpi_gbl_fixed_event_info[i].enable_register_id != 0xFF) {
                         status =
                             acpi_set_register(acpi_gbl_fixed_event_info[i].
-                                              enable_register_id, 0,
-                                              ACPI_MTX_LOCK);
+                                              enable_register_id, 0);
                         if (ACPI_FAILURE(status)) {
                                 return (status);
                         }
@@ -298,7 +290,7 @@ static u32 acpi_ev_fixed_event_dispatch(u32 event)
         /* Clear the status bit */
 
         (void)acpi_set_register(acpi_gbl_fixed_event_info[event].
-                                status_register_id, 1, ACPI_MTX_DO_NOT_LOCK);
+                                status_register_id, 1);
 
         /*
          * Make sure we've got a handler.  If not, report an error.
@@ -306,8 +298,7 @@ static u32 acpi_ev_fixed_event_dispatch(u32 event)
          */
         if (NULL == acpi_gbl_fixed_event_handlers[event].handler) {
                 (void)acpi_set_register(acpi_gbl_fixed_event_info[event].
-                                        enable_register_id, 0,
-                                        ACPI_MTX_DO_NOT_LOCK);
+                                        enable_register_id, 0);
 
                 ACPI_ERROR((AE_INFO,
                             "No installed handler for fixed event [%08X]",
diff --git a/drivers/acpi/events/evgpe.c b/drivers/acpi/events/evgpe.c
index c76c0583ca6a..dfac3ecc596e 100644
--- a/drivers/acpi/events/evgpe.c
+++ b/drivers/acpi/events/evgpe.c
@@ -5,7 +5,7 @@
  *****************************************************************************/
 
 /*
- * Copyright (C) 2000 - 2006, R. Byron Moore
+ * Copyright (C) 2000 - 2007, R. Byron Moore
  * All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without
@@ -121,7 +121,9 @@ acpi_ev_update_gpe_enable_masks(struct acpi_gpe_event_info *gpe_event_info,
         if (!gpe_register_info) {
                 return_ACPI_STATUS(AE_NOT_EXIST);
         }
-        register_bit = gpe_event_info->register_bit;
+        register_bit = (u8)
+            (1 <<
+             (gpe_event_info->gpe_number - gpe_register_info->base_gpe_number));
 
         /* 1) Disable case.  Simply clear all enable bits */
 
@@ -458,8 +460,7 @@ u32 acpi_ev_gpe_detect(struct acpi_gpe_xrupt_info * gpe_xrupt_list)
 
                                 /* Examine one GPE bit */
 
-                                if (enabled_status_byte &
-                                    acpi_gbl_decode_to8bit[j]) {
+                                if (enabled_status_byte & (1 << j)) {
                                         /*
                                          * Found an active GPE. Dispatch the event to a handler
                                          * or method.
@@ -570,7 +571,7 @@ static void ACPI_SYSTEM_XFACE acpi_ev_asynch_execute_gpe_method(void *context)
 
                 if (ACPI_FAILURE(status)) {
                         ACPI_EXCEPTION((AE_INFO, status,
-                                        "While evaluating GPE method [%4.4s]",
+                                        "while evaluating GPE method [%4.4s]",
                                         acpi_ut_get_node_name
                                         (local_gpe_event_info.dispatch.
                                          method_node)));
@@ -618,6 +619,8 @@ acpi_ev_gpe_dispatch(struct acpi_gpe_event_info *gpe_event_info, u32 gpe_number)
 
         ACPI_FUNCTION_TRACE(ev_gpe_dispatch);
 
+        acpi_gpe_count++;
+
         /*
          * If edge-triggered, clear the GPE status bit now.  Note that
          * level-triggered events are cleared after the GPE is serviced.
@@ -633,20 +636,23 @@ acpi_ev_gpe_dispatch(struct acpi_gpe_event_info *gpe_event_info, u32 gpe_number)
                 }
         }
 
-        /* Save current system state */
-
-        if (acpi_gbl_system_awake_and_running) {
-                ACPI_SET_BIT(gpe_event_info->flags, ACPI_GPE_SYSTEM_RUNNING);
-        } else {
-                ACPI_CLEAR_BIT(gpe_event_info->flags, ACPI_GPE_SYSTEM_RUNNING);
+        if (!acpi_gbl_system_awake_and_running) {
+                /*
+                 * We just woke up because of a wake GPE. Disable any further GPEs
+                 * until we are fully up and running (Only wake GPEs should be enabled
+                 * at this time, but we just brute-force disable them all.)
+                 * 1) We must disable this particular wake GPE so it won't fire again
+                 * 2) We want to disable all wake GPEs, since we are now awake
+                 */
+                (void)acpi_hw_disable_all_gpes();
         }
 
         /*
-         * Dispatch the GPE to either an installed handler, or the control
-         * method associated with this GPE (_Lxx or _Exx).
-         * If a handler exists, we invoke it and do not attempt to run the method.
-         * If there is neither a handler nor a method, we disable the level to
-         * prevent further events from coming in here.
+         * Dispatch the GPE to either an installed handler, or the control method
+         * associated with this GPE (_Lxx or _Exx). If a handler exists, we invoke
+         * it and do not attempt to run the method. If there is neither a handler
+         * nor a method, we disable this GPE to prevent further such pointless
+         * events from firing.
          */
         switch (gpe_event_info->flags & ACPI_GPE_DISPATCH_MASK) {
         case ACPI_GPE_DISPATCH_HANDLER:
@@ -677,8 +683,8 @@ acpi_ev_gpe_dispatch(struct acpi_gpe_event_info *gpe_event_info, u32 gpe_number)
         case ACPI_GPE_DISPATCH_METHOD:
 
                 /*
-                 * Disable GPE, so it doesn't keep firing before the method has a
-                 * chance to run.
+                 * Disable the GPE, so it doesn't keep firing before the method has a
+                 * chance to run (it runs asynchronously with interrupts enabled).
                  */
                 status = acpi_ev_disable_gpe(gpe_event_info);
                 if (ACPI_FAILURE(status)) {
@@ -711,7 +717,7 @@ acpi_ev_gpe_dispatch(struct acpi_gpe_event_info *gpe_event_info, u32 gpe_number)
                             gpe_number));
 
                 /*
-                 * Disable the GPE.  The GPE will remain disabled until the ACPI
+                 * Disable the GPE. The GPE will remain disabled until the ACPI
                  * Core Subsystem is restarted, or a handler is installed.
                  */
                 status = acpi_ev_disable_gpe(gpe_event_info);
@@ -726,50 +732,3 @@ acpi_ev_gpe_dispatch(struct acpi_gpe_event_info *gpe_event_info, u32 gpe_number)
 
         return_UINT32(ACPI_INTERRUPT_HANDLED);
 }
-
-#ifdef ACPI_GPE_NOTIFY_CHECK
-/*******************************************************************************
- * TBD: NOT USED, PROTOTYPE ONLY AND WILL PROBABLY BE REMOVED
- *
- * FUNCTION:    acpi_ev_check_for_wake_only_gpe
- *
- * PARAMETERS:  gpe_event_info  - info for this GPE
- *
- * RETURN:      Status
- *
- * DESCRIPTION: Determine if a a GPE is "wake-only".
- *
- *              Called from Notify() code in interpreter when a "DeviceWake"
- *              Notify comes in.
- *
- ******************************************************************************/
-
-acpi_status
-acpi_ev_check_for_wake_only_gpe(struct acpi_gpe_event_info *gpe_event_info)
-{
-        acpi_status status;
-
-        ACPI_FUNCTION_TRACE(ev_check_for_wake_only_gpe);
-
-        if ((gpe_event_info) && /* Only >0 for _Lxx/_Exx */
-            ((gpe_event_info->flags & ACPI_GPE_SYSTEM_MASK) == ACPI_GPE_SYSTEM_RUNNING)) {      /* System state at GPE time */
-                /* This must be a wake-only GPE, disable it */
-
-                status = acpi_ev_disable_gpe(gpe_event_info);
-
-                /* Set GPE to wake-only.  Do not change wake disabled/enabled status */
-
-                acpi_ev_set_gpe_type(gpe_event_info, ACPI_GPE_TYPE_WAKE);
-
-                ACPI_INFO((AE_INFO,
-                           "GPE %p was updated from wake/run to wake-only",
-                           gpe_event_info));
-
-                /* This was a wake-only GPE */
-
-                return_ACPI_STATUS(AE_WAKE_ONLY_GPE);
-        }
-
-        return_ACPI_STATUS(AE_OK);
-}
-#endif
diff --git a/drivers/acpi/events/evgpeblk.c b/drivers/acpi/events/evgpeblk.c
index 95ddeb48bc0f..ad5bc76edf46 100644
--- a/drivers/acpi/events/evgpeblk.c
+++ b/drivers/acpi/events/evgpeblk.c
@@ -5,7 +5,7 @@
  *****************************************************************************/
 
 /*
- * Copyright (C) 2000 - 2006, R. Byron Moore
+ * Copyright (C) 2000 - 2007, R. Byron Moore
  * All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without
@@ -529,7 +529,7 @@ static struct acpi_gpe_xrupt_info *acpi_ev_get_gpe_xrupt_block(u32
 
         /* Install new interrupt handler if not SCI_INT */
 
-        if (interrupt_number != acpi_gbl_FADT->sci_int) {
+        if (interrupt_number != acpi_gbl_FADT.sci_interrupt) {
                 status = acpi_os_install_interrupt_handler(interrupt_number,
                                                            acpi_ev_gpe_xrupt_handler,
                                                            gpe_xrupt);
@@ -567,7 +567,7 @@ acpi_ev_delete_gpe_xrupt(struct acpi_gpe_xrupt_info *gpe_xrupt)
 
         /* We never want to remove the SCI interrupt handler */
 
-        if (gpe_xrupt->interrupt_number == acpi_gbl_FADT->sci_int) {
+        if (gpe_xrupt->interrupt_number == acpi_gbl_FADT.sci_interrupt) {
                 gpe_xrupt->gpe_block_list_head = NULL;
                 return_ACPI_STATUS(AE_OK);
         }
@@ -796,30 +796,31 @@ acpi_ev_create_gpe_info_blocks(struct acpi_gpe_block_info *gpe_block)
                     (u8) (gpe_block->block_base_number +
                           (i * ACPI_GPE_REGISTER_WIDTH));
 
-                ACPI_STORE_ADDRESS(this_register->status_address.address,
-                                   (gpe_block->block_address.address + i));
+                this_register->status_address.address =
+                    gpe_block->block_address.address + i;
 
-                ACPI_STORE_ADDRESS(this_register->enable_address.address,
-                                   (gpe_block->block_address.address
-                                    + i + gpe_block->register_count));
+                this_register->enable_address.address =
+                    gpe_block->block_address.address + i +
+                    gpe_block->register_count;
 
-                this_register->status_address.address_space_id =
-                    gpe_block->block_address.address_space_id;
-                this_register->enable_address.address_space_id =
-                    gpe_block->block_address.address_space_id;
-                this_register->status_address.register_bit_width =
+                this_register->status_address.space_id =
+                    gpe_block->block_address.space_id;
+                this_register->enable_address.space_id =
+                    gpe_block->block_address.space_id;
+                this_register->status_address.bit_width =
                     ACPI_GPE_REGISTER_WIDTH;
-                this_register->enable_address.register_bit_width =
+                this_register->enable_address.bit_width =
                     ACPI_GPE_REGISTER_WIDTH;
-                this_register->status_address.register_bit_offset =
+                this_register->status_address.bit_offset =
                     ACPI_GPE_REGISTER_WIDTH;
-                this_register->enable_address.register_bit_offset =
+                this_register->enable_address.bit_offset =
                     ACPI_GPE_REGISTER_WIDTH;
 
                 /* Init the event_info for each GPE within this register */
 
                 for (j = 0; j < ACPI_GPE_REGISTER_WIDTH; j++) {
-                        this_event->register_bit = acpi_gbl_decode_to8bit[j];
+                        this_event->gpe_number =
+                            (u8) (this_register->base_gpe_number + j);
                         this_event->register_info = this_register;
                         this_event++;
                 }
@@ -1109,11 +1110,12 @@ acpi_status acpi_ev_gpe_initialize(void)
          * If EITHER the register length OR the block address are zero, then that
          * particular block is not supported.
          */
-        if (acpi_gbl_FADT->gpe0_blk_len && acpi_gbl_FADT->xgpe0_blk.address) {
+        if (acpi_gbl_FADT.gpe0_block_length &&
+            acpi_gbl_FADT.xgpe0_block.address) {
 
                 /* GPE block 0 exists (has both length and address > 0) */
 
-                register_count0 = (u16) (acpi_gbl_FADT->gpe0_blk_len / 2);
+                register_count0 = (u16) (acpi_gbl_FADT.gpe0_block_length / 2);
 
                 gpe_number_max =
                     (register_count0 * ACPI_GPE_REGISTER_WIDTH) - 1;
@@ -1121,9 +1123,9 @@ acpi_status acpi_ev_gpe_initialize(void)
                 /* Install GPE Block 0 */
 
                 status = acpi_ev_create_gpe_block(acpi_gbl_fadt_gpe_device,
-                                                  &acpi_gbl_FADT->xgpe0_blk,
+                                                  &acpi_gbl_FADT.xgpe0_block,
                                                   register_count0, 0,
-                                                  acpi_gbl_FADT->sci_int,
+                                                  acpi_gbl_FADT.sci_interrupt,
                                                   &acpi_gbl_gpe_fadt_blocks[0]);
 
                 if (ACPI_FAILURE(status)) {
@@ -1132,20 +1134,21 @@ acpi_status acpi_ev_gpe_initialize(void)
                 }
         }
 
-        if (acpi_gbl_FADT->gpe1_blk_len && acpi_gbl_FADT->xgpe1_blk.address) {
+        if (acpi_gbl_FADT.gpe1_block_length &&
+            acpi_gbl_FADT.xgpe1_block.address) {
 
                 /* GPE block 1 exists (has both length and address > 0) */
 
-                register_count1 = (u16) (acpi_gbl_FADT->gpe1_blk_len / 2);
+                register_count1 = (u16) (acpi_gbl_FADT.gpe1_block_length / 2);
 
                 /* Check for GPE0/GPE1 overlap (if both banks exist) */
 
                 if ((register_count0) &&
-                    (gpe_number_max >= acpi_gbl_FADT->gpe1_base)) {
+                    (gpe_number_max >= acpi_gbl_FADT.gpe1_base)) {
                         ACPI_ERROR((AE_INFO,
                                     "GPE0 block (GPE 0 to %d) overlaps the GPE1 block (GPE %d to %d) - Ignoring GPE1",
-                                    gpe_number_max, acpi_gbl_FADT->gpe1_base,
-                                    acpi_gbl_FADT->gpe1_base +
+                                    gpe_number_max, acpi_gbl_FADT.gpe1_base,
+                                    acpi_gbl_FADT.gpe1_base +
                                     ((register_count1 *
                                       ACPI_GPE_REGISTER_WIDTH) - 1)));
 
@@ -1157,10 +1160,11 @@ acpi_status acpi_ev_gpe_initialize(void)
 
                         status =
                             acpi_ev_create_gpe_block(acpi_gbl_fadt_gpe_device,
-                                                     &acpi_gbl_FADT->xgpe1_blk,
+                                                     &acpi_gbl_FADT.xgpe1_block,
                                                      register_count1,
-                                                     acpi_gbl_FADT->gpe1_base,
-                                                     acpi_gbl_FADT->sci_int,
+                                                     acpi_gbl_FADT.gpe1_base,
+                                                     acpi_gbl_FADT.
+                                                     sci_interrupt,
                                                      &acpi_gbl_gpe_fadt_blocks
                                                      [1]);
 
@@ -1173,7 +1177,7 @@ acpi_status acpi_ev_gpe_initialize(void)
                          * GPE0 and GPE1 do not have to be contiguous in the GPE number
                          * space. However, GPE0 always starts at GPE number zero.
                          */
-                        gpe_number_max = acpi_gbl_FADT->gpe1_base +
+                        gpe_number_max = acpi_gbl_FADT.gpe1_base +
                             ((register_count1 * ACPI_GPE_REGISTER_WIDTH) - 1);
                 }
         }
diff --git a/drivers/acpi/events/evmisc.c b/drivers/acpi/events/evmisc.c
index bf63edc6608d..1b784ffe54c3 100644
--- a/drivers/acpi/events/evmisc.c
+++ b/drivers/acpi/events/evmisc.c
@@ -5,7 +5,7 @@
  *****************************************************************************/
 
 /*
- * Copyright (C) 2000 - 2006, R. Byron Moore
+ * Copyright (C) 2000 - 2007, R. Byron Moore
  * All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without
@@ -63,14 +63,18 @@ static const char *acpi_notify_value_names[] = {
 };
 #endif
 
+/* Pointer to FACS needed for the Global Lock */
+
+static struct acpi_table_facs *facs = NULL;
+
 /* Local prototypes */
 
 static void ACPI_SYSTEM_XFACE acpi_ev_notify_dispatch(void *context);
 
-static void ACPI_SYSTEM_XFACE acpi_ev_global_lock_thread(void *context);
-
 static u32 acpi_ev_global_lock_handler(void *context);
 
+static acpi_status acpi_ev_remove_global_lock_handler(void);
+
 /*******************************************************************************
  *
  * FUNCTION:    acpi_ev_is_notify_object
@@ -282,49 +286,19 @@ static void ACPI_SYSTEM_XFACE acpi_ev_notify_dispatch(void *context)
 
 /*******************************************************************************
  *
- * FUNCTION:    acpi_ev_global_lock_thread
- *
- * PARAMETERS:  Context         - From thread interface, not used
- *
- * RETURN:      None
- *
- * DESCRIPTION: Invoked by SCI interrupt handler upon acquisition of the
- *              Global Lock.  Simply signal all threads that are waiting
- *              for the lock.
- *
- ******************************************************************************/
-
-static void ACPI_SYSTEM_XFACE acpi_ev_global_lock_thread(void *context)
-{
-        acpi_status status;
-
-        /* Signal threads that are waiting for the lock */
-
-        if (acpi_gbl_global_lock_thread_count) {
-
-                /* Send sufficient units to the semaphore */
-
-                status =
-                    acpi_os_signal_semaphore(acpi_gbl_global_lock_semaphore,
-                                             acpi_gbl_global_lock_thread_count);
-                if (ACPI_FAILURE(status)) {
-                        ACPI_ERROR((AE_INFO,
-                                    "Could not signal Global Lock semaphore"));
-                }
-        }
-}
-
-/*******************************************************************************
- *
  * FUNCTION:    acpi_ev_global_lock_handler
  *
  * PARAMETERS:  Context         - From thread interface, not used
  *
- * RETURN:      ACPI_INTERRUPT_HANDLED or ACPI_INTERRUPT_NOT_HANDLED
+ * RETURN:      ACPI_INTERRUPT_HANDLED
  *
  * DESCRIPTION: Invoked directly from the SCI handler when a global lock
- *              release interrupt occurs.  Grab the global lock and queue
- *              the global lock thread for execution
+ *              release interrupt occurs. Attempt to acquire the global lock,
+ *              if successful, signal the thread waiting for the lock.
+ *
+ * NOTE: Assumes that the semaphore can be signaled from interrupt level. If
+ * this is not possible for some reason, a separate thread will have to be
+ * scheduled to do this.
  *
  ******************************************************************************/
 
@@ -333,16 +307,24 @@ static u32 acpi_ev_global_lock_handler(void *context)
         u8 acquired = FALSE;
 
         /*
-         * Attempt to get the lock
+         * 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);
+        ACPI_ACQUIRE_GLOBAL_LOCK(facs, acquired);
         if (acquired) {
 
                 /* Got the lock, now wake all threads waiting for it */
+
                 acpi_gbl_global_lock_acquired = TRUE;
-                acpi_ev_global_lock_thread(context);
+                /* 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);
@@ -366,6 +348,13 @@ acpi_status acpi_ev_init_global_lock_handler(void)
 
         ACPI_FUNCTION_TRACE(ev_init_global_lock_handler);
 
+        status =
+            acpi_get_table_by_index(ACPI_TABLE_INDEX_FACS,
+                                    (struct acpi_table_header **)&facs);
+        if (ACPI_FAILURE(status)) {
+                return_ACPI_STATUS(status);
+        }
+
         acpi_gbl_global_lock_present = TRUE;
         status = acpi_install_fixed_event_handler(ACPI_EVENT_GLOBAL,
                                                   acpi_ev_global_lock_handler,
@@ -389,6 +378,31 @@ acpi_status acpi_ev_init_global_lock_handler(void)
         return_ACPI_STATUS(status);
 }
 
+/*******************************************************************************
+ *
+ * FUNCTION:    acpi_ev_remove_global_lock_handler
+ *
+ * PARAMETERS:  None
+ *
+ * RETURN:      Status
+ *
+ * DESCRIPTION: Remove the handler for the Global Lock
+ *
+ ******************************************************************************/
+
+static acpi_status acpi_ev_remove_global_lock_handler(void)
+{
+        acpi_status status;
+
+        ACPI_FUNCTION_TRACE(ev_remove_global_lock_handler);
+
+        acpi_gbl_global_lock_present = FALSE;
+        status = acpi_remove_fixed_event_handler(ACPI_EVENT_GLOBAL,
+                                                 acpi_ev_global_lock_handler);
+
+        return_ACPI_STATUS(status);
+}
+
 /******************************************************************************
  *
  * FUNCTION:    acpi_ev_acquire_global_lock
@@ -399,6 +413,16 @@ acpi_status acpi_ev_init_global_lock_handler(void)
  *
  * DESCRIPTION: Attempt to gain ownership of the Global Lock.
  *
+ * MUTEX:       Interpreter must be locked
+ *
+ * Note: The original implementation allowed multiple threads to "acquire" the
+ * Global Lock, and the OS would hold the lock until the last thread had
+ * released it. However, this could potentially starve the BIOS out of the
+ * lock, especially in the case where there is a tight handshake between the
+ * Embedded Controller driver and the BIOS. Therefore, this implementation
+ * allows only one thread to acquire the HW Global Lock at a time, and makes
+ * the global lock appear as a standard mutex on the OS side.
+ *
  *****************************************************************************/
 
 acpi_status acpi_ev_acquire_global_lock(u16 timeout)
@@ -408,53 +432,51 @@ acpi_status acpi_ev_acquire_global_lock(u16 timeout)
 
         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);
+        /*
+         * 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, timeout);
+        if (ACPI_FAILURE(status)) {
+                return_ACPI_STATUS(status);
         }
-#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
+         * Make sure that a global lock actually exists. If not, just treat
+         * the lock as a standard mutex.
          */
-        if (acpi_gbl_global_lock_acquired) {
+        if (!acpi_gbl_global_lock_present) {
+                acpi_gbl_global_lock_acquired = TRUE;
                 return_ACPI_STATUS(AE_OK);
         }
 
-        /* We must acquire the actual hardware lock */
+        /* Attempt to acquire the actual hardware lock */
 
-        ACPI_ACQUIRE_GLOBAL_LOCK(acpi_gbl_common_fACS.global_lock, acquired);
+        ACPI_ACQUIRE_GLOBAL_LOCK(facs, acquired);
         if (acquired) {
 
                 /* We got the lock */
 
                 ACPI_DEBUG_PRINT((ACPI_DB_EXEC,
-                                  "Acquired the HW Global Lock\n"));
+                                  "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
+         * 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"));
+        ACPI_DEBUG_PRINT((ACPI_DB_EXEC, "Waiting for hardware Global Lock\n"));
 
         /*
-         * Acquire the global lock semaphore first.
-         * Since this wait will block, we must release the interpreter
+         * 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,
-                                          timeout);
+        status = acpi_ex_system_wait_semaphore(acpi_gbl_global_lock_semaphore,
+                                               ACPI_WAIT_FOREVER);
+
         return_ACPI_STATUS(status);
 }
 
@@ -477,38 +499,39 @@ acpi_status acpi_ev_release_global_lock(void)
 
         ACPI_FUNCTION_TRACE(ev_release_global_lock);
 
-        if (!acpi_gbl_global_lock_thread_count) {
+        /* Lock must be already acquired */
+
+        if (!acpi_gbl_global_lock_acquired) {
                 ACPI_WARNING((AE_INFO,
-                              "Cannot release HW Global Lock, it has not been acquired"));
+                              "Cannot release the ACPI Global Lock, it has not been acquired"));
                 return_ACPI_STATUS(AE_NOT_ACQUIRED);
         }
 
-        /* One fewer thread has the global lock */
+        if (acpi_gbl_global_lock_present) {
 
-        acpi_gbl_global_lock_thread_count--;
-        if (acpi_gbl_global_lock_thread_count) {
+                /* Allow any thread to release the lock */
 
-                /* There are still some threads holding the lock, cannot release */
+                ACPI_RELEASE_GLOBAL_LOCK(facs, pending);
 
-                return_ACPI_STATUS(AE_OK);
+                /*
+                 * If the pending bit was set, we must write GBL_RLS to the control
+                 * register
+                 */
+                if (pending) {
+                        status =
+                            acpi_set_register(ACPI_BITREG_GLOBAL_LOCK_RELEASE,
+                                              1);
+                }
+
+                ACPI_DEBUG_PRINT((ACPI_DB_EXEC,
+                                  "Released hardware Global Lock\n"));
         }
 
-        /*
-         * No more threads holding lock, we can do the actual hardware
-         * release
-         */
-        ACPI_RELEASE_GLOBAL_LOCK(acpi_gbl_common_fACS.global_lock, pending);
         acpi_gbl_global_lock_acquired = FALSE;
 
-        /*
-         * If the pending bit was set, we must write GBL_RLS to the control
-         * register
-         */
-        if (pending) {
-                status = acpi_set_register(ACPI_BITREG_GLOBAL_LOCK_RELEASE,
-                                           1, ACPI_MTX_LOCK);
-        }
+        /* Release the local GL mutex */
 
+        acpi_os_release_mutex(acpi_gbl_global_lock_mutex);
         return_ACPI_STATUS(status);
 }
 
@@ -558,6 +581,12 @@ void acpi_ev_terminate(void)
                 if (ACPI_FAILURE(status)) {
                         ACPI_ERROR((AE_INFO, "Could not remove SCI handler"));
                 }
+
+                status = acpi_ev_remove_global_lock_handler();
+                if (ACPI_FAILURE(status)) {
+                        ACPI_ERROR((AE_INFO,
+                                    "Could not remove Global Lock handler"));
+                }
         }
 
         /* Deallocate all handler objects installed within GPE info structs */
diff --git a/drivers/acpi/events/evregion.c b/drivers/acpi/events/evregion.c
index 21caae04fe85..e99f0c435a47 100644
--- a/drivers/acpi/events/evregion.c
+++ b/drivers/acpi/events/evregion.c
@@ -5,7 +5,7 @@
  *****************************************************************************/
 
 /*
- * Copyright (C) 2000 - 2006, R. Byron Moore
+ * Copyright (C) 2000 - 2007, R. Byron Moore
  * All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without
@@ -291,7 +291,6 @@ acpi_ev_address_space_dispatch(union acpi_operand_object *region_obj,
                                u32 bit_width, acpi_integer * value)
 {
         acpi_status status;
-        acpi_status status2;
         acpi_adr_space_handler handler;
         acpi_adr_space_setup region_setup;
         union acpi_operand_object *handler_desc;
@@ -345,7 +344,7 @@ acpi_ev_address_space_dispatch(union acpi_operand_object *region_obj,
                  * setup will potentially execute control methods
                  * (e.g., _REG method for this region)
                  */
-                acpi_ex_exit_interpreter();
+                acpi_ex_relinquish_interpreter();
 
                 status = region_setup(region_obj, ACPI_REGION_ACTIVATE,
                                       handler_desc->address_space.context,
@@ -353,10 +352,7 @@ acpi_ev_address_space_dispatch(union acpi_operand_object *region_obj,
 
                 /* Re-enter the interpreter */
 
-                status2 = acpi_ex_enter_interpreter();
-                if (ACPI_FAILURE(status2)) {
-                        return_ACPI_STATUS(status2);
-                }
+                acpi_ex_reacquire_interpreter();
 
                 /* Check for failure of the Region Setup */
 
@@ -409,7 +405,7 @@ acpi_ev_address_space_dispatch(union acpi_operand_object *region_obj,
                  * exit the interpreter because the handler *might* block -- we don't
                  * know what it will do, so we can't hold the lock on the intepreter.
                  */
-                acpi_ex_exit_interpreter();
+                acpi_ex_relinquish_interpreter();
         }
 
         /* Call the handler */
@@ -430,10 +426,7 @@ acpi_ev_address_space_dispatch(union acpi_operand_object *region_obj,
                  * We just returned from a non-default handler, we must re-enter the
                  * interpreter
                  */
-                status2 = acpi_ex_enter_interpreter();
-                if (ACPI_FAILURE(status2)) {
-                        return_ACPI_STATUS(status2);
-                }
+                acpi_ex_reacquire_interpreter();
         }
 
         return_ACPI_STATUS(status);
diff --git a/drivers/acpi/events/evrgnini.c b/drivers/acpi/events/evrgnini.c
index 203d1359190a..a4fa7e6822a3 100644
--- a/drivers/acpi/events/evrgnini.c
+++ b/drivers/acpi/events/evrgnini.c
@@ -5,7 +5,7 @@
  *****************************************************************************/
 
 /*
- * Copyright (C) 2000 - 2006, R. Byron Moore
+ * Copyright (C) 2000 - 2007, R. Byron Moore
  * All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without
@@ -48,6 +48,11 @@
 #define _COMPONENT          ACPI_EVENTS
 ACPI_MODULE_NAME("evrgnini")
 
+/* Local prototypes */
+static u8 acpi_ev_match_pci_root_bridge(char *id);
+
+static u8 acpi_ev_is_pci_root_bridge(struct acpi_namespace_node *node);
+
 /*******************************************************************************
  *
  * FUNCTION:    acpi_ev_system_memory_region_setup
@@ -62,6 +67,7 @@ ACPI_MODULE_NAME("evrgnini")
  * DESCRIPTION: Setup a system_memory operation region
  *
  ******************************************************************************/
+
 acpi_status
 acpi_ev_system_memory_region_setup(acpi_handle handle,
                                    u32 function,
@@ -168,9 +174,9 @@ acpi_ev_pci_config_region_setup(acpi_handle handle,
         union acpi_operand_object *handler_obj;
         struct acpi_namespace_node *parent_node;
         struct acpi_namespace_node *pci_root_node;
+        struct acpi_namespace_node *pci_device_node;
         union acpi_operand_object *region_obj =
             (union acpi_operand_object *)handle;
-        struct acpi_device_id object_hID;
 
         ACPI_FUNCTION_TRACE(ev_pci_config_region_setup);
 
@@ -215,45 +221,30 @@ acpi_ev_pci_config_region_setup(acpi_handle handle,
 
                 pci_root_node = parent_node;
                 while (pci_root_node != acpi_gbl_root_node) {
-                        status =
-                            acpi_ut_execute_HID(pci_root_node, &object_hID);
-                        if (ACPI_SUCCESS(status)) {
-                                /*
-                                 * Got a valid _HID string, check if this is a PCI root.
-                                 * New for ACPI 3.0: check for a PCI Express root also.
-                                 */
-                                if (!
-                                    (ACPI_STRNCMP
-                                     (object_hID.value, PCI_ROOT_HID_STRING,
-                                      sizeof(PCI_ROOT_HID_STRING)))
-                                    ||
-                                    !(ACPI_STRNCMP
-                                      (object_hID.value,
-                                       PCI_EXPRESS_ROOT_HID_STRING,
-                                       sizeof(PCI_EXPRESS_ROOT_HID_STRING)))) {
-
-                                        /* Install a handler for this PCI root bridge */
 
-                                        status =
-                                            acpi_install_address_space_handler((acpi_handle) pci_root_node, ACPI_ADR_SPACE_PCI_CONFIG, ACPI_DEFAULT_HANDLER, NULL, NULL);
-                                        if (ACPI_FAILURE(status)) {
-                                                if (status == AE_SAME_HANDLER) {
-                                                        /*
-                                                         * It is OK if the handler is already installed on the root
-                                                         * bridge.  Still need to return a context object for the
-                                                         * new PCI_Config operation region, however.
-                                                         */
-                                                        status = AE_OK;
-                                                } else {
-                                                        ACPI_EXCEPTION((AE_INFO,
-                                                                        status,
-                                                                        "Could not install PciConfig handler for Root Bridge %4.4s",
-                                                                        acpi_ut_get_node_name
-                                                                        (pci_root_node)));
-                                                }
+                        /* Get the _HID/_CID in order to detect a root_bridge */
+
+                        if (acpi_ev_is_pci_root_bridge(pci_root_node)) {
+
+                                /* Install a handler for this PCI root bridge */
+
+                                status = acpi_install_address_space_handler((acpi_handle) pci_root_node, ACPI_ADR_SPACE_PCI_CONFIG, ACPI_DEFAULT_HANDLER, NULL, NULL);
+                                if (ACPI_FAILURE(status)) {
+                                        if (status == AE_SAME_HANDLER) {
+                                                /*
+                                                 * It is OK if the handler is already installed on the root
+                                                 * bridge.  Still need to return a context object for the
+                                                 * new PCI_Config operation region, however.
+                                                 */
+                                                status = AE_OK;
+                                        } else {
+                                                ACPI_EXCEPTION((AE_INFO, status,
+                                                                "Could not install PciConfig handler for Root Bridge %4.4s",
+                                                                acpi_ut_get_node_name
+                                                                (pci_root_node)));
                                         }
-                                        break;
                                 }
+                                break;
                         }
 
                         pci_root_node = acpi_ns_get_parent_node(pci_root_node);
@@ -282,14 +273,25 @@ acpi_ev_pci_config_region_setup(acpi_handle handle,
         /*
          * For PCI_Config space access, we need the segment, bus,
          * device and function numbers.  Acquire them here.
+         *
+         * Find the parent device object. (This allows the operation region to be
+         * within a subscope under the device, such as a control method.)
          */
+        pci_device_node = region_obj->region.node;
+        while (pci_device_node && (pci_device_node->type != ACPI_TYPE_DEVICE)) {
+                pci_device_node = acpi_ns_get_parent_node(pci_device_node);
+        }
+
+        if (!pci_device_node) {
+                return_ACPI_STATUS(AE_AML_OPERAND_TYPE);
+        }
 
         /*
          * Get the PCI device and function numbers from the _ADR object
          * contained in the parent's scope.
          */
         status =
-            acpi_ut_evaluate_numeric_object(METHOD_NAME__ADR, parent_node,
+            acpi_ut_evaluate_numeric_object(METHOD_NAME__ADR, pci_device_node,
                                             &pci_value);
 
         /*
@@ -329,6 +331,91 @@ acpi_ev_pci_config_region_setup(acpi_handle handle,
 
 /*******************************************************************************
  *
+ * FUNCTION:    acpi_ev_match_pci_root_bridge
+ *
+ * PARAMETERS:  Id              - The HID/CID in string format
+ *
+ * RETURN:      TRUE if the Id is a match for a PCI/PCI-Express Root Bridge
+ *
+ * DESCRIPTION: Determine if the input ID is a PCI Root Bridge ID.
+ *
+ ******************************************************************************/
+
+static u8 acpi_ev_match_pci_root_bridge(char *id)
+{
+
+        /*
+         * Check if this is a PCI root.
+         * ACPI 3.0+: check for a PCI Express root also.
+         */
+        if (!(ACPI_STRNCMP(id,
+                           PCI_ROOT_HID_STRING,
+                           sizeof(PCI_ROOT_HID_STRING))) ||
+            !(ACPI_STRNCMP(id,
+                           PCI_EXPRESS_ROOT_HID_STRING,
+                           sizeof(PCI_EXPRESS_ROOT_HID_STRING)))) {
+                return (TRUE);
+        }
+
+        return (FALSE);
+}
+
+/*******************************************************************************
+ *
+ * FUNCTION:    acpi_ev_is_pci_root_bridge
+ *
+ * PARAMETERS:  Node            - Device node being examined
+ *
+ * RETURN:      TRUE if device is a PCI/PCI-Express Root Bridge
+ *
+ * DESCRIPTION: Determine if the input device represents a PCI Root Bridge by
+ *              examining the _HID and _CID for the device.
+ *
+ ******************************************************************************/
+
+static u8 acpi_ev_is_pci_root_bridge(struct acpi_namespace_node *node)
+{
+        acpi_status status;
+        struct acpi_device_id hid;
+        struct acpi_compatible_id_list *cid;
+        acpi_native_uint i;
+
+        /*
+         * Get the _HID and check for a PCI Root Bridge
+         */
+        status = acpi_ut_execute_HID(node, &hid);
+        if (ACPI_FAILURE(status)) {
+                return (FALSE);
+        }
+
+        if (acpi_ev_match_pci_root_bridge(hid.value)) {
+                return (TRUE);
+        }
+
+        /*
+         * The _HID did not match.
+         * Get the _CID and check for a PCI Root Bridge
+         */
+        status = acpi_ut_execute_CID(node, &cid);
+        if (ACPI_FAILURE(status)) {
+                return (FALSE);
+        }
+
+        /* Check all _CIDs in the returned list */
+
+        for (i = 0; i < cid->count; i++) {
+                if (acpi_ev_match_pci_root_bridge(cid->id[i].value)) {
+                        ACPI_FREE(cid);
+                        return (TRUE);
+                }
+        }
+
+        ACPI_FREE(cid);
+        return (FALSE);
+}
+
+/*******************************************************************************
+ *
  * FUNCTION:    acpi_ev_pci_bar_region_setup
  *
  * PARAMETERS:  Handle              - Region we are interested in
@@ -432,6 +519,9 @@ acpi_ev_default_region_setup(acpi_handle handle,
  *              a PCI address in the scope of the definition.  This address is
  *              required to perform an access to PCI config space.
  *
+ * MUTEX:       Interpreter should be unlocked, because we may run the _REG
+ *              method for this region.
+ *
  ******************************************************************************/
 
 acpi_status
diff --git a/drivers/acpi/events/evsci.c b/drivers/acpi/events/evsci.c
index 8106215ad554..7e5d15ce2395 100644
--- a/drivers/acpi/events/evsci.c
+++ b/drivers/acpi/events/evsci.c
@@ -6,7 +6,7 @@
  ******************************************************************************/
 
 /*
- * Copyright (C) 2000 - 2006, R. Byron Moore
+ * Copyright (C) 2000 - 2007, R. Byron Moore
  * All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without
@@ -142,9 +142,10 @@ u32 acpi_ev_install_sci_handler(void)
 
         ACPI_FUNCTION_TRACE(ev_install_sci_handler);
 
-        status = acpi_os_install_interrupt_handler((u32) acpi_gbl_FADT->sci_int,
-                                                   acpi_ev_sci_xrupt_handler,
-                                                   acpi_gbl_gpe_xrupt_list_head);
+        status =
+            acpi_os_install_interrupt_handler((u32) acpi_gbl_FADT.sci_interrupt,
+                                              acpi_ev_sci_xrupt_handler,
+                                              acpi_gbl_gpe_xrupt_list_head);
         return_ACPI_STATUS(status);
 }
 
@@ -175,8 +176,9 @@ acpi_status acpi_ev_remove_sci_handler(void)
 
         /* Just let the OS remove the handler and disable the level */
 
-        status = acpi_os_remove_interrupt_handler((u32) acpi_gbl_FADT->sci_int,
-                                                  acpi_ev_sci_xrupt_handler);
+        status =
+            acpi_os_remove_interrupt_handler((u32) acpi_gbl_FADT.sci_interrupt,
+                                             acpi_ev_sci_xrupt_handler);
 
         return_ACPI_STATUS(status);
 }
diff --git a/drivers/acpi/events/evxface.c b/drivers/acpi/events/evxface.c
index 923fd2b46955..685a103a3587 100644
--- a/drivers/acpi/events/evxface.c
+++ b/drivers/acpi/events/evxface.c
@@ -5,7 +5,7 @@
  *****************************************************************************/
 
 /*
- * Copyright (C) 2000 - 2006, R. Byron Moore
+ * Copyright (C) 2000 - 2007, R. Byron Moore
  * All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without
@@ -768,11 +768,9 @@ acpi_status acpi_acquire_global_lock(u16 timeout, u32 * handle)
                 return (AE_BAD_PARAMETER);
         }
 
-        status = acpi_ex_enter_interpreter();
-        if (ACPI_FAILURE(status)) {
-                return (status);
-        }
+        /* Must lock interpreter to prevent race conditions */
 
+        acpi_ex_enter_interpreter();
         status = acpi_ev_acquire_global_lock(timeout);
         acpi_ex_exit_interpreter();
 
diff --git a/drivers/acpi/events/evxfevnt.c b/drivers/acpi/events/evxfevnt.c
index 7ebc2efac936..17065e98807c 100644
--- a/drivers/acpi/events/evxfevnt.c
+++ b/drivers/acpi/events/evxfevnt.c
@@ -5,7 +5,7 @@
  *****************************************************************************/
 
 /*
- * Copyright (C) 2000 - 2006, R. Byron Moore
+ * Copyright (C) 2000 - 2007, R. Byron Moore
  * All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without
@@ -44,6 +44,7 @@
 #include <acpi/acpi.h>
 #include <acpi/acevents.h>
 #include <acpi/acnamesp.h>
+#include <acpi/actables.h>
 
 #define _COMPONENT          ACPI_EVENTS
 ACPI_MODULE_NAME("evxfevnt")
@@ -65,13 +66,14 @@ acpi_status acpi_enable(void)
 
         ACPI_FUNCTION_TRACE(acpi_enable);
 
-        /* Make sure we have the FADT */
+        /* ACPI tables must be present */
 
-        if (!acpi_gbl_FADT) {
-                ACPI_WARNING((AE_INFO, "No FADT information present!"));
+        if (!acpi_tb_tables_loaded()) {
                 return_ACPI_STATUS(AE_NO_ACPI_TABLES);
         }
 
+        /* Check current mode */
+
         if (acpi_hw_get_mode() == ACPI_SYS_MODE_ACPI) {
                 ACPI_DEBUG_PRINT((ACPI_DB_INIT,
                                   "System is already in ACPI mode\n"));
@@ -111,11 +113,6 @@ acpi_status acpi_disable(void)
 
         ACPI_FUNCTION_TRACE(acpi_disable);
 
-        if (!acpi_gbl_FADT) {
-                ACPI_WARNING((AE_INFO, "No FADT information present!"));
-                return_ACPI_STATUS(AE_NO_ACPI_TABLES);
-        }
-
         if (acpi_hw_get_mode() == ACPI_SYS_MODE_LEGACY) {
                 ACPI_DEBUG_PRINT((ACPI_DB_INIT,
                                   "System is already in legacy (non-ACPI) mode\n"));
@@ -169,7 +166,7 @@ acpi_status acpi_enable_event(u32 event, u32 flags)
          */
         status =
             acpi_set_register(acpi_gbl_fixed_event_info[event].
-                              enable_register_id, 1, ACPI_MTX_LOCK);
+                              enable_register_id, 1);
         if (ACPI_FAILURE(status)) {
                 return_ACPI_STATUS(status);
         }
@@ -178,7 +175,7 @@ acpi_status acpi_enable_event(u32 event, u32 flags)
 
         status =
             acpi_get_register(acpi_gbl_fixed_event_info[event].
-                              enable_register_id, &value, ACPI_MTX_LOCK);
+                              enable_register_id, &value);
         if (ACPI_FAILURE(status)) {
                 return_ACPI_STATUS(status);
         }
@@ -368,14 +365,14 @@ acpi_status acpi_disable_event(u32 event, u32 flags)
          */
         status =
             acpi_set_register(acpi_gbl_fixed_event_info[event].
-                              enable_register_id, 0, ACPI_MTX_LOCK);
+                              enable_register_id, 0);
         if (ACPI_FAILURE(status)) {
                 return_ACPI_STATUS(status);
         }
 
         status =
             acpi_get_register(acpi_gbl_fixed_event_info[event].
-                              enable_register_id, &value, ACPI_MTX_LOCK);
+                              enable_register_id, &value);
         if (ACPI_FAILURE(status)) {
                 return_ACPI_STATUS(status);
         }
@@ -421,7 +418,7 @@ acpi_status acpi_clear_event(u32 event)
          */
         status =
             acpi_set_register(acpi_gbl_fixed_event_info[event].
-                              status_register_id, 1, ACPI_MTX_LOCK);
+                              status_register_id, 1);
 
         return_ACPI_STATUS(status);
 }
@@ -510,7 +507,7 @@ acpi_status acpi_get_event_status(u32 event, acpi_event_status * event_status)
 
         status =
             acpi_get_register(acpi_gbl_fixed_event_info[event].
-                              status_register_id, event_status, ACPI_MTX_LOCK);
+                              status_register_id, event_status);
 
         return_ACPI_STATUS(status);
 }
diff --git a/drivers/acpi/events/evxfregn.c b/drivers/acpi/events/evxfregn.c
index 83b12a9afa32..7bf09c5fb242 100644
--- a/drivers/acpi/events/evxfregn.c
+++ b/drivers/acpi/events/evxfregn.c
@@ -6,7 +6,7 @@
  *****************************************************************************/
 
 /*
- * Copyright (C) 2000 - 2006, R. Byron Moore
+ * Copyright (C) 2000 - 2007, R. Byron Moore
  * All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without