[ACPI] Lindent all ACPI files

Signed-off-by: Len Brown <len.brown@intel.com>

5 files changed, 661 insertions, 744 deletions

diff --git a/drivers/acpi/hardware/hwacpi.c b/drivers/acpi/hardware/hwacpi.c
index b51001e74eea..1bb3463d7040 100644
--- a/drivers/acpi/hardware/hwacpi.c
+++ b/drivers/acpi/hardware/hwacpi.c
@@ -42,13 +42,10 @@
  * POSSIBILITY OF SUCH DAMAGES.
  */
 
-
 #include <acpi/acpi.h>
 
-
 #define _COMPONENT          ACPI_HARDWARE
-	 ACPI_MODULE_NAME    ("hwacpi")
-
+ACPI_MODULE_NAME("hwacpi")
 
 /******************************************************************************
  *
@@ -62,36 +59,30 @@
  *              the FADT.
  *
  ******************************************************************************/
-
-acpi_status
-acpi_hw_initialize (
-	void)
+acpi_status acpi_hw_initialize(void)
 {
-	acpi_status                     status;
-
-
-	ACPI_FUNCTION_TRACE ("hw_initialize");
+	acpi_status status;
 
+	ACPI_FUNCTION_TRACE("hw_initialize");
 
 	/* We must have the ACPI tables by the time we get here */
 
 	if (!acpi_gbl_FADT) {
-		ACPI_DEBUG_PRINT ((ACPI_DB_ERROR, "No FADT is present\n"));
+		ACPI_DEBUG_PRINT((ACPI_DB_ERROR, "No FADT is present\n"));
 
-		return_ACPI_STATUS (AE_NO_ACPI_TABLES);
+		return_ACPI_STATUS(AE_NO_ACPI_TABLES);
 	}
 
 	/* Sanity check the FADT for valid values */
 
-	status = acpi_ut_validate_fadt ();
-	if (ACPI_FAILURE (status)) {
-		return_ACPI_STATUS (status);
+	status = acpi_ut_validate_fadt();
+	if (ACPI_FAILURE(status)) {
+		return_ACPI_STATUS(status);
 	}
 
-	return_ACPI_STATUS (AE_OK);
+	return_ACPI_STATUS(AE_OK);
 }
 
-
 /******************************************************************************
  *
  * FUNCTION:    acpi_hw_set_mode
@@ -104,24 +95,21 @@ acpi_hw_initialize (
  *
  ******************************************************************************/
 
-acpi_status
-acpi_hw_set_mode (
-	u32                             mode)
+acpi_status acpi_hw_set_mode(u32 mode)
 {
 
-	acpi_status                     status;
-	u32                             retry;
-
+	acpi_status status;
+	u32 retry;
 
-	ACPI_FUNCTION_TRACE ("hw_set_mode");
+	ACPI_FUNCTION_TRACE("hw_set_mode");
 
 	/*
 	 * ACPI 2.0 clarified that if SMI_CMD in FADT is zero,
 	 * system does not support mode transition.
 	 */
 	if (!acpi_gbl_FADT->smi_cmd) {
-		ACPI_REPORT_ERROR (("No SMI_CMD in FADT, mode transition failed.\n"));
-		return_ACPI_STATUS (AE_NO_HARDWARE_RESPONSE);
+		ACPI_REPORT_ERROR(("No SMI_CMD in FADT, mode transition failed.\n"));
+		return_ACPI_STATUS(AE_NO_HARDWARE_RESPONSE);
 	}
 
 	/*
@@ -132,9 +120,8 @@ acpi_hw_set_mode (
 	 * transitions are not supported.
 	 */
 	if (!acpi_gbl_FADT->acpi_enable && !acpi_gbl_FADT->acpi_disable) {
-		ACPI_REPORT_ERROR ((
-			"No ACPI mode transition supported in this system (enable/disable both zero)\n"));
-		return_ACPI_STATUS (AE_OK);
+		ACPI_REPORT_ERROR(("No ACPI mode transition supported in this system (enable/disable both zero)\n"));
+		return_ACPI_STATUS(AE_OK);
 	}
 
 	switch (mode) {
@@ -142,9 +129,11 @@ acpi_hw_set_mode (
 
 		/* BIOS should have disabled ALL fixed and GP events */
 
-		status = acpi_os_write_port (acpi_gbl_FADT->smi_cmd,
-				  (u32) acpi_gbl_FADT->acpi_enable, 8);
-		ACPI_DEBUG_PRINT ((ACPI_DB_INFO, "Attempting to enable ACPI mode\n"));
+		status = acpi_os_write_port(acpi_gbl_FADT->smi_cmd,
+					    (u32) acpi_gbl_FADT->acpi_enable,
+					    8);
+		ACPI_DEBUG_PRINT((ACPI_DB_INFO,
+				  "Attempting to enable ACPI mode\n"));
 		break;
 
 	case ACPI_SYS_MODE_LEGACY:
@@ -153,20 +142,21 @@ acpi_hw_set_mode (
 		 * BIOS should clear all fixed status bits and restore fixed event
 		 * enable bits to default
 		 */
-		status = acpi_os_write_port (acpi_gbl_FADT->smi_cmd,
-				 (u32) acpi_gbl_FADT->acpi_disable, 8);
-		ACPI_DEBUG_PRINT ((ACPI_DB_INFO,
-				 "Attempting to enable Legacy (non-ACPI) mode\n"));
+		status = acpi_os_write_port(acpi_gbl_FADT->smi_cmd,
+					    (u32) acpi_gbl_FADT->acpi_disable,
+					    8);
+		ACPI_DEBUG_PRINT((ACPI_DB_INFO,
+				  "Attempting to enable Legacy (non-ACPI) mode\n"));
 		break;
 
 	default:
-		return_ACPI_STATUS (AE_BAD_PARAMETER);
+		return_ACPI_STATUS(AE_BAD_PARAMETER);
 	}
 
-	if (ACPI_FAILURE (status)) {
-		ACPI_REPORT_ERROR (("Could not write mode change, %s\n",
-			acpi_format_exception (status)));
-		return_ACPI_STATUS (status);
+	if (ACPI_FAILURE(status)) {
+		ACPI_REPORT_ERROR(("Could not write mode change, %s\n",
+				   acpi_format_exception(status)));
+		return_ACPI_STATUS(status);
 	}
 
 	/*
@@ -176,19 +166,19 @@ acpi_hw_set_mode (
 	retry = 3000;
 	while (retry) {
 		if (acpi_hw_get_mode() == mode) {
-			ACPI_DEBUG_PRINT ((ACPI_DB_INFO, "Mode %X successfully enabled\n",
-				mode));
-			return_ACPI_STATUS (AE_OK);
+			ACPI_DEBUG_PRINT((ACPI_DB_INFO,
+					  "Mode %X successfully enabled\n",
+					  mode));
+			return_ACPI_STATUS(AE_OK);
 		}
 		acpi_os_stall(1000);
 		retry--;
 	}
 
-	ACPI_REPORT_ERROR (("Hardware never changed modes\n"));
-	return_ACPI_STATUS (AE_NO_HARDWARE_RESPONSE);
+	ACPI_REPORT_ERROR(("Hardware never changed modes\n"));
+	return_ACPI_STATUS(AE_NO_HARDWARE_RESPONSE);
 }
 
-
 /*******************************************************************************
  *
  * FUNCTION:    acpi_hw_get_mode
@@ -202,34 +192,30 @@ acpi_hw_set_mode (
  *
  ******************************************************************************/
 
-u32
-acpi_hw_get_mode (
-	void)
+u32 acpi_hw_get_mode(void)
 {
-	acpi_status                     status;
-	u32                             value;
-
-
-	ACPI_FUNCTION_TRACE ("hw_get_mode");
+	acpi_status status;
+	u32 value;
 
+	ACPI_FUNCTION_TRACE("hw_get_mode");
 
 	/*
 	 * ACPI 2.0 clarified that if SMI_CMD in FADT is zero,
 	 * system does not support mode transition.
 	 */
 	if (!acpi_gbl_FADT->smi_cmd) {
-		return_VALUE (ACPI_SYS_MODE_ACPI);
+		return_VALUE(ACPI_SYS_MODE_ACPI);
 	}
 
-	status = acpi_get_register (ACPI_BITREG_SCI_ENABLE, &value, ACPI_MTX_LOCK);
-	if (ACPI_FAILURE (status)) {
-		return_VALUE (ACPI_SYS_MODE_LEGACY);
+	status =
+	    acpi_get_register(ACPI_BITREG_SCI_ENABLE, &value, ACPI_MTX_LOCK);
+	if (ACPI_FAILURE(status)) {
+		return_VALUE(ACPI_SYS_MODE_LEGACY);
 	}
 
 	if (value) {
-		return_VALUE (ACPI_SYS_MODE_ACPI);
-	}
-	else {
-		return_VALUE (ACPI_SYS_MODE_LEGACY);
+		return_VALUE(ACPI_SYS_MODE_ACPI);
+	} else {
+		return_VALUE(ACPI_SYS_MODE_LEGACY);
 	}
 }
diff --git a/drivers/acpi/hardware/hwgpe.c b/drivers/acpi/hardware/hwgpe.c
index 3536bbb990c3..5c8e5dfd024e 100644
--- a/drivers/acpi/hardware/hwgpe.c
+++ b/drivers/acpi/hardware/hwgpe.c
@@ -46,15 +46,12 @@
 #include <acpi/acevents.h>
 
 #define _COMPONENT          ACPI_HARDWARE
-	 ACPI_MODULE_NAME    ("hwgpe")
+ACPI_MODULE_NAME("hwgpe")
 
 /* Local prototypes */
-
 static acpi_status
-acpi_hw_enable_wakeup_gpe_block (
-	struct acpi_gpe_xrupt_info      *gpe_xrupt_info,
-	struct acpi_gpe_block_info      *gpe_block);
-
+acpi_hw_enable_wakeup_gpe_block(struct acpi_gpe_xrupt_info *gpe_xrupt_info,
+				struct acpi_gpe_block_info *gpe_block);
 
 /******************************************************************************
  *
@@ -71,15 +68,12 @@ acpi_hw_enable_wakeup_gpe_block (
  ******************************************************************************/
 
 acpi_status
-acpi_hw_write_gpe_enable_reg (
-	struct acpi_gpe_event_info      *gpe_event_info)
+acpi_hw_write_gpe_enable_reg(struct acpi_gpe_event_info *gpe_event_info)
 {
-	struct acpi_gpe_register_info   *gpe_register_info;
-	acpi_status                     status;
-
-
-	ACPI_FUNCTION_ENTRY ();
+	struct acpi_gpe_register_info *gpe_register_info;
+	acpi_status status;
 
+	ACPI_FUNCTION_ENTRY();
 
 	/* Get the info block for the entire GPE register */
 
@@ -90,13 +84,12 @@ acpi_hw_write_gpe_enable_reg (
 
 	/* Write the entire GPE (runtime) enable register */
 
-	status = acpi_hw_low_level_write (8, gpe_register_info->enable_for_run,
-			  &gpe_register_info->enable_address);
+	status = acpi_hw_low_level_write(8, gpe_register_info->enable_for_run,
+					 &gpe_register_info->enable_address);
 
 	return (status);
 }
 
-
 /******************************************************************************
  *
  * FUNCTION:    acpi_hw_clear_gpe
@@ -109,27 +102,23 @@ acpi_hw_write_gpe_enable_reg (
  *
  ******************************************************************************/
 
-acpi_status
-acpi_hw_clear_gpe (
-	struct acpi_gpe_event_info      *gpe_event_info)
+acpi_status acpi_hw_clear_gpe(struct acpi_gpe_event_info * gpe_event_info)
 {
-	acpi_status                     status;
-
-
-	ACPI_FUNCTION_ENTRY ();
+	acpi_status status;
 
+	ACPI_FUNCTION_ENTRY();
 
 	/*
 	 * Write a one to the appropriate bit in the status register to
 	 * clear this GPE.
 	 */
-	status = acpi_hw_low_level_write (8, gpe_event_info->register_bit,
-			  &gpe_event_info->register_info->status_address);
+	status = acpi_hw_low_level_write(8, gpe_event_info->register_bit,
+					 &gpe_event_info->register_info->
+					 status_address);
 
 	return (status);
 }
 
-
 /******************************************************************************
  *
  * FUNCTION:    acpi_hw_get_gpe_status
@@ -145,19 +134,16 @@ acpi_hw_clear_gpe (
 
 #ifdef ACPI_FUTURE_USAGE
 acpi_status
-acpi_hw_get_gpe_status (
-	struct acpi_gpe_event_info      *gpe_event_info,
-	acpi_event_status               *event_status)
+acpi_hw_get_gpe_status(struct acpi_gpe_event_info * gpe_event_info,
+		       acpi_event_status * event_status)
 {
-	u32                             in_byte;
-	u8                              register_bit;
-	struct acpi_gpe_register_info   *gpe_register_info;
-	acpi_status                     status;
-	acpi_event_status               local_event_status = 0;
-
-
-	ACPI_FUNCTION_ENTRY ();
+	u32 in_byte;
+	u8 register_bit;
+	struct acpi_gpe_register_info *gpe_register_info;
+	acpi_status status;
+	acpi_event_status local_event_status = 0;
 
+	ACPI_FUNCTION_ENTRY();
 
 	if (!event_status) {
 		return (AE_BAD_PARAMETER);
@@ -185,8 +171,10 @@ acpi_hw_get_gpe_status (
 
 	/* GPE currently active (status bit == 1)? */
 
-	status = acpi_hw_low_level_read (8, &in_byte, &gpe_register_info->status_address);
-	if (ACPI_FAILURE (status)) {
+	status =
+	    acpi_hw_low_level_read(8, &in_byte,
+				   &gpe_register_info->status_address);
+	if (ACPI_FAILURE(status)) {
 		goto unlock_and_exit;
 	}
 
@@ -198,12 +186,10 @@ acpi_hw_get_gpe_status (
 
 	(*event_status) = local_event_status;
 
-
-unlock_and_exit:
+      unlock_and_exit:
 	return (status);
 }
-#endif  /*  ACPI_FUTURE_USAGE  */
-
+#endif				/*  ACPI_FUTURE_USAGE  */
 
 /******************************************************************************
  *
@@ -219,22 +205,21 @@ unlock_and_exit:
  ******************************************************************************/
 
 acpi_status
-acpi_hw_disable_gpe_block (
-	struct acpi_gpe_xrupt_info      *gpe_xrupt_info,
-	struct acpi_gpe_block_info      *gpe_block)
+acpi_hw_disable_gpe_block(struct acpi_gpe_xrupt_info * gpe_xrupt_info,
+			  struct acpi_gpe_block_info * gpe_block)
 {
-	u32                             i;
-	acpi_status                     status;
-
+	u32 i;
+	acpi_status status;
 
 	/* Examine each GPE Register within the block */
 
 	for (i = 0; i < gpe_block->register_count; i++) {
 		/* Disable all GPEs in this register */
 
-		status = acpi_hw_low_level_write (8, 0x00,
-				 &gpe_block->register_info[i].enable_address);
-		if (ACPI_FAILURE (status)) {
+		status = acpi_hw_low_level_write(8, 0x00,
+						 &gpe_block->register_info[i].
+						 enable_address);
+		if (ACPI_FAILURE(status)) {
 			return (status);
 		}
 	}
@@ -242,7 +227,6 @@ acpi_hw_disable_gpe_block (
 	return (AE_OK);
 }
 
-
 /******************************************************************************
  *
  * FUNCTION:    acpi_hw_clear_gpe_block
@@ -257,22 +241,21 @@ acpi_hw_disable_gpe_block (
  ******************************************************************************/
 
 acpi_status
-acpi_hw_clear_gpe_block (
-	struct acpi_gpe_xrupt_info      *gpe_xrupt_info,
-	struct acpi_gpe_block_info      *gpe_block)
+acpi_hw_clear_gpe_block(struct acpi_gpe_xrupt_info * gpe_xrupt_info,
+			struct acpi_gpe_block_info * gpe_block)
 {
-	u32                             i;
-	acpi_status                     status;
-
+	u32 i;
+	acpi_status status;
 
 	/* Examine each GPE Register within the block */
 
 	for (i = 0; i < gpe_block->register_count; i++) {
 		/* Clear status on all GPEs in this register */
 
-		status = acpi_hw_low_level_write (8, 0xFF,
-				 &gpe_block->register_info[i].status_address);
-		if (ACPI_FAILURE (status)) {
+		status = acpi_hw_low_level_write(8, 0xFF,
+						 &gpe_block->register_info[i].
+						 status_address);
+		if (ACPI_FAILURE(status)) {
 			return (status);
 		}
 	}
@@ -280,7 +263,6 @@ acpi_hw_clear_gpe_block (
 	return (AE_OK);
 }
 
-
 /******************************************************************************
  *
  * FUNCTION:    acpi_hw_enable_runtime_gpe_block
@@ -296,13 +278,11 @@ acpi_hw_clear_gpe_block (
  ******************************************************************************/
 
 acpi_status
-acpi_hw_enable_runtime_gpe_block (
-	struct acpi_gpe_xrupt_info      *gpe_xrupt_info,
-	struct acpi_gpe_block_info      *gpe_block)
+acpi_hw_enable_runtime_gpe_block(struct acpi_gpe_xrupt_info * gpe_xrupt_info,
+				 struct acpi_gpe_block_info * gpe_block)
 {
-	u32                             i;
-	acpi_status                     status;
-
+	u32 i;
+	acpi_status status;
 
 	/* NOTE: assumes that all GPEs are currently disabled */
 
@@ -315,9 +295,13 @@ acpi_hw_enable_runtime_gpe_block (
 
 		/* Enable all "runtime" GPEs in this register */
 
-		status = acpi_hw_low_level_write (8, gpe_block->register_info[i].enable_for_run,
-				 &gpe_block->register_info[i].enable_address);
-		if (ACPI_FAILURE (status)) {
+		status =
+		    acpi_hw_low_level_write(8,
+					    gpe_block->register_info[i].
+					    enable_for_run,
+					    &gpe_block->register_info[i].
+					    enable_address);
+		if (ACPI_FAILURE(status)) {
 			return (status);
 		}
 	}
@@ -325,7 +309,6 @@ acpi_hw_enable_runtime_gpe_block (
 	return (AE_OK);
 }
 
-
 /******************************************************************************
  *
  * FUNCTION:    acpi_hw_enable_wakeup_gpe_block
@@ -341,13 +324,11 @@ acpi_hw_enable_runtime_gpe_block (
  ******************************************************************************/
 
 static acpi_status
-acpi_hw_enable_wakeup_gpe_block (
-	struct acpi_gpe_xrupt_info      *gpe_xrupt_info,
-	struct acpi_gpe_block_info      *gpe_block)
+acpi_hw_enable_wakeup_gpe_block(struct acpi_gpe_xrupt_info *gpe_xrupt_info,
+				struct acpi_gpe_block_info *gpe_block)
 {
-	u32                             i;
-	acpi_status                     status;
-
+	u32 i;
+	acpi_status status;
 
 	/* Examine each GPE Register within the block */
 
@@ -358,10 +339,12 @@ acpi_hw_enable_wakeup_gpe_block (
 
 		/* Enable all "wake" GPEs in this register */
 
-		status = acpi_hw_low_level_write (8,
-				 gpe_block->register_info[i].enable_for_wake,
-				 &gpe_block->register_info[i].enable_address);
-		if (ACPI_FAILURE (status)) {
+		status = acpi_hw_low_level_write(8,
+						 gpe_block->register_info[i].
+						 enable_for_wake,
+						 &gpe_block->register_info[i].
+						 enable_address);
+		if (ACPI_FAILURE(status)) {
 			return (status);
 		}
 	}
@@ -369,7 +352,6 @@ acpi_hw_enable_wakeup_gpe_block (
 	return (AE_OK);
 }
 
-
 /******************************************************************************
  *
  * FUNCTION:    acpi_hw_disable_all_gpes
@@ -382,22 +364,17 @@ acpi_hw_enable_wakeup_gpe_block (
  *
  ******************************************************************************/
 
-acpi_status
-acpi_hw_disable_all_gpes (
-	void)
+acpi_status acpi_hw_disable_all_gpes(void)
 {
-	acpi_status                     status;
-
+	acpi_status status;
 
-	ACPI_FUNCTION_TRACE ("hw_disable_all_gpes");
+	ACPI_FUNCTION_TRACE("hw_disable_all_gpes");
 
-
-	status = acpi_ev_walk_gpe_list (acpi_hw_disable_gpe_block);
-	status = acpi_ev_walk_gpe_list (acpi_hw_clear_gpe_block);
-	return_ACPI_STATUS (status);
+	status = acpi_ev_walk_gpe_list(acpi_hw_disable_gpe_block);
+	status = acpi_ev_walk_gpe_list(acpi_hw_clear_gpe_block);
+	return_ACPI_STATUS(status);
 }
 
-
 /******************************************************************************
  *
  * FUNCTION:    acpi_hw_enable_all_runtime_gpes
@@ -410,21 +387,16 @@ acpi_hw_disable_all_gpes (
  *
  ******************************************************************************/
 
-acpi_status
-acpi_hw_enable_all_runtime_gpes (
-	void)
+acpi_status acpi_hw_enable_all_runtime_gpes(void)
 {
-	acpi_status                     status;
-
+	acpi_status status;
 
-	ACPI_FUNCTION_TRACE ("hw_enable_all_runtime_gpes");
+	ACPI_FUNCTION_TRACE("hw_enable_all_runtime_gpes");
 
-
-	status = acpi_ev_walk_gpe_list (acpi_hw_enable_runtime_gpe_block);
-	return_ACPI_STATUS (status);
+	status = acpi_ev_walk_gpe_list(acpi_hw_enable_runtime_gpe_block);
+	return_ACPI_STATUS(status);
 }
 
-
 /******************************************************************************
  *
  * FUNCTION:    acpi_hw_enable_all_wakeup_gpes
@@ -437,17 +409,12 @@ acpi_hw_enable_all_runtime_gpes (
  *
  ******************************************************************************/
 
-acpi_status
-acpi_hw_enable_all_wakeup_gpes (
-	void)
+acpi_status acpi_hw_enable_all_wakeup_gpes(void)
 {
-	acpi_status                     status;
-
+	acpi_status status;
 
-	ACPI_FUNCTION_TRACE ("hw_enable_all_wakeup_gpes");
+	ACPI_FUNCTION_TRACE("hw_enable_all_wakeup_gpes");
 
-
-	status = acpi_ev_walk_gpe_list (acpi_hw_enable_wakeup_gpe_block);
-	return_ACPI_STATUS (status);
+	status = acpi_ev_walk_gpe_list(acpi_hw_enable_wakeup_gpe_block);
+	return_ACPI_STATUS(status);
 }
-
diff --git a/drivers/acpi/hardware/hwregs.c b/drivers/acpi/hardware/hwregs.c
index 04a058565d8d..536a7aea80c9 100644
--- a/drivers/acpi/hardware/hwregs.c
+++ b/drivers/acpi/hardware/hwregs.c
@@ -50,8 +50,7 @@
 #include <acpi/acevents.h>
 
 #define _COMPONENT          ACPI_HARDWARE
-	 ACPI_MODULE_NAME    ("hwregs")
-
+ACPI_MODULE_NAME("hwregs")
 
 /*******************************************************************************
  *
@@ -65,57 +64,52 @@
  *              THIS FUNCTION MUST BE CALLED WITH INTERRUPTS DISABLED
  *
  ******************************************************************************/
-
-acpi_status
-acpi_hw_clear_acpi_status (
-	u32                             flags)
+acpi_status acpi_hw_clear_acpi_status(u32 flags)
 {
-	acpi_status                     status;
-
+	acpi_status status;
 
-	ACPI_FUNCTION_TRACE ("hw_clear_acpi_status");
+	ACPI_FUNCTION_TRACE("hw_clear_acpi_status");
 
-
-	ACPI_DEBUG_PRINT ((ACPI_DB_IO, "About to write %04X to %04X\n",
-		ACPI_BITMASK_ALL_FIXED_STATUS,
-		(u16) acpi_gbl_FADT->xpm1a_evt_blk.address));
+	ACPI_DEBUG_PRINT((ACPI_DB_IO, "About to write %04X to %04X\n",
+			  ACPI_BITMASK_ALL_FIXED_STATUS,
+			  (u16) acpi_gbl_FADT->xpm1a_evt_blk.address));
 
 	if (flags & ACPI_MTX_LOCK) {
-		status = acpi_ut_acquire_mutex (ACPI_MTX_HARDWARE);
-		if (ACPI_FAILURE (status)) {
-			return_ACPI_STATUS (status);
+		status = acpi_ut_acquire_mutex(ACPI_MTX_HARDWARE);
+		if (ACPI_FAILURE(status)) {
+			return_ACPI_STATUS(status);
 		}
 	}
 
-	status = acpi_hw_register_write (ACPI_MTX_DO_NOT_LOCK,
-			 ACPI_REGISTER_PM1_STATUS,
-			 ACPI_BITMASK_ALL_FIXED_STATUS);
-	if (ACPI_FAILURE (status)) {
+	status = acpi_hw_register_write(ACPI_MTX_DO_NOT_LOCK,
+					ACPI_REGISTER_PM1_STATUS,
+					ACPI_BITMASK_ALL_FIXED_STATUS);
+	if (ACPI_FAILURE(status)) {
 		goto unlock_and_exit;
 	}
 
 	/* Clear the fixed events */
 
 	if (acpi_gbl_FADT->xpm1b_evt_blk.address) {
-		status = acpi_hw_low_level_write (16, ACPI_BITMASK_ALL_FIXED_STATUS,
-				 &acpi_gbl_FADT->xpm1b_evt_blk);
-		if (ACPI_FAILURE (status)) {
+		status =
+		    acpi_hw_low_level_write(16, ACPI_BITMASK_ALL_FIXED_STATUS,
+					    &acpi_gbl_FADT->xpm1b_evt_blk);
+		if (ACPI_FAILURE(status)) {
 			goto unlock_and_exit;
 		}
 	}
 
 	/* Clear the GPE Bits in all GPE registers in all GPE blocks */
 
-	status = acpi_ev_walk_gpe_list (acpi_hw_clear_gpe_block);
+	status = acpi_ev_walk_gpe_list(acpi_hw_clear_gpe_block);
 
-unlock_and_exit:
+      unlock_and_exit:
 	if (flags & ACPI_MTX_LOCK) {
-		(void) acpi_ut_release_mutex (ACPI_MTX_HARDWARE);
+		(void)acpi_ut_release_mutex(ACPI_MTX_HARDWARE);
 	}
-	return_ACPI_STATUS (status);
+	return_ACPI_STATUS(status);
 }
 
-
 /*******************************************************************************
  *
  * FUNCTION:    acpi_get_sleep_type_data
@@ -132,53 +126,48 @@ unlock_and_exit:
  ******************************************************************************/
 
 acpi_status
-acpi_get_sleep_type_data (
-	u8                              sleep_state,
-	u8                              *sleep_type_a,
-	u8                              *sleep_type_b)
+acpi_get_sleep_type_data(u8 sleep_state, u8 * sleep_type_a, u8 * sleep_type_b)
 {
-	acpi_status                     status = AE_OK;
-	struct acpi_parameter_info      info;
-	char                            *sleep_state_name;
-
-
-	ACPI_FUNCTION_TRACE ("acpi_get_sleep_type_data");
+	acpi_status status = AE_OK;
+	struct acpi_parameter_info info;
+	char *sleep_state_name;
 
+	ACPI_FUNCTION_TRACE("acpi_get_sleep_type_data");
 
 	/* Validate parameters */
 
-	if ((sleep_state > ACPI_S_STATES_MAX) ||
-		!sleep_type_a || !sleep_type_b) {
-		return_ACPI_STATUS (AE_BAD_PARAMETER);
+	if ((sleep_state > ACPI_S_STATES_MAX) || !sleep_type_a || !sleep_type_b) {
+		return_ACPI_STATUS(AE_BAD_PARAMETER);
 	}
 
 	/* Evaluate the namespace object containing the values for this state */
 
 	info.parameters = NULL;
 	info.return_object = NULL;
-	sleep_state_name = (char *) acpi_gbl_sleep_state_names[sleep_state];
+	sleep_state_name = (char *)acpi_gbl_sleep_state_names[sleep_state];
 
-	status = acpi_ns_evaluate_by_name (sleep_state_name, &info);
-	if (ACPI_FAILURE (status)) {
-		ACPI_DEBUG_PRINT ((ACPI_DB_EXEC,
-			"%s while evaluating sleep_state [%s]\n",
-			acpi_format_exception (status), sleep_state_name));
+	status = acpi_ns_evaluate_by_name(sleep_state_name, &info);
+	if (ACPI_FAILURE(status)) {
+		ACPI_DEBUG_PRINT((ACPI_DB_EXEC,
+				  "%s while evaluating sleep_state [%s]\n",
+				  acpi_format_exception(status),
+				  sleep_state_name));
 
-		return_ACPI_STATUS (status);
+		return_ACPI_STATUS(status);
 	}
 
 	/* Must have a return object */
 
 	if (!info.return_object) {
-		ACPI_REPORT_ERROR (("No Sleep State object returned from [%s]\n",
-			sleep_state_name));
+		ACPI_REPORT_ERROR(("No Sleep State object returned from [%s]\n",
+				   sleep_state_name));
 		status = AE_NOT_EXIST;
 	}
 
 	/* It must be of type Package */
 
-	else if (ACPI_GET_OBJECT_TYPE (info.return_object) != ACPI_TYPE_PACKAGE) {
-		ACPI_REPORT_ERROR (("Sleep State return object is not a Package\n"));
+	else if (ACPI_GET_OBJECT_TYPE(info.return_object) != ACPI_TYPE_PACKAGE) {
+		ACPI_REPORT_ERROR(("Sleep State return object is not a Package\n"));
 		status = AE_AML_OPERAND_TYPE;
 	}
 
@@ -190,45 +179,41 @@ acpi_get_sleep_type_data (
 	 * one per sleep type (A/B).
 	 */
 	else if (info.return_object->package.count < 2) {
-		ACPI_REPORT_ERROR ((
-			"Sleep State return package does not have at least two elements\n"));
+		ACPI_REPORT_ERROR(("Sleep State return package does not have at least two elements\n"));
 		status = AE_AML_NO_OPERAND;
 	}
 
 	/* The first two elements must both be of type Integer */
 
-	else if ((ACPI_GET_OBJECT_TYPE (info.return_object->package.elements[0])
-			 != ACPI_TYPE_INTEGER) ||
-			 (ACPI_GET_OBJECT_TYPE (info.return_object->package.elements[1])
-				!= ACPI_TYPE_INTEGER)) {
-		ACPI_REPORT_ERROR ((
-			"Sleep State return package elements are not both Integers (%s, %s)\n",
-			acpi_ut_get_object_type_name (info.return_object->package.elements[0]),
-			acpi_ut_get_object_type_name (info.return_object->package.elements[1])));
+	else if ((ACPI_GET_OBJECT_TYPE(info.return_object->package.elements[0])
+		  != ACPI_TYPE_INTEGER) ||
+		 (ACPI_GET_OBJECT_TYPE(info.return_object->package.elements[1])
+		  != ACPI_TYPE_INTEGER)) {
+		ACPI_REPORT_ERROR(("Sleep State return package elements are not both Integers (%s, %s)\n", acpi_ut_get_object_type_name(info.return_object->package.elements[0]), acpi_ut_get_object_type_name(info.return_object->package.elements[1])));
 		status = AE_AML_OPERAND_TYPE;
-	}
-	else {
+	} else {
 		/* Valid _Sx_ package size, type, and value */
 
 		*sleep_type_a = (u8)
-			(info.return_object->package.elements[0])->integer.value;
+		    (info.return_object->package.elements[0])->integer.value;
 		*sleep_type_b = (u8)
-			(info.return_object->package.elements[1])->integer.value;
+		    (info.return_object->package.elements[1])->integer.value;
 	}
 
-	if (ACPI_FAILURE (status)) {
-		ACPI_DEBUG_PRINT ((ACPI_DB_ERROR,
-			"%s While evaluating sleep_state [%s], bad Sleep object %p type %s\n",
-			acpi_format_exception (status),
-			sleep_state_name, info.return_object,
-			acpi_ut_get_object_type_name (info.return_object)));
+	if (ACPI_FAILURE(status)) {
+		ACPI_DEBUG_PRINT((ACPI_DB_ERROR,
+				  "%s While evaluating sleep_state [%s], bad Sleep object %p type %s\n",
+				  acpi_format_exception(status),
+				  sleep_state_name, info.return_object,
+				  acpi_ut_get_object_type_name(info.
+							       return_object)));
 	}
 
-	acpi_ut_remove_reference (info.return_object);
-	return_ACPI_STATUS (status);
+	acpi_ut_remove_reference(info.return_object);
+	return_ACPI_STATUS(status);
 }
-EXPORT_SYMBOL(acpi_get_sleep_type_data);
 
+EXPORT_SYMBOL(acpi_get_sleep_type_data);
 
 /*******************************************************************************
  *
@@ -242,22 +227,20 @@ EXPORT_SYMBOL(acpi_get_sleep_type_data);
  *
  ******************************************************************************/
 
-struct acpi_bit_register_info *
-acpi_hw_get_bit_register_info (
-	u32                             register_id)
+struct acpi_bit_register_info *acpi_hw_get_bit_register_info(u32 register_id)
 {
-	ACPI_FUNCTION_NAME ("hw_get_bit_register_info");
-
+	ACPI_FUNCTION_NAME("hw_get_bit_register_info");
 
 	if (register_id > ACPI_BITREG_MAX) {
-		ACPI_DEBUG_PRINT ((ACPI_DB_ERROR, "Invalid bit_register ID: %X\n", register_id));
+		ACPI_DEBUG_PRINT((ACPI_DB_ERROR,
+				  "Invalid bit_register ID: %X\n",
+				  register_id));
 		return (NULL);
 	}
 
 	return (&acpi_gbl_bit_register_info[register_id]);
 }
 
-
 /*******************************************************************************
  *
  * FUNCTION:    acpi_get_register
@@ -273,59 +256,56 @@ acpi_hw_get_bit_register_info (
  *
  ******************************************************************************/
 
-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 flags)
 {
-	u32                             register_value = 0;
-	struct acpi_bit_register_info   *bit_reg_info;
-	acpi_status                     status;
-
-
-	ACPI_FUNCTION_TRACE ("acpi_get_register");
+	u32 register_value = 0;
+	struct acpi_bit_register_info *bit_reg_info;
+	acpi_status status;
 
+	ACPI_FUNCTION_TRACE("acpi_get_register");
 
 	/* Get the info structure corresponding to the requested ACPI Register */
 
-	bit_reg_info = acpi_hw_get_bit_register_info (register_id);
+	bit_reg_info = acpi_hw_get_bit_register_info(register_id);
 	if (!bit_reg_info) {
-		return_ACPI_STATUS (AE_BAD_PARAMETER);
+		return_ACPI_STATUS(AE_BAD_PARAMETER);
 	}
 
 	if (flags & ACPI_MTX_LOCK) {
-		status = acpi_ut_acquire_mutex (ACPI_MTX_HARDWARE);
-		if (ACPI_FAILURE (status)) {
-			return_ACPI_STATUS (status);
+		status = acpi_ut_acquire_mutex(ACPI_MTX_HARDWARE);
+		if (ACPI_FAILURE(status)) {
+			return_ACPI_STATUS(status);
 		}
 	}
 
 	/* Read from the register */
 
-	status = acpi_hw_register_read (ACPI_MTX_DO_NOT_LOCK,
-			  bit_reg_info->parent_register, &register_value);
+	status = acpi_hw_register_read(ACPI_MTX_DO_NOT_LOCK,
+				       bit_reg_info->parent_register,
+				       &register_value);
 
 	if (flags & ACPI_MTX_LOCK) {
-		(void) acpi_ut_release_mutex (ACPI_MTX_HARDWARE);
+		(void)acpi_ut_release_mutex(ACPI_MTX_HARDWARE);
 	}
 
-	if (ACPI_SUCCESS (status)) {
+	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);
+		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));
+		ACPI_DEBUG_PRINT((ACPI_DB_IO, "Read value %8.8X register %X\n",
+				  register_value,
+				  bit_reg_info->parent_register));
 	}
 
-	return_ACPI_STATUS (status);
+	return_ACPI_STATUS(status);
 }
-EXPORT_SYMBOL(acpi_get_register);
 
+EXPORT_SYMBOL(acpi_get_register);
 
 /*******************************************************************************
  *
@@ -342,40 +322,36 @@ EXPORT_SYMBOL(acpi_get_register);
  *
  ******************************************************************************/
 
-acpi_status
-acpi_set_register (
-	u32                             register_id,
-	u32                             value,
-	u32                             flags)
+acpi_status acpi_set_register(u32 register_id, u32 value, u32 flags)
 {
-	u32                             register_value = 0;
-	struct acpi_bit_register_info   *bit_reg_info;
-	acpi_status                     status;
-
-
-	ACPI_FUNCTION_TRACE_U32 ("acpi_set_register", register_id);
+	u32 register_value = 0;
+	struct acpi_bit_register_info *bit_reg_info;
+	acpi_status status;
 
+	ACPI_FUNCTION_TRACE_U32("acpi_set_register", register_id);
 
 	/* Get the info structure corresponding to the requested ACPI Register */
 
-	bit_reg_info = acpi_hw_get_bit_register_info (register_id);
+	bit_reg_info = acpi_hw_get_bit_register_info(register_id);
 	if (!bit_reg_info) {
-		ACPI_REPORT_ERROR (("Bad ACPI HW register_id: %X\n", register_id));
-		return_ACPI_STATUS (AE_BAD_PARAMETER);
+		ACPI_REPORT_ERROR(("Bad ACPI HW register_id: %X\n",
+				   register_id));
+		return_ACPI_STATUS(AE_BAD_PARAMETER);
 	}
 
 	if (flags & ACPI_MTX_LOCK) {
-		status = acpi_ut_acquire_mutex (ACPI_MTX_HARDWARE);
-		if (ACPI_FAILURE (status)) {
-			return_ACPI_STATUS (status);
+		status = acpi_ut_acquire_mutex(ACPI_MTX_HARDWARE);
+		if (ACPI_FAILURE(status)) {
+			return_ACPI_STATUS(status);
 		}
 	}
 
 	/* Always do a register read first so we can insert the new bits  */
 
-	status = acpi_hw_register_read (ACPI_MTX_DO_NOT_LOCK,
-			 bit_reg_info->parent_register, &register_value);
-	if (ACPI_FAILURE (status)) {
+	status = acpi_hw_register_read(ACPI_MTX_DO_NOT_LOCK,
+				       bit_reg_info->parent_register,
+				       &register_value);
+	if (ACPI_FAILURE(status)) {
 		goto unlock_and_exit;
 	}
 
@@ -395,26 +371,30 @@ acpi_set_register (
 		 * information is the single bit we're interested in, all others should
 		 * be written as 0 so they will be left unchanged.
 		 */
-		value = ACPI_REGISTER_PREPARE_BITS (value,
-				 bit_reg_info->bit_position, bit_reg_info->access_bit_mask);
+		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_MTX_DO_NOT_LOCK,
-					 ACPI_REGISTER_PM1_STATUS, (u16) value);
+			status = acpi_hw_register_write(ACPI_MTX_DO_NOT_LOCK,
+							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);
+		ACPI_REGISTER_INSERT_VALUE(register_value,
+					   bit_reg_info->bit_position,
+					   bit_reg_info->access_bit_mask,
+					   value);
 
-		status = acpi_hw_register_write (ACPI_MTX_DO_NOT_LOCK,
-				 ACPI_REGISTER_PM1_ENABLE, (u16) register_value);
+		status = acpi_hw_register_write(ACPI_MTX_DO_NOT_LOCK,
+						ACPI_REGISTER_PM1_ENABLE,
+						(u16) register_value);
 		break;
 
-
 	case ACPI_REGISTER_PM1_CONTROL:
 
 		/*
@@ -422,65 +402,73 @@ acpi_set_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_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);
+		ACPI_REGISTER_INSERT_VALUE(register_value,
+					   bit_reg_info->bit_position,
+					   bit_reg_info->access_bit_mask,
+					   value);
 
-		status = acpi_hw_register_write (ACPI_MTX_DO_NOT_LOCK,
-				 ACPI_REGISTER_PM1_CONTROL, (u16) register_value);
+		status = acpi_hw_register_write(ACPI_MTX_DO_NOT_LOCK,
+						ACPI_REGISTER_PM1_CONTROL,
+						(u16) register_value);
 		break;
 
-
 	case ACPI_REGISTER_PM2_CONTROL:
 
-		status = acpi_hw_register_read (ACPI_MTX_DO_NOT_LOCK,
-				 ACPI_REGISTER_PM2_CONTROL, &register_value);
-		if (ACPI_FAILURE (status)) {
+		status = acpi_hw_register_read(ACPI_MTX_DO_NOT_LOCK,
+					       ACPI_REGISTER_PM2_CONTROL,
+					       &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_cnt_blk.address)));
-
-		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_cnt_blk.address)));
-
-		status = acpi_hw_register_write (ACPI_MTX_DO_NOT_LOCK,
-				 ACPI_REGISTER_PM2_CONTROL, (u8) (register_value));
+		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_cnt_blk.address)));
+
+		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_cnt_blk.address)));
+
+		status = acpi_hw_register_write(ACPI_MTX_DO_NOT_LOCK,
+						ACPI_REGISTER_PM2_CONTROL,
+						(u8) (register_value));
 		break;
 
-
 	default:
 		break;
 	}
 
-
-unlock_and_exit:
+      unlock_and_exit:
 
 	if (flags & ACPI_MTX_LOCK) {
-		(void) acpi_ut_release_mutex (ACPI_MTX_HARDWARE);
+		(void)acpi_ut_release_mutex(ACPI_MTX_HARDWARE);
 	}
 
 	/* Normalize the value that was read */
 
-	ACPI_DEBUG_EXEC (register_value =
-		((register_value & bit_reg_info->access_bit_mask) >>
-			bit_reg_info->bit_position));
+	ACPI_DEBUG_EXEC(register_value =
+			((register_value & bit_reg_info->access_bit_mask) >>
+			 bit_reg_info->bit_position));
 
-	ACPI_DEBUG_PRINT ((ACPI_DB_IO, "Set bits: %8.8X actual %8.8X register %X\n",
-			value, register_value, bit_reg_info->parent_register));
-	return_ACPI_STATUS (status);
+	ACPI_DEBUG_PRINT((ACPI_DB_IO,
+			  "Set bits: %8.8X actual %8.8X register %X\n", value,
+			  register_value, bit_reg_info->parent_register));
+	return_ACPI_STATUS(status);
 }
-EXPORT_SYMBOL(acpi_set_register);
 
+EXPORT_SYMBOL(acpi_set_register);
 
 /******************************************************************************
  *
@@ -498,103 +486,107 @@ EXPORT_SYMBOL(acpi_set_register);
  ******************************************************************************/
 
 acpi_status
-acpi_hw_register_read (
-	u8                              use_lock,
-	u32                             register_id,
-	u32                             *return_value)
+acpi_hw_register_read(u8 use_lock, u32 register_id, u32 * return_value)
 {
-	u32                             value1 = 0;
-	u32                             value2 = 0;
-	acpi_status                     status;
-
-
-	ACPI_FUNCTION_TRACE ("hw_register_read");
+	u32 value1 = 0;
+	u32 value2 = 0;
+	acpi_status status;
 
+	ACPI_FUNCTION_TRACE("hw_register_read");
 
 	if (ACPI_MTX_LOCK == use_lock) {
-		status = acpi_ut_acquire_mutex (ACPI_MTX_HARDWARE);
-		if (ACPI_FAILURE (status)) {
-			return_ACPI_STATUS (status);
+		status = acpi_ut_acquire_mutex(ACPI_MTX_HARDWARE);
+		if (ACPI_FAILURE(status)) {
+			return_ACPI_STATUS(status);
 		}
 	}
 
 	switch (register_id) {
-	case ACPI_REGISTER_PM1_STATUS:           /* 16-bit access */
+	case ACPI_REGISTER_PM1_STATUS:	/* 16-bit access */
 
-		status = acpi_hw_low_level_read (16, &value1, &acpi_gbl_FADT->xpm1a_evt_blk);
-		if (ACPI_FAILURE (status)) {
+		status =
+		    acpi_hw_low_level_read(16, &value1,
+					   &acpi_gbl_FADT->xpm1a_evt_blk);
+		if (ACPI_FAILURE(status)) {
 			goto unlock_and_exit;
 		}
 
 		/* PM1B is optional */
 
-		status = acpi_hw_low_level_read (16, &value2, &acpi_gbl_FADT->xpm1b_evt_blk);
+		status =
+		    acpi_hw_low_level_read(16, &value2,
+					   &acpi_gbl_FADT->xpm1b_evt_blk);
 		value1 |= value2;
 		break;
 
+	case ACPI_REGISTER_PM1_ENABLE:	/* 16-bit access */
 
-	case ACPI_REGISTER_PM1_ENABLE:           /* 16-bit access */
-
-		status = acpi_hw_low_level_read (16, &value1, &acpi_gbl_xpm1a_enable);
-		if (ACPI_FAILURE (status)) {
+		status =
+		    acpi_hw_low_level_read(16, &value1, &acpi_gbl_xpm1a_enable);
+		if (ACPI_FAILURE(status)) {
 			goto unlock_and_exit;
 		}
 
 		/* PM1B is optional */
 
-		status = acpi_hw_low_level_read (16, &value2, &acpi_gbl_xpm1b_enable);
+		status =
+		    acpi_hw_low_level_read(16, &value2, &acpi_gbl_xpm1b_enable);
 		value1 |= value2;
 		break;
 
+	case ACPI_REGISTER_PM1_CONTROL:	/* 16-bit access */
 
-	case ACPI_REGISTER_PM1_CONTROL:          /* 16-bit access */
-
-		status = acpi_hw_low_level_read (16, &value1, &acpi_gbl_FADT->xpm1a_cnt_blk);
-		if (ACPI_FAILURE (status)) {
+		status =
+		    acpi_hw_low_level_read(16, &value1,
+					   &acpi_gbl_FADT->xpm1a_cnt_blk);
+		if (ACPI_FAILURE(status)) {
 			goto unlock_and_exit;
 		}
 
-		status = acpi_hw_low_level_read (16, &value2, &acpi_gbl_FADT->xpm1b_cnt_blk);
+		status =
+		    acpi_hw_low_level_read(16, &value2,
+					   &acpi_gbl_FADT->xpm1b_cnt_blk);
 		value1 |= value2;
 		break;
 
+	case ACPI_REGISTER_PM2_CONTROL:	/* 8-bit access */
 
-	case ACPI_REGISTER_PM2_CONTROL:          /* 8-bit access */
-
-		status = acpi_hw_low_level_read (8, &value1, &acpi_gbl_FADT->xpm2_cnt_blk);
+		status =
+		    acpi_hw_low_level_read(8, &value1,
+					   &acpi_gbl_FADT->xpm2_cnt_blk);
 		break;
 
+	case ACPI_REGISTER_PM_TIMER:	/* 32-bit access */
 
-	case ACPI_REGISTER_PM_TIMER:             /* 32-bit access */
-
-		status = acpi_hw_low_level_read (32, &value1, &acpi_gbl_FADT->xpm_tmr_blk);
+		status =
+		    acpi_hw_low_level_read(32, &value1,
+					   &acpi_gbl_FADT->xpm_tmr_blk);
 		break;
 
-	case ACPI_REGISTER_SMI_COMMAND_BLOCK:    /* 8-bit access */
+	case ACPI_REGISTER_SMI_COMMAND_BLOCK:	/* 8-bit access */
 
-		status = acpi_os_read_port (acpi_gbl_FADT->smi_cmd, &value1, 8);
+		status = acpi_os_read_port(acpi_gbl_FADT->smi_cmd, &value1, 8);
 		break;
 
 	default:
-		ACPI_DEBUG_PRINT ((ACPI_DB_ERROR, "Unknown Register ID: %X\n",
-			register_id));
+		ACPI_DEBUG_PRINT((ACPI_DB_ERROR, "Unknown Register ID: %X\n",
+				  register_id));
 		status = AE_BAD_PARAMETER;
 		break;
 	}
 
-unlock_and_exit:
+      unlock_and_exit:
 	if (ACPI_MTX_LOCK == use_lock) {
-		(void) acpi_ut_release_mutex (ACPI_MTX_HARDWARE);
+		(void)acpi_ut_release_mutex(ACPI_MTX_HARDWARE);
 	}
 
-	if (ACPI_SUCCESS (status)) {
+	if (ACPI_SUCCESS(status)) {
 		*return_value = value1;
 	}
 
-	return_ACPI_STATUS (status);
+	return_ACPI_STATUS(status);
 }
 
-
 /******************************************************************************
  *
  * FUNCTION:    acpi_hw_register_write
@@ -610,109 +602,112 @@ unlock_and_exit:
  *
  ******************************************************************************/
 
-acpi_status
-acpi_hw_register_write (
-	u8                              use_lock,
-	u32                             register_id,
-	u32                             value)
+acpi_status acpi_hw_register_write(u8 use_lock, u32 register_id, u32 value)
 {
-	acpi_status                     status;
-
-
-	ACPI_FUNCTION_TRACE ("hw_register_write");
+	acpi_status status;
 
+	ACPI_FUNCTION_TRACE("hw_register_write");
 
 	if (ACPI_MTX_LOCK == use_lock) {
-		status = acpi_ut_acquire_mutex (ACPI_MTX_HARDWARE);
-		if (ACPI_FAILURE (status)) {
-			return_ACPI_STATUS (status);
+		status = acpi_ut_acquire_mutex(ACPI_MTX_HARDWARE);
+		if (ACPI_FAILURE(status)) {
+			return_ACPI_STATUS(status);
 		}
 	}
 
 	switch (register_id) {
-	case ACPI_REGISTER_PM1_STATUS:           /* 16-bit access */
+	case ACPI_REGISTER_PM1_STATUS:	/* 16-bit access */
 
-		status = acpi_hw_low_level_write (16, value, &acpi_gbl_FADT->xpm1a_evt_blk);
-		if (ACPI_FAILURE (status)) {
+		status =
+		    acpi_hw_low_level_write(16, value,
+					    &acpi_gbl_FADT->xpm1a_evt_blk);
+		if (ACPI_FAILURE(status)) {
 			goto unlock_and_exit;
 		}
 
 		/* PM1B is optional */
 
-		status = acpi_hw_low_level_write (16, value, &acpi_gbl_FADT->xpm1b_evt_blk);
+		status =
+		    acpi_hw_low_level_write(16, value,
+					    &acpi_gbl_FADT->xpm1b_evt_blk);
 		break;
 
+	case ACPI_REGISTER_PM1_ENABLE:	/* 16-bit access */
 
-	case ACPI_REGISTER_PM1_ENABLE:           /* 16-bit access*/
-
-		status = acpi_hw_low_level_write (16, value, &acpi_gbl_xpm1a_enable);
-		if (ACPI_FAILURE (status)) {
+		status =
+		    acpi_hw_low_level_write(16, value, &acpi_gbl_xpm1a_enable);
+		if (ACPI_FAILURE(status)) {
 			goto unlock_and_exit;
 		}
 
 		/* PM1B is optional */
 
-		status = acpi_hw_low_level_write (16, value, &acpi_gbl_xpm1b_enable);
+		status =
+		    acpi_hw_low_level_write(16, value, &acpi_gbl_xpm1b_enable);
 		break;
 
+	case ACPI_REGISTER_PM1_CONTROL:	/* 16-bit access */
 
-	case ACPI_REGISTER_PM1_CONTROL:          /* 16-bit access */
-
-		status = acpi_hw_low_level_write (16, value, &acpi_gbl_FADT->xpm1a_cnt_blk);
-		if (ACPI_FAILURE (status)) {
+		status =
+		    acpi_hw_low_level_write(16, value,
+					    &acpi_gbl_FADT->xpm1a_cnt_blk);
+		if (ACPI_FAILURE(status)) {
 			goto unlock_and_exit;
 		}
 
-		status = acpi_hw_low_level_write (16, value, &acpi_gbl_FADT->xpm1b_cnt_blk);
+		status =
+		    acpi_hw_low_level_write(16, value,
+					    &acpi_gbl_FADT->xpm1b_cnt_blk);
 		break;
 
+	case ACPI_REGISTER_PM1A_CONTROL:	/* 16-bit access */
 
-	case ACPI_REGISTER_PM1A_CONTROL:         /* 16-bit access */
-
-		status = acpi_hw_low_level_write (16, value, &acpi_gbl_FADT->xpm1a_cnt_blk);
+		status =
+		    acpi_hw_low_level_write(16, value,
+					    &acpi_gbl_FADT->xpm1a_cnt_blk);
 		break;
 
+	case ACPI_REGISTER_PM1B_CONTROL:	/* 16-bit access */
 
-	case ACPI_REGISTER_PM1B_CONTROL:         /* 16-bit access */
-
-		status = acpi_hw_low_level_write (16, value, &acpi_gbl_FADT->xpm1b_cnt_blk);
+		status =
+		    acpi_hw_low_level_write(16, value,
+					    &acpi_gbl_FADT->xpm1b_cnt_blk);
 		break;
 
+	case ACPI_REGISTER_PM2_CONTROL:	/* 8-bit access */
 
-	case ACPI_REGISTER_PM2_CONTROL:          /* 8-bit access */
-
-		status = acpi_hw_low_level_write (8, value, &acpi_gbl_FADT->xpm2_cnt_blk);
+		status =
+		    acpi_hw_low_level_write(8, value,
+					    &acpi_gbl_FADT->xpm2_cnt_blk);
 		break;
 
+	case ACPI_REGISTER_PM_TIMER:	/* 32-bit access */
 
-	case ACPI_REGISTER_PM_TIMER:             /* 32-bit access */
-
-		status = acpi_hw_low_level_write (32, value, &acpi_gbl_FADT->xpm_tmr_blk);
+		status =
+		    acpi_hw_low_level_write(32, value,
+					    &acpi_gbl_FADT->xpm_tmr_blk);
 		break;
 
-
-	case ACPI_REGISTER_SMI_COMMAND_BLOCK:    /* 8-bit access */
+	case ACPI_REGISTER_SMI_COMMAND_BLOCK:	/* 8-bit access */
 
 		/* SMI_CMD is currently always in IO space */
 
-		status = acpi_os_write_port (acpi_gbl_FADT->smi_cmd, value, 8);
+		status = acpi_os_write_port(acpi_gbl_FADT->smi_cmd, value, 8);
 		break;
 
-
 	default:
 		status = AE_BAD_PARAMETER;
 		break;
 	}
 
-unlock_and_exit:
+      unlock_and_exit:
 	if (ACPI_MTX_LOCK == use_lock) {
-		(void) acpi_ut_release_mutex (ACPI_MTX_HARDWARE);
+		(void)acpi_ut_release_mutex(ACPI_MTX_HARDWARE);
 	}
 
-	return_ACPI_STATUS (status);
+	return_ACPI_STATUS(status);
 }
 
-
 /******************************************************************************
  *
  * FUNCTION:    acpi_hw_low_level_read
@@ -728,17 +723,12 @@ unlock_and_exit:
  ******************************************************************************/
 
 acpi_status
-acpi_hw_low_level_read (
-	u32                             width,
-	u32                             *value,
-	struct acpi_generic_address     *reg)
+acpi_hw_low_level_read(u32 width, u32 * value, struct acpi_generic_address *reg)
 {
-	u64                             address;
-	acpi_status                     status;
-
-
-	ACPI_FUNCTION_NAME ("hw_low_level_read");
+	u64 address;
+	acpi_status status;
 
+	ACPI_FUNCTION_NAME("hw_low_level_read");
 
 	/*
 	 * Must have a valid pointer to a GAS structure, and
@@ -751,7 +741,7 @@ acpi_hw_low_level_read (
 
 	/* Get a local copy of the address.  Handles possible alignment issues */
 
-	ACPI_MOVE_64_TO_64 (&address, &reg->address);
+	ACPI_MOVE_64_TO_64(&address, &reg->address);
 	if (!address) {
 		return (AE_OK);
 	}
@@ -764,35 +754,32 @@ acpi_hw_low_level_read (
 	switch (reg->address_space_id) {
 	case ACPI_ADR_SPACE_SYSTEM_MEMORY:
 
-		status = acpi_os_read_memory (
-				 (acpi_physical_address) address,
-				 value, width);
+		status = acpi_os_read_memory((acpi_physical_address) address,
+					     value, width);
 		break;
 
-
 	case ACPI_ADR_SPACE_SYSTEM_IO:
 
-		status = acpi_os_read_port ((acpi_io_address) address,
-				 value, width);
+		status = acpi_os_read_port((acpi_io_address) address,
+					   value, width);
 		break;
 
-
 	default:
-		ACPI_DEBUG_PRINT ((ACPI_DB_ERROR,
-			"Unsupported address space: %X\n", reg->address_space_id));
+		ACPI_DEBUG_PRINT((ACPI_DB_ERROR,
+				  "Unsupported address space: %X\n",
+				  reg->address_space_id));
 		return (AE_BAD_PARAMETER);
 	}
 
-	ACPI_DEBUG_PRINT ((ACPI_DB_IO,
-		"Read:  %8.8X width %2d from %8.8X%8.8X (%s)\n",
-		*value, width,
-		ACPI_FORMAT_UINT64 (address),
-		acpi_ut_get_region_name (reg->address_space_id)));
+	ACPI_DEBUG_PRINT((ACPI_DB_IO,
+			  "Read:  %8.8X width %2d from %8.8X%8.8X (%s)\n",
+			  *value, width,
+			  ACPI_FORMAT_UINT64(address),
+			  acpi_ut_get_region_name(reg->address_space_id)));
 
 	return (status);
 }
 
-
 /******************************************************************************
  *
  * FUNCTION:    acpi_hw_low_level_write
@@ -808,17 +795,12 @@ acpi_hw_low_level_read (
  ******************************************************************************/
 
 acpi_status
-acpi_hw_low_level_write (
-	u32                             width,
-	u32                             value,
-	struct acpi_generic_address     *reg)
+acpi_hw_low_level_write(u32 width, u32 value, struct acpi_generic_address * reg)
 {
-	u64                             address;
-	acpi_status                     status;
-
-
-	ACPI_FUNCTION_NAME ("hw_low_level_write");
+	u64 address;
+	acpi_status status;
 
+	ACPI_FUNCTION_NAME("hw_low_level_write");
 
 	/*
 	 * Must have a valid pointer to a GAS structure, and
@@ -831,7 +813,7 @@ acpi_hw_low_level_write (
 
 	/* Get a local copy of the address.  Handles possible alignment issues */
 
-	ACPI_MOVE_64_TO_64 (&address, &reg->address);
+	ACPI_MOVE_64_TO_64(&address, &reg->address);
 	if (!address) {
 		return (AE_OK);
 	}
@@ -843,30 +825,28 @@ acpi_hw_low_level_write (
 	switch (reg->address_space_id) {
 	case ACPI_ADR_SPACE_SYSTEM_MEMORY:
 
-		status = acpi_os_write_memory (
-				 (acpi_physical_address) address,
-				 value, width);
+		status = acpi_os_write_memory((acpi_physical_address) address,
+					      value, width);
 		break;
 
-
 	case ACPI_ADR_SPACE_SYSTEM_IO:
 
-		status = acpi_os_write_port ((acpi_io_address) address,
-				 value, width);
+		status = acpi_os_write_port((acpi_io_address) address,
+					    value, width);
 		break;
 
-
 	default:
-		ACPI_DEBUG_PRINT ((ACPI_DB_ERROR,
-			"Unsupported address space: %X\n", reg->address_space_id));
+		ACPI_DEBUG_PRINT((ACPI_DB_ERROR,
+				  "Unsupported address space: %X\n",
+				  reg->address_space_id));
 		return (AE_BAD_PARAMETER);
 	}
 
-	ACPI_DEBUG_PRINT ((ACPI_DB_IO,
-		"Wrote: %8.8X width %2d   to %8.8X%8.8X (%s)\n",
-		value, width,
-		ACPI_FORMAT_UINT64 (address),
-		acpi_ut_get_region_name (reg->address_space_id)));
+	ACPI_DEBUG_PRINT((ACPI_DB_IO,
+			  "Wrote: %8.8X width %2d   to %8.8X%8.8X (%s)\n",
+			  value, width,
+			  ACPI_FORMAT_UINT64(address),
+			  acpi_ut_get_region_name(reg->address_space_id)));
 
 	return (status);
 }
diff --git a/drivers/acpi/hardware/hwsleep.c b/drivers/acpi/hardware/hwsleep.c
index cedee0c43b5f..34519069050c 100644
--- a/drivers/acpi/hardware/hwsleep.c
+++ b/drivers/acpi/hardware/hwsleep.c
@@ -46,8 +46,7 @@
 #include <acpi/acpi.h>
 
 #define _COMPONENT          ACPI_HARDWARE
-	 ACPI_MODULE_NAME    ("hwsleep")
-
+ACPI_MODULE_NAME("hwsleep")
 
 /*******************************************************************************
  *
@@ -61,30 +60,25 @@
  * DESCRIPTION: Access function for the firmware_waking_vector field in FACS
  *
  ******************************************************************************/
-
 acpi_status
-acpi_set_firmware_waking_vector (
-	acpi_physical_address physical_address)
+acpi_set_firmware_waking_vector(acpi_physical_address physical_address)
 {
 
-	ACPI_FUNCTION_TRACE ("acpi_set_firmware_waking_vector");
-
+	ACPI_FUNCTION_TRACE("acpi_set_firmware_waking_vector");
 
 	/* Set the vector */
 
 	if (acpi_gbl_common_fACS.vector_width == 32) {
-		*(ACPI_CAST_PTR (u32, acpi_gbl_common_fACS.firmware_waking_vector))
-				= (u32) physical_address;
-	}
-	else {
-		*acpi_gbl_common_fACS.firmware_waking_vector
-				= physical_address;
+		*(ACPI_CAST_PTR
+		  (u32, acpi_gbl_common_fACS.firmware_waking_vector))
+		    = (u32) physical_address;
+	} else {
+		*acpi_gbl_common_fACS.firmware_waking_vector = physical_address;
 	}
 
-	return_ACPI_STATUS (AE_OK);
+	return_ACPI_STATUS(AE_OK);
 }
 
-
 /*******************************************************************************
  *
  * FUNCTION:    acpi_get_firmware_waking_vector
@@ -101,33 +95,31 @@ acpi_set_firmware_waking_vector (
 
 #ifdef ACPI_FUTURE_USAGE
 acpi_status
-acpi_get_firmware_waking_vector (
-	acpi_physical_address *physical_address)
+acpi_get_firmware_waking_vector(acpi_physical_address * physical_address)
 {
 
-	ACPI_FUNCTION_TRACE ("acpi_get_firmware_waking_vector");
-
+	ACPI_FUNCTION_TRACE("acpi_get_firmware_waking_vector");
 
 	if (!physical_address) {
-		return_ACPI_STATUS (AE_BAD_PARAMETER);
+		return_ACPI_STATUS(AE_BAD_PARAMETER);
 	}
 
 	/* Get the vector */
 
 	if (acpi_gbl_common_fACS.vector_width == 32) {
 		*physical_address = (acpi_physical_address)
-			*(ACPI_CAST_PTR (u32, acpi_gbl_common_fACS.firmware_waking_vector));
-	}
-	else {
+		    *
+		    (ACPI_CAST_PTR
+		     (u32, acpi_gbl_common_fACS.firmware_waking_vector));
+	} else {
 		*physical_address =
-			*acpi_gbl_common_fACS.firmware_waking_vector;
+		    *acpi_gbl_common_fACS.firmware_waking_vector;
 	}
 
-	return_ACPI_STATUS (AE_OK);
+	return_ACPI_STATUS(AE_OK);
 }
 #endif
 
-
 /*******************************************************************************
  *
  * FUNCTION:    acpi_enter_sleep_state_prep
@@ -143,25 +135,22 @@ acpi_get_firmware_waking_vector (
  *
  ******************************************************************************/
 
-acpi_status
-acpi_enter_sleep_state_prep (
-	u8                          sleep_state)
+acpi_status acpi_enter_sleep_state_prep(u8 sleep_state)
 {
-	acpi_status                 status;
-	struct acpi_object_list     arg_list;
-	union acpi_object           arg;
-
-
-	ACPI_FUNCTION_TRACE ("acpi_enter_sleep_state_prep");
+	acpi_status status;
+	struct acpi_object_list arg_list;
+	union acpi_object arg;
 
+	ACPI_FUNCTION_TRACE("acpi_enter_sleep_state_prep");
 
 	/*
 	 * _PSW methods could be run here to enable wake-on keyboard, LAN, etc.
 	 */
-	status = acpi_get_sleep_type_data (sleep_state,
-			  &acpi_gbl_sleep_type_a, &acpi_gbl_sleep_type_b);
-	if (ACPI_FAILURE (status)) {
-		return_ACPI_STATUS (status);
+	status = acpi_get_sleep_type_data(sleep_state,
+					  &acpi_gbl_sleep_type_a,
+					  &acpi_gbl_sleep_type_b);
+	if (ACPI_FAILURE(status)) {
+		return_ACPI_STATUS(status);
 	}
 
 	/* Setup parameter object */
@@ -174,14 +163,14 @@ acpi_enter_sleep_state_prep (
 
 	/* Run the _PTS and _GTS methods */
 
-	status = acpi_evaluate_object (NULL, METHOD_NAME__PTS, &arg_list, NULL);
-	if (ACPI_FAILURE (status) && status != AE_NOT_FOUND) {
-		return_ACPI_STATUS (status);
+	status = acpi_evaluate_object(NULL, METHOD_NAME__PTS, &arg_list, NULL);
+	if (ACPI_FAILURE(status) && status != AE_NOT_FOUND) {
+		return_ACPI_STATUS(status);
 	}
 
-	status = acpi_evaluate_object (NULL, METHOD_NAME__GTS, &arg_list, NULL);
-	if (ACPI_FAILURE (status) && status != AE_NOT_FOUND) {
-		return_ACPI_STATUS (status);
+	status = acpi_evaluate_object(NULL, METHOD_NAME__GTS, &arg_list, NULL);
+	if (ACPI_FAILURE(status) && status != AE_NOT_FOUND) {
+		return_ACPI_STATUS(status);
 	}
 
 	/* Setup the argument to _SST */
@@ -202,22 +191,21 @@ acpi_enter_sleep_state_prep (
 		break;
 
 	default:
-		arg.integer.value = ACPI_SST_INDICATOR_OFF; /* Default is off */
+		arg.integer.value = ACPI_SST_INDICATOR_OFF;	/* Default is off */
 		break;
 	}
 
 	/* Set the system indicators to show the desired sleep state. */
 
-	status = acpi_evaluate_object (NULL, METHOD_NAME__SST, &arg_list, NULL);
-	if (ACPI_FAILURE (status) && status != AE_NOT_FOUND) {
-		 ACPI_REPORT_ERROR (("Method _SST failed, %s\n",
-			acpi_format_exception (status)));
+	status = acpi_evaluate_object(NULL, METHOD_NAME__SST, &arg_list, NULL);
+	if (ACPI_FAILURE(status) && status != AE_NOT_FOUND) {
+		ACPI_REPORT_ERROR(("Method _SST failed, %s\n",
+				   acpi_format_exception(status)));
 	}
 
-	return_ACPI_STATUS (AE_OK);
+	return_ACPI_STATUS(AE_OK);
 }
 
-
 /*******************************************************************************
  *
  * FUNCTION:    acpi_enter_sleep_state
@@ -231,80 +219,82 @@ acpi_enter_sleep_state_prep (
  *
  ******************************************************************************/
 
-acpi_status asmlinkage
-acpi_enter_sleep_state (
-	u8                              sleep_state)
+acpi_status asmlinkage acpi_enter_sleep_state(u8 sleep_state)
 {
-	u32                             PM1Acontrol;
-	u32                             PM1Bcontrol;
-	struct acpi_bit_register_info   *sleep_type_reg_info;
-	struct acpi_bit_register_info   *sleep_enable_reg_info;
-	u32                             in_value;
-	acpi_status                     status;
-
-
-	ACPI_FUNCTION_TRACE ("acpi_enter_sleep_state");
+	u32 PM1Acontrol;
+	u32 PM1Bcontrol;
+	struct acpi_bit_register_info *sleep_type_reg_info;
+	struct acpi_bit_register_info *sleep_enable_reg_info;
+	u32 in_value;
+	acpi_status status;
 
+	ACPI_FUNCTION_TRACE("acpi_enter_sleep_state");
 
 	if ((acpi_gbl_sleep_type_a > ACPI_SLEEP_TYPE_MAX) ||
-		(acpi_gbl_sleep_type_b > ACPI_SLEEP_TYPE_MAX)) {
-		ACPI_REPORT_ERROR (("Sleep values out of range: A=%X B=%X\n",
-			acpi_gbl_sleep_type_a, acpi_gbl_sleep_type_b));
-		return_ACPI_STATUS (AE_AML_OPERAND_VALUE);
+	    (acpi_gbl_sleep_type_b > ACPI_SLEEP_TYPE_MAX)) {
+		ACPI_REPORT_ERROR(("Sleep values out of range: A=%X B=%X\n",
+				   acpi_gbl_sleep_type_a,
+				   acpi_gbl_sleep_type_b));
+		return_ACPI_STATUS(AE_AML_OPERAND_VALUE);
 	}
 
-	sleep_type_reg_info = acpi_hw_get_bit_register_info (ACPI_BITREG_SLEEP_TYPE_A);
-	sleep_enable_reg_info = acpi_hw_get_bit_register_info (ACPI_BITREG_SLEEP_ENABLE);
+	sleep_type_reg_info =
+	    acpi_hw_get_bit_register_info(ACPI_BITREG_SLEEP_TYPE_A);
+	sleep_enable_reg_info =
+	    acpi_hw_get_bit_register_info(ACPI_BITREG_SLEEP_ENABLE);
 
 	/* Clear wake status */
 
-	status = acpi_set_register (ACPI_BITREG_WAKE_STATUS, 1, ACPI_MTX_DO_NOT_LOCK);
-	if (ACPI_FAILURE (status)) {
-		return_ACPI_STATUS (status);
+	status =
+	    acpi_set_register(ACPI_BITREG_WAKE_STATUS, 1, ACPI_MTX_DO_NOT_LOCK);
+	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);
-	if (ACPI_FAILURE (status)) {
-		return_ACPI_STATUS (status);
+	status = acpi_hw_clear_acpi_status(ACPI_MTX_DO_NOT_LOCK);
+	if (ACPI_FAILURE(status)) {
+		return_ACPI_STATUS(status);
 	}
 
 	/*
 	 * 1) Disable/Clear all GPEs
 	 * 2) Enable all wakeup GPEs
 	 */
-	status = acpi_hw_disable_all_gpes ();
-	if (ACPI_FAILURE (status)) {
-		return_ACPI_STATUS (status);
+	status = acpi_hw_disable_all_gpes();
+	if (ACPI_FAILURE(status)) {
+		return_ACPI_STATUS(status);
 	}
 	acpi_gbl_system_awake_and_running = FALSE;
 
-	status = acpi_hw_enable_all_wakeup_gpes ();
-	if (ACPI_FAILURE (status)) {
-		return_ACPI_STATUS (status);
+	status = acpi_hw_enable_all_wakeup_gpes();
+	if (ACPI_FAILURE(status)) {
+		return_ACPI_STATUS(status);
 	}
 
 	/* Get current value of PM1A control */
 
-	status = acpi_hw_register_read (ACPI_MTX_DO_NOT_LOCK,
-			 ACPI_REGISTER_PM1_CONTROL, &PM1Acontrol);
-	if (ACPI_FAILURE (status)) {
-		return_ACPI_STATUS (status);
+	status = acpi_hw_register_read(ACPI_MTX_DO_NOT_LOCK,
+				       ACPI_REGISTER_PM1_CONTROL, &PM1Acontrol);
+	if (ACPI_FAILURE(status)) {
+		return_ACPI_STATUS(status);
 	}
-	ACPI_DEBUG_PRINT ((ACPI_DB_INIT,
-		"Entering sleep state [S%d]\n", sleep_state));
+	ACPI_DEBUG_PRINT((ACPI_DB_INIT,
+			  "Entering sleep state [S%d]\n", sleep_state));
 
 	/* Clear SLP_EN and SLP_TYP fields */
 
 	PM1Acontrol &= ~(sleep_type_reg_info->access_bit_mask |
-			   sleep_enable_reg_info->access_bit_mask);
+			 sleep_enable_reg_info->access_bit_mask);
 	PM1Bcontrol = PM1Acontrol;
 
 	/* Insert SLP_TYP bits */
 
-	PM1Acontrol |= (acpi_gbl_sleep_type_a << sleep_type_reg_info->bit_position);
-	PM1Bcontrol |= (acpi_gbl_sleep_type_b << sleep_type_reg_info->bit_position);
+	PM1Acontrol |=
+	    (acpi_gbl_sleep_type_a << sleep_type_reg_info->bit_position);
+	PM1Bcontrol |=
+	    (acpi_gbl_sleep_type_b << sleep_type_reg_info->bit_position);
 
 	/*
 	 * We split the writes of SLP_TYP and SLP_EN to workaround
@@ -313,16 +303,18 @@ acpi_enter_sleep_state (
 
 	/* Write #1: fill in SLP_TYP data */
 
-	status = acpi_hw_register_write (ACPI_MTX_DO_NOT_LOCK,
-			 ACPI_REGISTER_PM1A_CONTROL, PM1Acontrol);
-	if (ACPI_FAILURE (status)) {
-		return_ACPI_STATUS (status);
+	status = acpi_hw_register_write(ACPI_MTX_DO_NOT_LOCK,
+					ACPI_REGISTER_PM1A_CONTROL,
+					PM1Acontrol);
+	if (ACPI_FAILURE(status)) {
+		return_ACPI_STATUS(status);
 	}
 
-	status = acpi_hw_register_write (ACPI_MTX_DO_NOT_LOCK,
-			 ACPI_REGISTER_PM1B_CONTROL, PM1Bcontrol);
-	if (ACPI_FAILURE (status)) {
-		return_ACPI_STATUS (status);
+	status = acpi_hw_register_write(ACPI_MTX_DO_NOT_LOCK,
+					ACPI_REGISTER_PM1B_CONTROL,
+					PM1Bcontrol);
+	if (ACPI_FAILURE(status)) {
+		return_ACPI_STATUS(status);
 	}
 
 	/* Insert SLP_ENABLE bit */
@@ -332,18 +324,20 @@ acpi_enter_sleep_state (
 
 	/* Write #2: SLP_TYP + SLP_EN */
 
-	ACPI_FLUSH_CPU_CACHE ();
+	ACPI_FLUSH_CPU_CACHE();
 
-	status = acpi_hw_register_write (ACPI_MTX_DO_NOT_LOCK,
-			 ACPI_REGISTER_PM1A_CONTROL, PM1Acontrol);
-	if (ACPI_FAILURE (status)) {
-		return_ACPI_STATUS (status);
+	status = acpi_hw_register_write(ACPI_MTX_DO_NOT_LOCK,
+					ACPI_REGISTER_PM1A_CONTROL,
+					PM1Acontrol);
+	if (ACPI_FAILURE(status)) {
+		return_ACPI_STATUS(status);
 	}
 
-	status = acpi_hw_register_write (ACPI_MTX_DO_NOT_LOCK,
-			 ACPI_REGISTER_PM1B_CONTROL, PM1Bcontrol);
-	if (ACPI_FAILURE (status)) {
-		return_ACPI_STATUS (status);
+	status = acpi_hw_register_write(ACPI_MTX_DO_NOT_LOCK,
+					ACPI_REGISTER_PM1B_CONTROL,
+					PM1Bcontrol);
+	if (ACPI_FAILURE(status)) {
+		return_ACPI_STATUS(status);
 	}
 
 	if (sleep_state > ACPI_STATE_S3) {
@@ -358,33 +352,34 @@ acpi_enter_sleep_state (
 		 * still read the right value. Ideally, this block would go
 		 * away entirely.
 		 */
-		acpi_os_stall (10000000);
-
-		status = acpi_hw_register_write (ACPI_MTX_DO_NOT_LOCK,
-				 ACPI_REGISTER_PM1_CONTROL,
-				 sleep_enable_reg_info->access_bit_mask);
-		if (ACPI_FAILURE (status)) {
-			return_ACPI_STATUS (status);
+		acpi_os_stall(10000000);
+
+		status = acpi_hw_register_write(ACPI_MTX_DO_NOT_LOCK,
+						ACPI_REGISTER_PM1_CONTROL,
+						sleep_enable_reg_info->
+						access_bit_mask);
+		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);
-		if (ACPI_FAILURE (status)) {
-			return_ACPI_STATUS (status);
+		status = acpi_get_register(ACPI_BITREG_WAKE_STATUS, &in_value,
+					   ACPI_MTX_DO_NOT_LOCK);
+		if (ACPI_FAILURE(status)) {
+			return_ACPI_STATUS(status);
 		}
 
 		/* Spin until we wake */
 
 	} while (!in_value);
 
-	return_ACPI_STATUS (AE_OK);
+	return_ACPI_STATUS(AE_OK);
 }
-EXPORT_SYMBOL(acpi_enter_sleep_state);
 
+EXPORT_SYMBOL(acpi_enter_sleep_state);
 
 /*******************************************************************************
  *
@@ -399,60 +394,57 @@ EXPORT_SYMBOL(acpi_enter_sleep_state);
  *
  ******************************************************************************/
 
-acpi_status asmlinkage
-acpi_enter_sleep_state_s4bios (
-	void)
+acpi_status asmlinkage acpi_enter_sleep_state_s4bios(void)
 {
-	u32                             in_value;
-	acpi_status                     status;
-
+	u32 in_value;
+	acpi_status status;
 
-	ACPI_FUNCTION_TRACE ("acpi_enter_sleep_state_s4bios");
+	ACPI_FUNCTION_TRACE("acpi_enter_sleep_state_s4bios");
 
-
-	status = acpi_set_register (ACPI_BITREG_WAKE_STATUS, 1, ACPI_MTX_DO_NOT_LOCK);
-	if (ACPI_FAILURE (status)) {
-		return_ACPI_STATUS (status);
+	status =
+	    acpi_set_register(ACPI_BITREG_WAKE_STATUS, 1, ACPI_MTX_DO_NOT_LOCK);
+	if (ACPI_FAILURE(status)) {
+		return_ACPI_STATUS(status);
 	}
 
-	status = acpi_hw_clear_acpi_status (ACPI_MTX_DO_NOT_LOCK);
-	if (ACPI_FAILURE (status)) {
-		return_ACPI_STATUS (status);
+	status = acpi_hw_clear_acpi_status(ACPI_MTX_DO_NOT_LOCK);
+	if (ACPI_FAILURE(status)) {
+		return_ACPI_STATUS(status);
 	}
 
 	/*
 	 * 1) Disable/Clear all GPEs
 	 * 2) Enable all wakeup GPEs
 	 */
-	status = acpi_hw_disable_all_gpes ();
-	if (ACPI_FAILURE (status)) {
-		return_ACPI_STATUS (status);
+	status = acpi_hw_disable_all_gpes();
+	if (ACPI_FAILURE(status)) {
+		return_ACPI_STATUS(status);
 	}
 	acpi_gbl_system_awake_and_running = FALSE;
 
-	status = acpi_hw_enable_all_wakeup_gpes ();
-	if (ACPI_FAILURE (status)) {
-		return_ACPI_STATUS (status);
+	status = acpi_hw_enable_all_wakeup_gpes();
+	if (ACPI_FAILURE(status)) {
+		return_ACPI_STATUS(status);
 	}
 
-	ACPI_FLUSH_CPU_CACHE ();
+	ACPI_FLUSH_CPU_CACHE();
 
-	status = acpi_os_write_port (acpi_gbl_FADT->smi_cmd,
-			 (u32) acpi_gbl_FADT->S4bios_req, 8);
+	status = acpi_os_write_port(acpi_gbl_FADT->smi_cmd,
+				    (u32) acpi_gbl_FADT->S4bios_req, 8);
 
 	do {
 		acpi_os_stall(1000);
-		status = acpi_get_register (ACPI_BITREG_WAKE_STATUS, &in_value,
-			ACPI_MTX_DO_NOT_LOCK);
-		if (ACPI_FAILURE (status)) {
-			return_ACPI_STATUS (status);
+		status = acpi_get_register(ACPI_BITREG_WAKE_STATUS, &in_value,
+					   ACPI_MTX_DO_NOT_LOCK);
+		if (ACPI_FAILURE(status)) {
+			return_ACPI_STATUS(status);
 		}
 	} while (!in_value);
 
-	return_ACPI_STATUS (AE_OK);
+	return_ACPI_STATUS(AE_OK);
 }
-EXPORT_SYMBOL(acpi_enter_sleep_state_s4bios);
 
+EXPORT_SYMBOL(acpi_enter_sleep_state_s4bios);
 
 /*******************************************************************************
  *
@@ -467,55 +459,62 @@ EXPORT_SYMBOL(acpi_enter_sleep_state_s4bios);
  *
  ******************************************************************************/
 
-acpi_status
-acpi_leave_sleep_state (
-	u8                              sleep_state)
+acpi_status acpi_leave_sleep_state(u8 sleep_state)
 {
-	struct acpi_object_list         arg_list;
-	union acpi_object               arg;
-	acpi_status                     status;
-	struct acpi_bit_register_info   *sleep_type_reg_info;
-	struct acpi_bit_register_info   *sleep_enable_reg_info;
-	u32                             PM1Acontrol;
-	u32                             PM1Bcontrol;
-
-
-	ACPI_FUNCTION_TRACE ("acpi_leave_sleep_state");
+	struct acpi_object_list arg_list;
+	union acpi_object arg;
+	acpi_status status;
+	struct acpi_bit_register_info *sleep_type_reg_info;
+	struct acpi_bit_register_info *sleep_enable_reg_info;
+	u32 PM1Acontrol;
+	u32 PM1Bcontrol;
 
+	ACPI_FUNCTION_TRACE("acpi_leave_sleep_state");
 
 	/*
 	 * Set SLP_TYPE and SLP_EN to state S0.
 	 * This is unclear from the ACPI Spec, but it is required
 	 * by some machines.
 	 */
-	status = acpi_get_sleep_type_data (ACPI_STATE_S0,
-			  &acpi_gbl_sleep_type_a, &acpi_gbl_sleep_type_b);
-	if (ACPI_SUCCESS (status)) {
-		sleep_type_reg_info = acpi_hw_get_bit_register_info (ACPI_BITREG_SLEEP_TYPE_A);
-		sleep_enable_reg_info = acpi_hw_get_bit_register_info (ACPI_BITREG_SLEEP_ENABLE);
+	status = acpi_get_sleep_type_data(ACPI_STATE_S0,
+					  &acpi_gbl_sleep_type_a,
+					  &acpi_gbl_sleep_type_b);
+	if (ACPI_SUCCESS(status)) {
+		sleep_type_reg_info =
+		    acpi_hw_get_bit_register_info(ACPI_BITREG_SLEEP_TYPE_A);
+		sleep_enable_reg_info =
+		    acpi_hw_get_bit_register_info(ACPI_BITREG_SLEEP_ENABLE);
 
 		/* Get current value of PM1A control */
 
-		status = acpi_hw_register_read (ACPI_MTX_DO_NOT_LOCK,
-				 ACPI_REGISTER_PM1_CONTROL, &PM1Acontrol);
-		if (ACPI_SUCCESS (status)) {
+		status = acpi_hw_register_read(ACPI_MTX_DO_NOT_LOCK,
+					       ACPI_REGISTER_PM1_CONTROL,
+					       &PM1Acontrol);
+		if (ACPI_SUCCESS(status)) {
 			/* Clear SLP_EN and SLP_TYP fields */
 
 			PM1Acontrol &= ~(sleep_type_reg_info->access_bit_mask |
-					   sleep_enable_reg_info->access_bit_mask);
+					 sleep_enable_reg_info->
+					 access_bit_mask);
 			PM1Bcontrol = PM1Acontrol;
 
 			/* Insert SLP_TYP bits */
 
-			PM1Acontrol |= (acpi_gbl_sleep_type_a << sleep_type_reg_info->bit_position);
-			PM1Bcontrol |= (acpi_gbl_sleep_type_b << sleep_type_reg_info->bit_position);
+			PM1Acontrol |=
+			    (acpi_gbl_sleep_type_a << sleep_type_reg_info->
+			     bit_position);
+			PM1Bcontrol |=
+			    (acpi_gbl_sleep_type_b << sleep_type_reg_info->
+			     bit_position);
 
 			/* Just ignore any errors */
 
-			(void) acpi_hw_register_write (ACPI_MTX_DO_NOT_LOCK,
-					  ACPI_REGISTER_PM1A_CONTROL, PM1Acontrol);
-			(void) acpi_hw_register_write (ACPI_MTX_DO_NOT_LOCK,
-					  ACPI_REGISTER_PM1B_CONTROL, PM1Bcontrol);
+			(void)acpi_hw_register_write(ACPI_MTX_DO_NOT_LOCK,
+						     ACPI_REGISTER_PM1A_CONTROL,
+						     PM1Acontrol);
+			(void)acpi_hw_register_write(ACPI_MTX_DO_NOT_LOCK,
+						     ACPI_REGISTER_PM1B_CONTROL,
+						     PM1Bcontrol);
 		}
 	}
 
@@ -532,23 +531,23 @@ acpi_leave_sleep_state (
 	/* Ignore any errors from these methods */
 
 	arg.integer.value = ACPI_SST_WAKING;
-	status = acpi_evaluate_object (NULL, METHOD_NAME__SST, &arg_list, NULL);
-	if (ACPI_FAILURE (status) && status != AE_NOT_FOUND) {
-		ACPI_REPORT_ERROR (("Method _SST failed, %s\n",
-			acpi_format_exception (status)));
+	status = acpi_evaluate_object(NULL, METHOD_NAME__SST, &arg_list, NULL);
+	if (ACPI_FAILURE(status) && status != AE_NOT_FOUND) {
+		ACPI_REPORT_ERROR(("Method _SST failed, %s\n",
+				   acpi_format_exception(status)));
 	}
 
 	arg.integer.value = sleep_state;
-	status = acpi_evaluate_object (NULL, METHOD_NAME__BFS, &arg_list, NULL);
-	if (ACPI_FAILURE (status) && status != AE_NOT_FOUND) {
-		ACPI_REPORT_ERROR (("Method _BFS failed, %s\n",
-			acpi_format_exception (status)));
+	status = acpi_evaluate_object(NULL, METHOD_NAME__BFS, &arg_list, NULL);
+	if (ACPI_FAILURE(status) && status != AE_NOT_FOUND) {
+		ACPI_REPORT_ERROR(("Method _BFS failed, %s\n",
+				   acpi_format_exception(status)));
 	}
 
-	status = acpi_evaluate_object (NULL, METHOD_NAME__WAK, &arg_list, NULL);
-	if (ACPI_FAILURE (status) && status != AE_NOT_FOUND) {
-		ACPI_REPORT_ERROR (("Method _WAK failed, %s\n",
-			acpi_format_exception (status)));
+	status = acpi_evaluate_object(NULL, METHOD_NAME__WAK, &arg_list, NULL);
+	if (ACPI_FAILURE(status) && status != AE_NOT_FOUND) {
+		ACPI_REPORT_ERROR(("Method _WAK failed, %s\n",
+				   acpi_format_exception(status)));
 	}
 	/* TBD: _WAK "sometimes" returns stuff - do we want to look at it? */
 
@@ -557,33 +556,35 @@ acpi_leave_sleep_state (
 	 * 1) Disable/Clear all GPEs
 	 * 2) Enable all runtime GPEs
 	 */
-	status = acpi_hw_disable_all_gpes ();
-	if (ACPI_FAILURE (status)) {
-		return_ACPI_STATUS (status);
+	status = acpi_hw_disable_all_gpes();
+	if (ACPI_FAILURE(status)) {
+		return_ACPI_STATUS(status);
 	}
 	acpi_gbl_system_awake_and_running = TRUE;
 
-	status = acpi_hw_enable_all_runtime_gpes ();
-	if (ACPI_FAILURE (status)) {
-		return_ACPI_STATUS (status);
+	status = acpi_hw_enable_all_runtime_gpes();
+	if (ACPI_FAILURE(status)) {
+		return_ACPI_STATUS(status);
 	}
 
 	/* Enable power button */
 
-	(void) acpi_set_register(
-			acpi_gbl_fixed_event_info[ACPI_EVENT_POWER_BUTTON].enable_register_id,
-			1, ACPI_MTX_DO_NOT_LOCK);
+	(void)
+	    acpi_set_register(acpi_gbl_fixed_event_info
+			      [ACPI_EVENT_POWER_BUTTON].enable_register_id, 1,
+			      ACPI_MTX_DO_NOT_LOCK);
 
-	(void) acpi_set_register(
-			acpi_gbl_fixed_event_info[ACPI_EVENT_POWER_BUTTON].status_register_id,
-			1, ACPI_MTX_DO_NOT_LOCK);
+	(void)
+	    acpi_set_register(acpi_gbl_fixed_event_info
+			      [ACPI_EVENT_POWER_BUTTON].status_register_id, 1,
+			      ACPI_MTX_DO_NOT_LOCK);
 
 	arg.integer.value = ACPI_SST_WORKING;
-	status = acpi_evaluate_object (NULL, METHOD_NAME__SST, &arg_list, NULL);
-	if (ACPI_FAILURE (status) && status != AE_NOT_FOUND) {
-		ACPI_REPORT_ERROR (("Method _SST failed, %s\n",
-			acpi_format_exception (status)));
+	status = acpi_evaluate_object(NULL, METHOD_NAME__SST, &arg_list, NULL);
+	if (ACPI_FAILURE(status) && status != AE_NOT_FOUND) {
+		ACPI_REPORT_ERROR(("Method _SST failed, %s\n",
+				   acpi_format_exception(status)));
 	}
 
-	return_ACPI_STATUS (status);
+	return_ACPI_STATUS(status);
 }
diff --git a/drivers/acpi/hardware/hwtimer.c b/drivers/acpi/hardware/hwtimer.c
index 49d7b395322e..aff6dc141784 100644
--- a/drivers/acpi/hardware/hwtimer.c
+++ b/drivers/acpi/hardware/hwtimer.c
@@ -46,8 +46,7 @@
 #include <acpi/acpi.h>
 
 #define _COMPONENT          ACPI_HARDWARE
-	 ACPI_MODULE_NAME    ("hwtimer")
-
+ACPI_MODULE_NAME("hwtimer")
 
 /******************************************************************************
  *
@@ -60,29 +59,23 @@
  * DESCRIPTION: Obtains resolution of the ACPI PM Timer (24 or 32 bits).
  *
  ******************************************************************************/
-
-acpi_status
-acpi_get_timer_resolution (
-	u32                             *resolution)
+acpi_status acpi_get_timer_resolution(u32 * resolution)
 {
-	ACPI_FUNCTION_TRACE ("acpi_get_timer_resolution");
-
+	ACPI_FUNCTION_TRACE("acpi_get_timer_resolution");
 
 	if (!resolution) {
-		return_ACPI_STATUS (AE_BAD_PARAMETER);
+		return_ACPI_STATUS(AE_BAD_PARAMETER);
 	}
 
 	if (0 == acpi_gbl_FADT->tmr_val_ext) {
 		*resolution = 24;
-	}
-	else {
+	} else {
 		*resolution = 32;
 	}
 
-	return_ACPI_STATUS (AE_OK);
+	return_ACPI_STATUS(AE_OK);
 }
 
-
 /******************************************************************************
  *
  * FUNCTION:    acpi_get_timer
@@ -95,26 +88,22 @@ acpi_get_timer_resolution (
  *
  ******************************************************************************/
 
-acpi_status
-acpi_get_timer (
-	u32                             *ticks)
+acpi_status acpi_get_timer(u32 * ticks)
 {
-	acpi_status                     status;
-
-
-	ACPI_FUNCTION_TRACE ("acpi_get_timer");
+	acpi_status status;
 
+	ACPI_FUNCTION_TRACE("acpi_get_timer");
 
 	if (!ticks) {
-		return_ACPI_STATUS (AE_BAD_PARAMETER);
+		return_ACPI_STATUS(AE_BAD_PARAMETER);
 	}
 
-	status = acpi_hw_low_level_read (32, ticks, &acpi_gbl_FADT->xpm_tmr_blk);
+	status = acpi_hw_low_level_read(32, ticks, &acpi_gbl_FADT->xpm_tmr_blk);
 
-	return_ACPI_STATUS (status);
+	return_ACPI_STATUS(status);
 }
-EXPORT_SYMBOL(acpi_get_timer);
 
+EXPORT_SYMBOL(acpi_get_timer);
 
 /******************************************************************************
  *
@@ -146,21 +135,16 @@ EXPORT_SYMBOL(acpi_get_timer);
  ******************************************************************************/
 
 acpi_status
-acpi_get_timer_duration (
-	u32                             start_ticks,
-	u32                             end_ticks,
-	u32                             *time_elapsed)
+acpi_get_timer_duration(u32 start_ticks, u32 end_ticks, u32 * time_elapsed)
 {
-	acpi_status                     status;
-	u32                             delta_ticks;
-	acpi_integer                    quotient;
-
-
-	ACPI_FUNCTION_TRACE ("acpi_get_timer_duration");
+	acpi_status status;
+	u32 delta_ticks;
+	acpi_integer quotient;
 
+	ACPI_FUNCTION_TRACE("acpi_get_timer_duration");
 
 	if (!time_elapsed) {
-		return_ACPI_STATUS (AE_BAD_PARAMETER);
+		return_ACPI_STATUS(AE_BAD_PARAMETER);
 	}
 
 	/*
@@ -169,22 +153,22 @@ acpi_get_timer_duration (
 	 */
 	if (start_ticks < end_ticks) {
 		delta_ticks = end_ticks - start_ticks;
-	}
-	else if (start_ticks > end_ticks) {
+	} else if (start_ticks > end_ticks) {
 		if (0 == acpi_gbl_FADT->tmr_val_ext) {
 			/* 24-bit Timer */
 
-			delta_ticks = (((0x00FFFFFF - start_ticks) + end_ticks) & 0x00FFFFFF);
-		}
-		else {
+			delta_ticks =
+			    (((0x00FFFFFF - start_ticks) +
+			      end_ticks) & 0x00FFFFFF);
+		} else {
 			/* 32-bit Timer */
 
 			delta_ticks = (0xFFFFFFFF - start_ticks) + end_ticks;
 		}
-	}
-	else /* start_ticks == end_ticks */ {
+	} else {		/* start_ticks == end_ticks */
+
 		*time_elapsed = 0;
-		return_ACPI_STATUS (AE_OK);
+		return_ACPI_STATUS(AE_OK);
 	}
 
 	/*
@@ -192,12 +176,11 @@ acpi_get_timer_duration (
 	 *
 	 * time_elapsed = (delta_ticks * 1000000) / PM_TIMER_FREQUENCY;
 	 */
-	status = acpi_ut_short_divide (((u64) delta_ticks) * 1000000,
-			 PM_TIMER_FREQUENCY, &quotient, NULL);
+	status = acpi_ut_short_divide(((u64) delta_ticks) * 1000000,
+				      PM_TIMER_FREQUENCY, &quotient, NULL);
 
 	*time_elapsed = (u32) quotient;
-	return_ACPI_STATUS (status);
+	return_ACPI_STATUS(status);
 }
 
 EXPORT_SYMBOL(acpi_get_timer_duration);
-