ACPI: ACPICA 20060623

Implemented a new acpi_spinlock type for the OSL lock
interfaces.  This allows the type to be customized to
the host OS for improved efficiency (since a spinlock is
usually a very small object.)

Implemented support for "ignored" bits in the ACPI
registers.  According to the ACPI specification, these
bits should be preserved when writing the registers via
a read/modify/write cycle. There are 3 bits preserved
in this manner: PM1_CONTROL[0] (SCI_EN), PM1_CONTROL[9],
and PM1_STATUS[11].
http://bugzilla.kernel.org/show_bug.cgi?id=3691

Implemented the initial deployment of new OSL mutex
interfaces.  Since some host operating systems have
separate mutex and semaphore objects, this feature was
requested. The base code now uses mutexes (and the new
mutex interfaces) wherever a binary semaphore was used
previously. However, for the current release, the mutex
interfaces are defined as macros to map them to the
existing semaphore interfaces.

Fixed several problems with the support for the control
method SyncLevel parameter. The SyncLevel now works
according to the ACPI specification and in concert with the
Mutex SyncLevel parameter, since the current SyncLevel is
a property of the executing thread. Mutual exclusion for
control methods is now implemented with a mutex instead
of a semaphore.

Fixed three instances of the use of the C shift operator
in the bitfield support code (exfldio.c) to avoid the use
of a shift value larger than the target data width. The
behavior of C compilers is undefined in this case and can
cause unpredictable results, and therefore the case must
be detected and avoided.  (Fiodor Suietov)

Added an info message whenever an SSDT or OEM table
is loaded dynamically via the Load() or LoadTable()
ASL operators. This should improve debugging capability
since it will show exactly what tables have been loaded
(beyond the tables present in the RSDT/XSDT.)

Signed-off-by: Bob Moore <robert.moore@intel.com>
Signed-off-by: Len Brown <len.brown@intel.com>

1 files changed, 68 insertions, 14 deletions

diff --git a/drivers/acpi/executer/exsystem.c b/drivers/acpi/executer/exsystem.c
index 52beee3674a0..6b5d1e6ce94b 100644
--- a/drivers/acpi/executer/exsystem.c
+++ b/drivers/acpi/executer/exsystem.c
@@ -63,14 +63,14 @@ ACPI_MODULE_NAME("exsystem")
  *              interpreter is released.
  *
  ******************************************************************************/
