Remove flags parameter for acpi_{get,set}_register().
It is no longer necessary now that these functions use a
spinlock for mutual exclusion.
Signed-off-by: Alexey Starikovskiy <alexey.y.starikovskiy@intel.com>
Signed-off-by: Len Brown <len.brown@intel.com>
                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);
                        }
        /* 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.
         */
        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]",
 
                if (pending) {
                        status =
                            acpi_set_register(ACPI_BITREG_GLOBAL_LOCK_RELEASE,
-                                             1, ACPI_MTX_LOCK);
+                                             1);
                }
 
                ACPI_DEBUG_PRINT((ACPI_DB_EXEC,
 
         */
        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);
        }
 
        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);
        }
         */
        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);
        }
         */
        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);
 }
 
        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);
 }
 
                return_UINT32(ACPI_SYS_MODE_ACPI);
        }
 
-       status =
-           acpi_get_register(ACPI_BITREG_SCI_ENABLE, &value, ACPI_MTX_LOCK);
+       status = acpi_get_register(ACPI_BITREG_SCI_ENABLE, &value);
        if (ACPI_FAILURE(status)) {
                return_UINT32(ACPI_SYS_MODE_LEGACY);
        }
 
  *
  * FUNCTION:    acpi_hw_clear_acpi_status
  *
- * PARAMETERS:  Flags           - Lock the hardware or not
+ * PARAMETERS:  None
  *
- * RETURN:      none
+ * RETURN:      None
  *
  * DESCRIPTION: Clears all fixed and general purpose status bits
  *              THIS FUNCTION MUST BE CALLED WITH INTERRUPTS DISABLED
  *
- * NOTE: TBD: Flags parameter is obsolete, to be removed
- *
  ******************************************************************************/
