1 files changed, 107 insertions, 172 deletions

diff --git a/drivers/acpi/acpica/hwxface.c b/drivers/acpi/acpica/hwxface.c
index ae597c0ab53f..9829979f2bdd 100644
--- a/drivers/acpi/acpica/hwxface.c
+++ b/drivers/acpi/acpica/hwxface.c
@@ -107,19 +107,18 @@ acpi_status acpi_read(u32 *value, struct acpi_generic_address *reg)
         ACPI_FUNCTION_NAME(acpi_read);
 
         /*
-         * Must have a valid pointer to a GAS structure, and
-         * a non-zero address within. However, don't return an error
-         * because the PM1A/B code must not fail if B isn't present.
+         * Must have a valid pointer to a GAS structure, and a non-zero address
+         * within.
          */
         if (!reg) {
-                return (AE_OK);
+                return (AE_BAD_PARAMETER);
         }
 
         /* Get a local copy of the address. Handles possible alignment issues */
 
         ACPI_MOVE_64_TO_64(&address, &reg->address);
         if (!address) {
-                return (AE_OK);
+                return (AE_BAD_ADDRESS);
         }
 
         /* Supported widths are 8/16/32 */
@@ -134,8 +133,8 @@ acpi_status acpi_read(u32 *value, struct acpi_generic_address *reg)
         *value = 0;
 
         /*
-         * Two address spaces supported: Memory or IO.
-         * PCI_Config is not supported here because the GAS struct is insufficient
+         * Two address spaces supported: Memory or IO. PCI_Config is
+         * not supported here because the GAS structure is insufficient
          */
         switch (reg->space_id) {
         case ACPI_ADR_SPACE_SYSTEM_MEMORY:
@@ -147,7 +146,7 @@ acpi_status acpi_read(u32 *value, struct acpi_generic_address *reg)
         case ACPI_ADR_SPACE_SYSTEM_IO:
 
                 status =
-                    acpi_os_read_port((acpi_io_address) address, value, width);
+                    acpi_hw_read_port((acpi_io_address) address, value, width);
                 break;
 
         default:
@@ -187,19 +186,18 @@ acpi_status acpi_write(u32 value, struct acpi_generic_address *reg)
         ACPI_FUNCTION_NAME(acpi_write);
 
         /*
-         * Must have a valid pointer to a GAS structure, and
-         * a non-zero address within. However, don't return an error
-         * because the PM1A/B code must not fail if B isn't present.
+         * Must have a valid pointer to a GAS structure, and a non-zero address
+         * within.
          */
         if (!reg) {
-                return (AE_OK);
+                return (AE_BAD_PARAMETER);
         }
 
         /* Get a local copy of the address. Handles possible alignment issues */
 
         ACPI_MOVE_64_TO_64(&address, &reg->address);
         if (!address) {
-                return (AE_OK);
+                return (AE_BAD_ADDRESS);
         }
 
         /* Supported widths are 8/16/32 */
@@ -222,7 +220,7 @@ acpi_status acpi_write(u32 value, struct acpi_generic_address *reg)
 
         case ACPI_ADR_SPACE_SYSTEM_IO:
 
-                status = acpi_os_write_port((acpi_io_address) address, value,
+                status = acpi_hw_write_port((acpi_io_address) address, value,
                                             width);
                 break;
 
@@ -244,24 +242,36 @@ ACPI_EXPORT_SYMBOL(acpi_write)
 
 /*******************************************************************************
  *
- * FUNCTION:    acpi_get_register_unlocked
+ * FUNCTION:    acpi_read_bit_register
  *
- * PARAMETERS:  register_id     - ID of ACPI bit_register to access
- *              return_value    - Value that was read from the register
+ * PARAMETERS:  register_id     - ID of ACPI Bit Register to access
+ *              return_value    - Value that was read from the register,
+ *                                normalized to bit position zero.
  *
- * RETURN:      Status and the value read from specified Register. Value
+ * RETURN:      Status and the value read from the specified Register. Value
  *              returned is normalized to bit0 (is shifted all the way right)
  *
  * DESCRIPTION: ACPI bit_register read function. Does not acquire the HW lock.
  *
+ * SUPPORTS:    Bit fields in PM1 Status, PM1 Enable, PM1 Control, and
+ *              PM2 Control.
+ *
+ * Note: The hardware lock is not required when reading the ACPI bit registers
+ *       since almost all of them are single bit and it does not matter that
+ *       the parent hardware register can be split across two physical
+ *       registers. The only multi-bit field is SLP_TYP in the PM1 control
+ *       register, but this field does not cross an 8-bit boundary (nor does
+ *       it make much sense to actually read this field.)
+ *
  ******************************************************************************/
-acpi_status acpi_get_register_unlocked(u32 register_id, u32 *return_value)
+acpi_status acpi_read_bit_register(u32 register_id, u32 *return_value)
 {
-        u32 register_value = 0;
         struct acpi_bit_register_info *bit_reg_info;
+        u32 register_value;
+        u32 value;
         acpi_status status;
 
-        ACPI_FUNCTION_TRACE(acpi_get_register_unlocked);
+        ACPI_FUNCTION_TRACE_U32(acpi_read_bit_register, register_id);
 
         /* Get the info structure corresponding to the requested ACPI Register */
 
@@ -270,209 +280,133 @@ acpi_status acpi_get_register_unlocked(u32 register_id, u32 *return_value)
                 return_ACPI_STATUS(AE_BAD_PARAMETER);
         }
 
-        /* Read from the register */
+        /* Read the entire parent register */
 
         status = acpi_hw_register_read(bit_reg_info->parent_register,
                                        &register_value);
-
-        if (ACPI_SUCCESS(status)) {
-
-                /* Normalize the value that was read */
-
-                register_value =
-                    ((register_value & bit_reg_info->access_bit_mask)
-                     >> bit_reg_info->bit_position);
-
-                *return_value = register_value;
-
-                ACPI_DEBUG_PRINT((ACPI_DB_IO, "Read value %8.8X register %X\n",
-                                  register_value,
-                                  bit_reg_info->parent_register));
+        if (ACPI_FAILURE(status)) {
+                return_ACPI_STATUS(status);
         }
 
-        return_ACPI_STATUS(status);
-}
+        /* Normalize the value that was read, mask off other bits */
 
-ACPI_EXPORT_SYMBOL(acpi_get_register_unlocked)
+        value = ((register_value & bit_reg_info->access_bit_mask)
+                 >> bit_reg_info->bit_position);
 
-/*******************************************************************************
- *
- * FUNCTION:    acpi_get_register
- *
- * PARAMETERS:  register_id     - ID of ACPI bit_register to access
- *              return_value    - Value that was read from the register
- *
- * RETURN:      Status and the value read from specified Register. Value
- *              returned is normalized to bit0 (is shifted all the way right)
- *
- * DESCRIPTION: ACPI bit_register read function.
- *
- ******************************************************************************/
-acpi_status acpi_get_register(u32 register_id, u32 *return_value)
-{
-        acpi_status status;
-        acpi_cpu_flags flags;
-
-        flags = acpi_os_acquire_lock(acpi_gbl_hardware_lock);
-        status = acpi_get_register_unlocked(register_id, return_value);
-        acpi_os_release_lock(acpi_gbl_hardware_lock, flags);
+        ACPI_DEBUG_PRINT((ACPI_DB_IO,
+                          "BitReg %X, ParentReg %X, Actual %8.8X, ReturnValue %8.8X\n",
+                          register_id, bit_reg_info->parent_register,
+                          register_value, value));
 
-        return (status);
+        *return_value = value;
+        return_ACPI_STATUS(AE_OK);
 }
 
-ACPI_EXPORT_SYMBOL(acpi_get_register)
+ACPI_EXPORT_SYMBOL(acpi_read_bit_register)
 
 /*******************************************************************************
  *
- * FUNCTION:    acpi_set_register
+ * FUNCTION:    acpi_write_bit_register
  *
- * PARAMETERS:  register_id     - ID of ACPI bit_register to access
- *              Value           - (only used on write) value to write to the
- *                                Register, NOT pre-normalized to the bit pos
+ * PARAMETERS:  register_id     - ID of ACPI Bit Register to access
+ *              Value           - Value to write to the register, in bit
+ *                                position zero. The bit is automaticallly
+ *                                shifted to the correct position.
  *
  * RETURN:      Status
  *
- * DESCRIPTION: ACPI Bit Register write function.
+ * DESCRIPTION: ACPI Bit Register write function. Acquires the hardware lock
+ *              since most operations require a read/modify/write sequence.
+ *
+ * SUPPORTS:    Bit fields in PM1 Status, PM1 Enable, PM1 Control, and
+ *              PM2 Control.
+ *
+ * Note that at this level, the fact that there may be actually two
+ * hardware registers (A and B - and B may not exist) is abstracted.
  *
  ******************************************************************************/
-acpi_status acpi_set_register(u32 register_id, u32 value)
+acpi_status acpi_write_bit_register(u32 register_id, u32 value)
 {
-        u32 register_value = 0;
         struct acpi_bit_register_info *bit_reg_info;
-        acpi_status status;
         acpi_cpu_flags lock_flags;
+        u32 register_value;
+        acpi_status status = AE_OK;
 
-        ACPI_FUNCTION_TRACE_U32(acpi_set_register, register_id);
+        ACPI_FUNCTION_TRACE_U32(acpi_write_bit_register, register_id);
 
         /* Get the info structure corresponding to the requested ACPI Register */
 
         bit_reg_info = acpi_hw_get_bit_register_info(register_id);
         if (!bit_reg_info) {
-                ACPI_ERROR((AE_INFO, "Bad ACPI HW RegisterId: %X",
-                            register_id));
                 return_ACPI_STATUS(AE_BAD_PARAMETER);
         }
 
         lock_flags = acpi_os_acquire_lock(acpi_gbl_hardware_lock);
 
-        /* Always do a register read first so we can insert the new bits  */
-
-        status = acpi_hw_register_read(bit_reg_info->parent_register,
-                                       &register_value);
-        if (ACPI_FAILURE(status)) {
-                goto unlock_and_exit;
-        }
-
         /*
-         * Decode the Register ID
-         * Register ID = [Register block ID] | [bit ID]
-         *
-         * Check bit ID to fine locate Register offset.
-         * Check Mask to determine Register offset, and then read-write.
+         * At this point, we know that the parent register is one of the
+         * following: PM1 Status, PM1 Enable, PM1 Control, or PM2 Control
          */
-        switch (bit_reg_info->parent_register) {
-        case ACPI_REGISTER_PM1_STATUS:
-
+        if (bit_reg_info->parent_register != ACPI_REGISTER_PM1_STATUS) {
                 /*
-                 * Status Registers are different from the rest. Clear by
-                 * writing 1, and writing 0 has no effect. So, the only relevant
-                 * information is the single bit we're interested in, all others should
-                 * be written as 0 so they will be left unchanged.
+                 * 1) Case for PM1 Enable, PM1 Control, and PM2 Control
+                 *
+                 * Perform a register read to preserve the bits that we are not
+                 * interested in
                  */
-                value = ACPI_REGISTER_PREPARE_BITS(value,
-                                                   bit_reg_info->bit_position,
-                                                   bit_reg_info->
-                                                   access_bit_mask);
-                if (value) {
-                        status =
-                            acpi_hw_register_write(ACPI_REGISTER_PM1_STATUS,
-                                                   (u16) value);
-                        register_value = 0;
-                }
-                break;
-
-        case ACPI_REGISTER_PM1_ENABLE:
-
-                ACPI_REGISTER_INSERT_VALUE(register_value,
-                                           bit_reg_info->bit_position,
-                                           bit_reg_info->access_bit_mask,
-                                           value);
-
-                status = acpi_hw_register_write(ACPI_REGISTER_PM1_ENABLE,
-                                                (u16) register_value);
-                break;
-
-        case ACPI_REGISTER_PM1_CONTROL:
-
-                /*
-                 * Write the PM1 Control register.
-                 * Note that at this level, the fact that there are actually TWO
-                 * registers (A and B - and B may not exist) is abstracted.
-                 */
-                ACPI_DEBUG_PRINT((ACPI_DB_IO, "PM1 control: Read %X\n",
-                                  register_value));
-
-                ACPI_REGISTER_INSERT_VALUE(register_value,
-                                           bit_reg_info->bit_position,
-                                           bit_reg_info->access_bit_mask,
-                                           value);
-
-                status = acpi_hw_register_write(ACPI_REGISTER_PM1_CONTROL,
-                                                (u16) register_value);
-                break;
-
-        case ACPI_REGISTER_PM2_CONTROL:
-
-                status = acpi_hw_register_read(ACPI_REGISTER_PM2_CONTROL,
+                status = acpi_hw_register_read(bit_reg_info->parent_register,
                                                &register_value);
                 if (ACPI_FAILURE(status)) {
                         goto unlock_and_exit;
                 }
 
-                ACPI_DEBUG_PRINT((ACPI_DB_IO,
-                                  "PM2 control: Read %X from %8.8X%8.8X\n",
-                                  register_value,
-                                  ACPI_FORMAT_UINT64(acpi_gbl_FADT.
-                                                     xpm2_control_block.
-                                                     address)));
-
+                /*
+                 * Insert the input bit into the value that was just read
+                 * and write the register
+                 */
                 ACPI_REGISTER_INSERT_VALUE(register_value,
                                            bit_reg_info->bit_position,
                                            bit_reg_info->access_bit_mask,
                                            value);
 
-                ACPI_DEBUG_PRINT((ACPI_DB_IO,
-                                  "About to write %4.4X to %8.8X%8.8X\n",
-                                  register_value,
-                                  ACPI_FORMAT_UINT64(acpi_gbl_FADT.
-                                                     xpm2_control_block.
-                                                     address)));
+                status = acpi_hw_register_write(bit_reg_info->parent_register,
+                                                register_value);
+        } else {
+                /*
+                 * 2) Case for PM1 Status
+                 *
+                 * The Status register is different from the rest. Clear an event
+                 * by writing 1, writing 0 has no effect. So, the only relevant
+                 * information is the single bit we're interested in, all others
+                 * should be written as 0 so they will be left unchanged.
+                 */
+                register_value = ACPI_REGISTER_PREPARE_BITS(value,
+                                                            bit_reg_info->
+                                                            bit_position,
+                                                            bit_reg_info->
+                                                            access_bit_mask);
 
-                status = acpi_hw_register_write(ACPI_REGISTER_PM2_CONTROL,
-                                                (u8) (register_value));
-                break;
+                /* No need to write the register if value is all zeros */
 
-        default:
-                break;
+                if (register_value) {
+                        status =
+                            acpi_hw_register_write(ACPI_REGISTER_PM1_STATUS,
+                                                   register_value);
+                }
         }
 
-      unlock_and_exit:
-
-        acpi_os_release_lock(acpi_gbl_hardware_lock, lock_flags);
-
-        /* Normalize the value that was read */
+        ACPI_DEBUG_PRINT((ACPI_DB_IO,
+                          "BitReg %X, ParentReg %X, Value %8.8X, Actual %8.8X\n",
+                          register_id, bit_reg_info->parent_register, value,
+                          register_value));
 
-        ACPI_DEBUG_EXEC(register_value =
-                        ((register_value & bit_reg_info->access_bit_mask) >>
-                         bit_reg_info->bit_position));
+unlock_and_exit:
 
-        ACPI_DEBUG_PRINT((ACPI_DB_IO,
-                          "Set bits: %8.8X actual %8.8X register %X\n", value,
-                          register_value, bit_reg_info->parent_register));
+        acpi_os_release_lock(acpi_gbl_hardware_lock, lock_flags);
         return_ACPI_STATUS(status);
 }
 
-ACPI_EXPORT_SYMBOL(acpi_set_register)
+ACPI_EXPORT_SYMBOL(acpi_write_bit_register)
 
 /*******************************************************************************
  *
@@ -534,7 +468,7 @@ acpi_get_sleep_type_data(u8 sleep_state, u8 *sleep_type_a, u8 *sleep_type_b)
 
         /* It must be of type Package */
 
-        else if (ACPI_GET_OBJECT_TYPE(info->return_object) != ACPI_TYPE_PACKAGE) {
+        else if (info->return_object->common.type != ACPI_TYPE_PACKAGE) {
                 ACPI_ERROR((AE_INFO,
                             "Sleep State return object is not a Package"));
                 status = AE_AML_OPERAND_TYPE;
@@ -555,12 +489,13 @@ acpi_get_sleep_type_data(u8 sleep_state, u8 *sleep_type_a, u8 *sleep_type_b)
 
         /* The first two elements must both be of type Integer */
 
-        else if ((ACPI_GET_OBJECT_TYPE(info->return_object->package.elements[0])
+        else if (((info->return_object->package.elements[0])->common.type
                   != ACPI_TYPE_INTEGER) ||
-                 (ACPI_GET_OBJECT_TYPE(info->return_object->package.elements[1])
+                 ((info->return_object->package.elements[1])->common.type
                   != ACPI_TYPE_INTEGER)) {
                 ACPI_ERROR((AE_INFO,
-                            "Sleep State return package elements are not both Integers (%s, %s)",
+                            "Sleep State return package elements are not both Integers "
+                            "(%s, %s)",
                             acpi_ut_get_object_type_name(info->return_object->
                                                          package.elements[0]),
                             acpi_ut_get_object_type_name(info->return_object->