-acpi_status acpi_ex_system_wait_semaphore(acpi_handle semaphore, u16 timeout)
+acpi_status acpi_ex_system_wait_semaphore(acpi_semaphore semaphore, u16 timeout)
 {
         acpi_status status;
         acpi_status status2;
 
         ACPI_FUNCTION_TRACE(ex_system_wait_semaphore);
 
-        status = acpi_os_wait_semaphore(semaphore, 1, 0);
+        status = acpi_os_wait_semaphore(semaphore, 1, ACPI_DO_NOT_WAIT);
         if (ACPI_SUCCESS(status)) {
                 return_ACPI_STATUS(status);
         }
@@ -103,6 +103,59 @@ acpi_status acpi_ex_system_wait_semaphore(acpi_handle semaphore, u16 timeout)
 
 /*******************************************************************************
  *
+ * FUNCTION:    acpi_ex_system_wait_mutex
+ *
+ * PARAMETERS:  Mutex           - Mutex to wait on
+ *              Timeout         - Max time to wait
+ *
+ * RETURN:      Status
+ *
+ * DESCRIPTION: Implements a semaphore wait with a check to see if the
+ *              semaphore is available immediately.  If it is not, the
+ *              interpreter is released.
+ *
+ ******************************************************************************/
+
+acpi_status acpi_ex_system_wait_mutex(acpi_mutex mutex, u16 timeout)
+{
+        acpi_status status;
+        acpi_status status2;
+
+        ACPI_FUNCTION_TRACE(ex_system_wait_mutex);
+
+        status = acpi_os_acquire_mutex(mutex, ACPI_DO_NOT_WAIT);
+        if (ACPI_SUCCESS(status)) {
+                return_ACPI_STATUS(status);
+        }
+
+        if (status == AE_TIME) {
+
+                /* We must wait, so unlock the interpreter */
+
+                acpi_ex_exit_interpreter();
+
+                status = acpi_os_acquire_mutex(mutex, timeout);
+
+                ACPI_DEBUG_PRINT((ACPI_DB_EXEC,
+                                  "*** Thread awake after blocking, %s\n",
+                                  acpi_format_exception(status)));
+
+                /* Reacquire the interpreter */
+
+                status2 = acpi_ex_enter_interpreter();
+                if (ACPI_FAILURE(status2)) {
+
+                        /* Report fatal error, could not acquire interpreter */
+
+                        return_ACPI_STATUS(status2);
+                }
+        }
+
+        return_ACPI_STATUS(status);
+}
+
+/*******************************************************************************
+ *
  * FUNCTION:    acpi_ex_system_do_stall
  *
  * PARAMETERS:  how_long        - The amount of time to stall,
@@ -176,7 +229,7 @@ acpi_status acpi_ex_system_do_suspend(acpi_integer how_long)
  *
  * FUNCTION:    acpi_ex_system_acquire_mutex
  *
- * PARAMETERS:  time_desc       - The 'time to delay' object descriptor
+ * PARAMETERS:  time_desc       - Maximum time to wait for the mutex
  *              obj_desc        - The object descriptor for this op
  *
  * RETURN:      Status
@@ -201,14 +254,14 @@ acpi_ex_system_acquire_mutex(union acpi_operand_object * time_desc,
 
         /* Support for the _GL_ Mutex object -- go get the global lock */
 
-        if (obj_desc->mutex.semaphore == acpi_gbl_global_lock_semaphore) {
+        if (obj_desc->mutex.os_mutex == ACPI_GLOBAL_LOCK) {
                 status =
                     acpi_ev_acquire_global_lock((u16) time_desc->integer.value);
                 return_ACPI_STATUS(status);
         }
 
-        status = acpi_ex_system_wait_semaphore(obj_desc->mutex.semaphore,
-                                               (u16) time_desc->integer.value);
+        status = acpi_ex_system_wait_mutex(obj_desc->mutex.os_mutex,
+                                           (u16) time_desc->integer.value);
         return_ACPI_STATUS(status);
 }
 
@@ -239,13 +292,13 @@ acpi_status acpi_ex_system_release_mutex(union acpi_operand_object *obj_desc)
 
         /* Support for the _GL_ Mutex object -- release the global lock */
 
-        if (obj_desc->mutex.semaphore == acpi_gbl_global_lock_semaphore) {
+        if (obj_desc->mutex.os_mutex == ACPI_GLOBAL_LOCK) {
                 status = acpi_ev_release_global_lock();
                 return_ACPI_STATUS(status);
         }
 
-        status = acpi_os_signal_semaphore(obj_desc->mutex.semaphore, 1);
-        return_ACPI_STATUS(status);
+        acpi_os_release_mutex(obj_desc->mutex.os_mutex);
+        return_ACPI_STATUS(AE_OK);
 }
 
 /*******************************************************************************
@@ -268,7 +321,8 @@ acpi_status acpi_ex_system_signal_event(union acpi_operand_object *obj_desc)
         ACPI_FUNCTION_TRACE(ex_system_signal_event);
 
         if (obj_desc) {
-                status = acpi_os_signal_semaphore(obj_desc->event.semaphore, 1);
+                status =
+                    acpi_os_signal_semaphore(obj_desc->event.os_semaphore, 1);
         }
 
         return_ACPI_STATUS(status);
@@ -299,7 +353,7 @@ acpi_ex_system_wait_event(union acpi_operand_object *time_desc,
 
         if (obj_desc) {
                 status =
-                    acpi_ex_system_wait_semaphore(obj_desc->event.semaphore,
+                    acpi_ex_system_wait_semaphore(obj_desc->event.os_semaphore,
                                                   (u16) time_desc->integer.
                                                   value);
         }
@@ -322,7 +376,7 @@ acpi_ex_system_wait_event(union acpi_operand_object *time_desc,
 acpi_status acpi_ex_system_reset_event(union acpi_operand_object *obj_desc)
 {
         acpi_status status = AE_OK;
-        void *temp_semaphore;
+        acpi_semaphore temp_semaphore;
 
         ACPI_FUNCTION_ENTRY();
 
@@ -333,8 +387,8 @@ acpi_status acpi_ex_system_reset_event(union acpi_operand_object *obj_desc)
         status =
             acpi_os_create_semaphore(ACPI_NO_UNIT_LIMIT, 0, &temp_semaphore);
         if (ACPI_SUCCESS(status)) {
-                (void)acpi_os_delete_semaphore(obj_desc->event.semaphore);
-                obj_desc->event.semaphore = temp_semaphore;
+                (void)acpi_os_delete_semaphore(obj_desc->event.os_semaphore);
+                obj_desc->event.os_semaphore = temp_semaphore;
         }
 
         return (status);