-acpi_status acpi_hw_clear_acpi_status(u32 flags)
+acpi_status acpi_hw_clear_acpi_status(void)
 {
        acpi_status status;
        acpi_cpu_flags lock_flags = 0;
  *
  * PARAMETERS:  register_id     - ID of ACPI bit_register to access
  *              return_value    - Value that was read from the register
- *              Flags           - Lock the hardware or not
  *
  * 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.
  *
- * NOTE: TBD: Flags parameter is obsolete, to be removed
- *
  ******************************************************************************/
 
-acpi_status acpi_get_register(u32 register_id, u32 * return_value, u32 flags)
+acpi_status acpi_get_register(u32 register_id, u32 * return_value)
 {
        u32 register_value = 0;
        struct acpi_bit_register_info *bit_reg_info;
  * 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
- *              Flags           - Lock the hardware or not
  *
  * RETURN:      Status
  *
  * DESCRIPTION: ACPI Bit Register write function.
  *
- * NOTE: TBD: Flags parameter is obsolete, to be removed
- *
  ******************************************************************************/
-acpi_status acpi_set_register(u32 register_id, u32 value, u32 flags)
+acpi_status acpi_set_register(u32 register_id, u32 value)
 {
        u32 register_value = 0;
        struct acpi_bit_register_info *bit_reg_info;
 
 
        /* Clear wake status */
 
-       status =
-           acpi_set_register(ACPI_BITREG_WAKE_STATUS, 1, ACPI_MTX_DO_NOT_LOCK);
+       status = acpi_set_register(ACPI_BITREG_WAKE_STATUS, 1);
        if (ACPI_FAILURE(status)) {
                return_ACPI_STATUS(status);
        }
 
        /* Clear all fixed and general purpose status bits */
 
-       status = acpi_hw_clear_acpi_status(ACPI_MTX_DO_NOT_LOCK);
+       status = acpi_hw_clear_acpi_status();
        if (ACPI_FAILURE(status)) {
                return_ACPI_STATUS(status);
        }
        /* Wait until we enter sleep state */
 
        do {
-               status = acpi_get_register(ACPI_BITREG_WAKE_STATUS, &in_value,
-                                          ACPI_MTX_DO_NOT_LOCK);
+               status = acpi_get_register(ACPI_BITREG_WAKE_STATUS, &in_value);
                if (ACPI_FAILURE(status)) {
                        return_ACPI_STATUS(status);
                }
 
        ACPI_FUNCTION_TRACE(acpi_enter_sleep_state_s4bios);
 
-       status =
-           acpi_set_register(ACPI_BITREG_WAKE_STATUS, 1, ACPI_MTX_DO_NOT_LOCK);
+       status = acpi_set_register(ACPI_BITREG_WAKE_STATUS, 1);
        if (ACPI_FAILURE(status)) {
                return_ACPI_STATUS(status);
        }
 
-       status = acpi_hw_clear_acpi_status(ACPI_MTX_DO_NOT_LOCK);
+       status = acpi_hw_clear_acpi_status();
        if (ACPI_FAILURE(status)) {
                return_ACPI_STATUS(status);
        }
 
        do {
                acpi_os_stall(1000);
-               status = acpi_get_register(ACPI_BITREG_WAKE_STATUS, &in_value,
-                                          ACPI_MTX_DO_NOT_LOCK);
+               status = acpi_get_register(ACPI_BITREG_WAKE_STATUS, &in_value);
                if (ACPI_FAILURE(status)) {
                        return_ACPI_STATUS(status);
                }
 
        (void)
            acpi_set_register(acpi_gbl_fixed_event_info
-                             [ACPI_EVENT_POWER_BUTTON].enable_register_id, 1,
-                             ACPI_MTX_DO_NOT_LOCK);
+                             [ACPI_EVENT_POWER_BUTTON].enable_register_id, 1);
 
        (void)
            acpi_set_register(acpi_gbl_fixed_event_info
-                             [ACPI_EVENT_POWER_BUTTON].status_register_id, 1,
-                             ACPI_MTX_DO_NOT_LOCK);
+                             [ACPI_EVENT_POWER_BUTTON].status_register_id, 1);
 
        arg.integer.value = ACPI_SST_WORKING;
        status = acpi_evaluate_object(NULL, METHOD_NAME__SST, &arg_list, NULL);
 
 
 
        /* Make sure SCI is enabled again (Apple firmware bug?) */
-       acpi_set_register(ACPI_BITREG_SCI_ENABLE, 1, ACPI_MTX_DO_NOT_LOCK);
+       acpi_set_register(ACPI_BITREG_SCI_ENABLE, 1);
 
        list_for_each(node, &acpi_link.entries) {
                link = list_entry(node, struct acpi_pci_link, node);
 
                case ACPI_STATE_C3:
                        /* Disable bus master reload */
                        if (new->type != ACPI_STATE_C3 && pr->flags.bm_check)
-                               acpi_set_register(ACPI_BITREG_BUS_MASTER_RLD, 0,
-                                                 ACPI_MTX_DO_NOT_LOCK);
+                               acpi_set_register(ACPI_BITREG_BUS_MASTER_RLD, 0);
                        break;
                }
        }
        case ACPI_STATE_C3:
                /* Enable bus master reload */
                if (old->type != ACPI_STATE_C3 && pr->flags.bm_check)
-                       acpi_set_register(ACPI_BITREG_BUS_MASTER_RLD, 1,
-                                         ACPI_MTX_DO_NOT_LOCK);
+                       acpi_set_register(ACPI_BITREG_BUS_MASTER_RLD, 1);
                break;
        }
 
 
                pr->power.bm_activity <<= diff;
 
-               acpi_get_register(ACPI_BITREG_BUS_MASTER_STATUS,
-                                 &bm_status, ACPI_MTX_DO_NOT_LOCK);
+               acpi_get_register(ACPI_BITREG_BUS_MASTER_STATUS, &bm_status);
                if (bm_status) {
                        pr->power.bm_activity |= 0x1;
-                       acpi_set_register(ACPI_BITREG_BUS_MASTER_STATUS,
-                                         1, ACPI_MTX_DO_NOT_LOCK);
+                       acpi_set_register(ACPI_BITREG_BUS_MASTER_STATUS, 1);
                }
                /*
                 * PIIX4 Erratum #18: Note that BM_STS doesn't always reflect
                                 * All CPUs are trying to go to C3
                                 * Disable bus master arbitration
                                 */
-                               acpi_set_register(ACPI_BITREG_ARB_DISABLE, 1,
-                                                 ACPI_MTX_DO_NOT_LOCK);
+                               acpi_set_register(ACPI_BITREG_ARB_DISABLE, 1);
                        }
                } else {
                        /* SMP with no shared cache... Invalidate cache  */
                if (pr->flags.bm_check) {
                        /* Enable bus master arbitration */
                        atomic_dec(&c3_cpu_count);
-                       acpi_set_register(ACPI_BITREG_ARB_DISABLE, 0,
-                                         ACPI_MTX_DO_NOT_LOCK);
+                       acpi_set_register(ACPI_BITREG_ARB_DISABLE, 0);
                }
 
 #ifdef CONFIG_GENERIC_TIME
                                          " for C3 to be enabled on SMP systems\n"));
                        return;
                }
-               acpi_set_register(ACPI_BITREG_BUS_MASTER_RLD,
-                                 0, ACPI_MTX_DO_NOT_LOCK);
+               acpi_set_register(ACPI_BITREG_BUS_MASTER_RLD, 0);
        }
 
        /*
 
 acpi_status
 acpi_hw_low_level_write(u32 width, u32 value, struct acpi_generic_address *reg);
 
-acpi_status acpi_hw_clear_acpi_status(u32 flags);
+acpi_status acpi_hw_clear_acpi_status(void);
 
 /*
  * hwgpe - GPE support
 
 /*
  * Hardware (ACPI device) interfaces
  */
-acpi_status acpi_get_register(u32 register_id, u32 * return_value, u32 flags);
+acpi_status acpi_get_register(u32 register_id, u32 * return_value);
 
-acpi_status acpi_set_register(u32 register_id, u32 value, u32 flags);
+acpi_status acpi_set_register(u32 register_id, u32 value);
 
 acpi_status
 acpi_set_firmware_waking_vector(acpi_physical_address physical_address);