[ACPI] Lindent all ACPI files

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

1 files changed, 126 insertions, 168 deletions

diff --git a/drivers/acpi/events/evmisc.c b/drivers/acpi/events/evmisc.c
index 3df3ada4b9e7..7e57b8470f55 100644
--- a/drivers/acpi/events/evmisc.c
+++ b/drivers/acpi/events/evmisc.c
@@ -47,12 +47,10 @@
 #include <acpi/acinterp.h>
 
 #define _COMPONENT          ACPI_EVENTS
-	 ACPI_MODULE_NAME    ("evmisc")
-
+ACPI_MODULE_NAME("evmisc")
 
 #ifdef ACPI_DEBUG_OUTPUT
-static const char                *acpi_notify_value_names[] =
-{
+static const char *acpi_notify_value_names[] = {
 	"Bus Check",
 	"Device Check",
 	"Device Wake",
@@ -66,18 +64,11 @@ static const char                *acpi_notify_value_names[] =
 
 /* Local prototypes */
 
-static void ACPI_SYSTEM_XFACE
-acpi_ev_notify_dispatch (
-	void                            *context);
-
-static void ACPI_SYSTEM_XFACE
-acpi_ev_global_lock_thread (
-	void                            *context);
+static void ACPI_SYSTEM_XFACE acpi_ev_notify_dispatch(void *context);
 
-static u32
-acpi_ev_global_lock_handler (
-	void                            *context);
+static void ACPI_SYSTEM_XFACE acpi_ev_global_lock_thread(void *context);
 
+static u32 acpi_ev_global_lock_handler(void *context);
 
 /*******************************************************************************
  *
@@ -93,9 +84,7 @@ acpi_ev_global_lock_handler (
  *
  ******************************************************************************/
 
-u8
-acpi_ev_is_notify_object (
-	struct acpi_namespace_node      *node)
+u8 acpi_ev_is_notify_object(struct acpi_namespace_node *node)
 {
 	switch (node->type) {
 	case ACPI_TYPE_DEVICE:
@@ -112,7 +101,6 @@ acpi_ev_is_notify_object (
 	}
 }
 
-
 /*******************************************************************************
  *
  * FUNCTION:    acpi_ev_queue_notify_request
@@ -128,18 +116,15 @@ acpi_ev_is_notify_object (
  ******************************************************************************/
 
 acpi_status
-acpi_ev_queue_notify_request (
-	struct acpi_namespace_node      *node,
-	u32                             notify_value)
+acpi_ev_queue_notify_request(struct acpi_namespace_node * node,
+			     u32 notify_value)
 {
-	union acpi_operand_object       *obj_desc;
-	union acpi_operand_object       *handler_obj = NULL;
-	union acpi_generic_state        *notify_info;
-	acpi_status                     status = AE_OK;
-
-
-	ACPI_FUNCTION_NAME ("ev_queue_notify_request");
+	union acpi_operand_object *obj_desc;
+	union acpi_operand_object *handler_obj = NULL;
+	union acpi_generic_state *notify_info;
+	acpi_status status = AE_OK;
 
+	ACPI_FUNCTION_NAME("ev_queue_notify_request");
 
 	/*
 	 * For value 3 (Ejection Request), some device method may need to be run.
@@ -148,22 +133,22 @@ acpi_ev_queue_notify_request (
 	 * For value 0x80 (Status Change) on the power button or sleep button,
 	 *   initiate soft-off or sleep operation?
 	 */
-	ACPI_DEBUG_PRINT ((ACPI_DB_INFO,
-		"Dispatching Notify(%X) on node %p\n", notify_value, node));
+	ACPI_DEBUG_PRINT((ACPI_DB_INFO,
+			  "Dispatching Notify(%X) on node %p\n", notify_value,
+			  node));
 
 	if (notify_value <= 7) {
-		ACPI_DEBUG_PRINT ((ACPI_DB_INFO, "Notify value: %s\n",
-				acpi_notify_value_names[notify_value]));
-	}
-	else {
-		ACPI_DEBUG_PRINT ((ACPI_DB_INFO,
-			"Notify value: 0x%2.2X **Device Specific**\n",
-			notify_value));
+		ACPI_DEBUG_PRINT((ACPI_DB_INFO, "Notify value: %s\n",
+				  acpi_notify_value_names[notify_value]));
+	} else {
+		ACPI_DEBUG_PRINT((ACPI_DB_INFO,
+				  "Notify value: 0x%2.2X **Device Specific**\n",
+				  notify_value));
 	}
 
 	/* Get the notify object attached to the NS Node */
 
-	obj_desc = acpi_ns_get_attached_object (node);
+	obj_desc = acpi_ns_get_attached_object(node);
 	if (obj_desc) {
 		/* We have the notify object, Get the right handler */
 
@@ -174,10 +159,11 @@ acpi_ev_queue_notify_request (
 		case ACPI_TYPE_POWER:
 
 			if (notify_value <= ACPI_MAX_SYS_NOTIFY) {
-				handler_obj = obj_desc->common_notify.system_notify;
-			}
-			else {
-				handler_obj = obj_desc->common_notify.device_notify;
+				handler_obj =
+				    obj_desc->common_notify.system_notify;
+			} else {
+				handler_obj =
+				    obj_desc->common_notify.device_notify;
 			}
 			break;
 
@@ -189,23 +175,25 @@ acpi_ev_queue_notify_request (
 
 	/* If there is any handler to run, schedule the dispatcher */
 
-	if ((acpi_gbl_system_notify.handler && (notify_value <= ACPI_MAX_SYS_NOTIFY)) ||
-		(acpi_gbl_device_notify.handler && (notify_value > ACPI_MAX_SYS_NOTIFY)) ||
-		handler_obj) {
-		notify_info = acpi_ut_create_generic_state ();
+	if ((acpi_gbl_system_notify.handler
+	     && (notify_value <= ACPI_MAX_SYS_NOTIFY))
+	    || (acpi_gbl_device_notify.handler
+		&& (notify_value > ACPI_MAX_SYS_NOTIFY)) || handler_obj) {
+		notify_info = acpi_ut_create_generic_state();
 		if (!notify_info) {
 			return (AE_NO_MEMORY);
 		}
 
 		notify_info->common.data_type = ACPI_DESC_TYPE_STATE_NOTIFY;
-		notify_info->notify.node      = node;
-		notify_info->notify.value     = (u16) notify_value;
+		notify_info->notify.node = node;
+		notify_info->notify.value = (u16) notify_value;
 		notify_info->notify.handler_obj = handler_obj;
 
-		status = acpi_os_queue_for_execution (OSD_PRIORITY_HIGH,
-				  acpi_ev_notify_dispatch, notify_info);
-		if (ACPI_FAILURE (status)) {
-			acpi_ut_delete_generic_state (notify_info);
+		status = acpi_os_queue_for_execution(OSD_PRIORITY_HIGH,
+						     acpi_ev_notify_dispatch,
+						     notify_info);
+		if (ACPI_FAILURE(status)) {
+			acpi_ut_delete_generic_state(notify_info);
 		}
 	}
 
@@ -214,15 +202,15 @@ acpi_ev_queue_notify_request (
 		 * There is no per-device notify handler for this device.
 		 * This may or may not be a problem.
 		 */
-		ACPI_DEBUG_PRINT ((ACPI_DB_INFO,
-			"No notify handler for Notify(%4.4s, %X) node %p\n",
-			acpi_ut_get_node_name (node), notify_value, node));
+		ACPI_DEBUG_PRINT((ACPI_DB_INFO,
+				  "No notify handler for Notify(%4.4s, %X) node %p\n",
+				  acpi_ut_get_node_name(node), notify_value,
+				  node));
 	}
 
 	return (status);
 }
 
-
 /*******************************************************************************
  *
  * FUNCTION:    acpi_ev_notify_dispatch
@@ -236,18 +224,15 @@ acpi_ev_queue_notify_request (
  *
  ******************************************************************************/
 
-static void ACPI_SYSTEM_XFACE
-acpi_ev_notify_dispatch (
-	void                            *context)
+static void ACPI_SYSTEM_XFACE acpi_ev_notify_dispatch(void *context)
 {
-	union acpi_generic_state        *notify_info = (union acpi_generic_state *) context;
-	acpi_notify_handler             global_handler = NULL;
-	void                            *global_context = NULL;
-	union acpi_operand_object       *handler_obj;
-
-
-	ACPI_FUNCTION_ENTRY ();
+	union acpi_generic_state *notify_info =
+	    (union acpi_generic_state *)context;
+	acpi_notify_handler global_handler = NULL;
+	void *global_context = NULL;
+	union acpi_operand_object *handler_obj;
 
+	ACPI_FUNCTION_ENTRY();
 
 	/*
 	 * We will invoke a global notify handler if installed.
@@ -261,8 +246,7 @@ acpi_ev_notify_dispatch (
 			global_handler = acpi_gbl_system_notify.handler;
 			global_context = acpi_gbl_system_notify.context;
 		}
-	}
-	else {
+	} else {
 		/* Global driver notification handler */
 
 		if (acpi_gbl_device_notify.handler) {
@@ -274,25 +258,24 @@ acpi_ev_notify_dispatch (
 	/* Invoke the system handler first, if present */
 
 	if (global_handler) {
-		global_handler (notify_info->notify.node, notify_info->notify.value,
-			global_context);
+		global_handler(notify_info->notify.node,
+			       notify_info->notify.value, global_context);
 	}
 
 	/* Now invoke the per-device handler, if present */
 
 	handler_obj = notify_info->notify.handler_obj;
 	if (handler_obj) {
-		handler_obj->notify.handler (notify_info->notify.node,
-			notify_info->notify.value,
-			handler_obj->notify.context);
+		handler_obj->notify.handler(notify_info->notify.node,
+					    notify_info->notify.value,
+					    handler_obj->notify.context);
 	}
 
 	/* All done with the info object */
 
-	acpi_ut_delete_generic_state (notify_info);
+	acpi_ut_delete_generic_state(notify_info);
 }
 
-
 /*******************************************************************************
  *
  * FUNCTION:    acpi_ev_global_lock_thread
@@ -307,27 +290,24 @@ acpi_ev_notify_dispatch (
  *
  ******************************************************************************/
 
-static void ACPI_SYSTEM_XFACE
-acpi_ev_global_lock_thread (
-	void                            *context)
+static void ACPI_SYSTEM_XFACE acpi_ev_global_lock_thread(void *context)
 {
-	acpi_status                     status;
-
+	acpi_status status;
 
 	/* Signal threads that are waiting for the lock */
 
 	if (acpi_gbl_global_lock_thread_count) {
 		/* Send sufficient units to the semaphore */
 
-		status = acpi_os_signal_semaphore (acpi_gbl_global_lock_semaphore,
-				 acpi_gbl_global_lock_thread_count);
-		if (ACPI_FAILURE (status)) {
-			ACPI_REPORT_ERROR (("Could not signal Global Lock semaphore\n"));
+		status =
+		    acpi_os_signal_semaphore(acpi_gbl_global_lock_semaphore,
+					     acpi_gbl_global_lock_thread_count);
+		if (ACPI_FAILURE(status)) {
+			ACPI_REPORT_ERROR(("Could not signal Global Lock semaphore\n"));
 		}
 	}
 }
 
-
 /*******************************************************************************
  *
  * FUNCTION:    acpi_ev_global_lock_handler
@@ -342,20 +322,17 @@ acpi_ev_global_lock_thread (
  *
  ******************************************************************************/
 
-static u32
-acpi_ev_global_lock_handler (
-	void                            *context)
+static u32 acpi_ev_global_lock_handler(void *context)
 {
-	u8                              acquired = FALSE;
-	acpi_status                     status;
-
+	u8 acquired = FALSE;
+	acpi_status status;
 
 	/*
 	 * Attempt to get the lock
 	 * If we don't get it now, it will be marked pending and we will
 	 * take another interrupt when it becomes free.
 	 */
-	ACPI_ACQUIRE_GLOBAL_LOCK (acpi_gbl_common_fACS.global_lock, acquired);
+	ACPI_ACQUIRE_GLOBAL_LOCK(acpi_gbl_common_fACS.global_lock, acquired);
 	if (acquired) {
 		/* Got the lock, now wake all threads waiting for it */
 
@@ -363,11 +340,11 @@ acpi_ev_global_lock_handler (
 
 		/* Run the Global Lock thread which will signal all waiting threads */
 
-		status = acpi_os_queue_for_execution (OSD_PRIORITY_HIGH,
-				  acpi_ev_global_lock_thread, context);
-		if (ACPI_FAILURE (status)) {
-			ACPI_REPORT_ERROR (("Could not queue Global Lock thread, %s\n",
-				acpi_format_exception (status)));
+		status = acpi_os_queue_for_execution(OSD_PRIORITY_HIGH,
+						     acpi_ev_global_lock_thread,
+						     context);
+		if (ACPI_FAILURE(status)) {
+			ACPI_REPORT_ERROR(("Could not queue Global Lock thread, %s\n", acpi_format_exception(status)));
 
 			return (ACPI_INTERRUPT_NOT_HANDLED);
 		}
@@ -376,7 +353,6 @@ acpi_ev_global_lock_handler (
 	return (ACPI_INTERRUPT_HANDLED);
 }
 
-
 /*******************************************************************************
  *
  * FUNCTION:    acpi_ev_init_global_lock_handler
@@ -389,19 +365,16 @@ acpi_ev_global_lock_handler (
  *
  ******************************************************************************/
 
-acpi_status
-acpi_ev_init_global_lock_handler (
-	void)
+acpi_status acpi_ev_init_global_lock_handler(void)
 {
-	acpi_status                     status;
-
-
-	ACPI_FUNCTION_TRACE ("ev_init_global_lock_handler");
+	acpi_status status;
 
+	ACPI_FUNCTION_TRACE("ev_init_global_lock_handler");
 
 	acpi_gbl_global_lock_present = TRUE;
-	status = acpi_install_fixed_event_handler (ACPI_EVENT_GLOBAL,
-			 acpi_ev_global_lock_handler, NULL);
+	status = acpi_install_fixed_event_handler(ACPI_EVENT_GLOBAL,
+						  acpi_ev_global_lock_handler,
+						  NULL);
 
 	/*
 	 * If the global lock does not exist on this platform, the attempt
@@ -411,17 +384,15 @@ acpi_ev_init_global_lock_handler (
 	 * with an error.
 	 */
 	if (status == AE_NO_HARDWARE_RESPONSE) {
-		ACPI_REPORT_ERROR ((
-			"No response from Global Lock hardware, disabling lock\n"));
+		ACPI_REPORT_ERROR(("No response from Global Lock hardware, disabling lock\n"));
 
 		acpi_gbl_global_lock_present = FALSE;
 		status = AE_OK;
 	}
 
-	return_ACPI_STATUS (status);
+	return_ACPI_STATUS(status);
 }
 
-
 /******************************************************************************
  *
  * FUNCTION:    acpi_ev_acquire_global_lock
@@ -434,22 +405,18 @@ acpi_ev_init_global_lock_handler (
  *
  *****************************************************************************/
 
-acpi_status
-acpi_ev_acquire_global_lock (
-	u16                             timeout)
+acpi_status acpi_ev_acquire_global_lock(u16 timeout)
 {
-	acpi_status                     status = AE_OK;
-	u8                              acquired = FALSE;
-
-
-	ACPI_FUNCTION_TRACE ("ev_acquire_global_lock");
+	acpi_status status = AE_OK;
+	u8 acquired = FALSE;
 
+	ACPI_FUNCTION_TRACE("ev_acquire_global_lock");
 
 #ifndef ACPI_APPLICATION
 	/* Make sure that we actually have a global lock */
 
 	if (!acpi_gbl_global_lock_present) {
-		return_ACPI_STATUS (AE_NO_GLOBAL_LOCK);
+		return_ACPI_STATUS(AE_NO_GLOBAL_LOCK);
 	}
 #endif
 
@@ -462,37 +429,37 @@ acpi_ev_acquire_global_lock (
 	 * we are done
 	 */
 	if (acpi_gbl_global_lock_acquired) {
-		return_ACPI_STATUS (AE_OK);
+		return_ACPI_STATUS(AE_OK);
 	}
 
 	/* We must acquire the actual hardware lock */
 
-	ACPI_ACQUIRE_GLOBAL_LOCK (acpi_gbl_common_fACS.global_lock, acquired);
+	ACPI_ACQUIRE_GLOBAL_LOCK(acpi_gbl_common_fACS.global_lock, acquired);
 	if (acquired) {
-	   /* We got the lock */
+		/* We got the lock */
 
-		ACPI_DEBUG_PRINT ((ACPI_DB_EXEC, "Acquired the HW Global Lock\n"));
+		ACPI_DEBUG_PRINT((ACPI_DB_EXEC,
+				  "Acquired the HW Global Lock\n"));
 
 		acpi_gbl_global_lock_acquired = TRUE;
-		return_ACPI_STATUS (AE_OK);
+		return_ACPI_STATUS(AE_OK);
 	}
 
 	/*
 	 * Did not get the lock.  The pending bit was set above, and we must now
 	 * wait until we get the global lock released interrupt.
 	 */
-	ACPI_DEBUG_PRINT ((ACPI_DB_EXEC, "Waiting for the HW Global Lock\n"));
+	ACPI_DEBUG_PRINT((ACPI_DB_EXEC, "Waiting for the HW Global Lock\n"));
 
 	/*
 	 * Acquire the global lock semaphore first.
 	 * Since this wait will block, we must release the interpreter
 	 */
-	status = acpi_ex_system_wait_semaphore (acpi_gbl_global_lock_semaphore,
-			  timeout);
-	return_ACPI_STATUS (status);
+	status = acpi_ex_system_wait_semaphore(acpi_gbl_global_lock_semaphore,
+					       timeout);
+	return_ACPI_STATUS(status);
 }
 
-
 /*******************************************************************************
  *
  * FUNCTION:    acpi_ev_release_global_lock
@@ -505,21 +472,16 @@ acpi_ev_acquire_global_lock (
  *
  ******************************************************************************/
 
-acpi_status
-acpi_ev_release_global_lock (
-	void)
+acpi_status acpi_ev_release_global_lock(void)
 {
-	u8                              pending = FALSE;
-	acpi_status                     status = AE_OK;
-
-
-	ACPI_FUNCTION_TRACE ("ev_release_global_lock");
+	u8 pending = FALSE;
+	acpi_status status = AE_OK;
 
+	ACPI_FUNCTION_TRACE("ev_release_global_lock");
 
 	if (!acpi_gbl_global_lock_thread_count) {
-		ACPI_REPORT_WARNING((
-			"Cannot release HW Global Lock, it has not been acquired\n"));
-		return_ACPI_STATUS (AE_NOT_ACQUIRED);
+		ACPI_REPORT_WARNING(("Cannot release HW Global Lock, it has not been acquired\n"));
+		return_ACPI_STATUS(AE_NOT_ACQUIRED);
 	}
 
 	/* One fewer thread has the global lock */
@@ -528,14 +490,14 @@ acpi_ev_release_global_lock (
 	if (acpi_gbl_global_lock_thread_count) {
 		/* There are still some threads holding the lock, cannot release */
 
-		return_ACPI_STATUS (AE_OK);
+		return_ACPI_STATUS(AE_OK);
 	}
 
 	/*
 	 * No more threads holding lock, we can do the actual hardware
 	 * release
 	 */
-	ACPI_RELEASE_GLOBAL_LOCK (acpi_gbl_common_fACS.global_lock, pending);
+	ACPI_RELEASE_GLOBAL_LOCK(acpi_gbl_common_fACS.global_lock, pending);
 	acpi_gbl_global_lock_acquired = FALSE;
 
 	/*
@@ -543,14 +505,13 @@ acpi_ev_release_global_lock (
 	 * register
 	 */
 	if (pending) {
-		status = acpi_set_register (ACPI_BITREG_GLOBAL_LOCK_RELEASE,
-				 1, ACPI_MTX_LOCK);
+		status = acpi_set_register(ACPI_BITREG_GLOBAL_LOCK_RELEASE,
+					   1, ACPI_MTX_LOCK);
 	}
 
-	return_ACPI_STATUS (status);
+	return_ACPI_STATUS(status);
 }
 
-
 /******************************************************************************
  *
  * FUNCTION:    acpi_ev_terminate
@@ -563,16 +524,12 @@ acpi_ev_release_global_lock (
  *
  ******************************************************************************/
 
-void
-acpi_ev_terminate (
-	void)
+void acpi_ev_terminate(void)
 {
-	acpi_native_uint                i;
-	acpi_status                     status;
-
-
-	ACPI_FUNCTION_TRACE ("ev_terminate");
+	acpi_native_uint i;
+	acpi_status status;
 
+	ACPI_FUNCTION_TRACE("ev_terminate");
 
 	if (acpi_gbl_events_initialized) {
 		/*
@@ -583,38 +540,39 @@ acpi_ev_terminate (
 		/* Disable all fixed events */
 
 		for (i = 0; i < ACPI_NUM_FIXED_EVENTS; i++) {
-			status = acpi_disable_event ((u32) i, 0);
-			if (ACPI_FAILURE (status)) {
-				ACPI_DEBUG_PRINT ((ACPI_DB_ERROR,
-					"Could not disable fixed event %d\n", (u32) i));
+			status = acpi_disable_event((u32) i, 0);
+			if (ACPI_FAILURE(status)) {
+				ACPI_DEBUG_PRINT((ACPI_DB_ERROR,
+						  "Could not disable fixed event %d\n",
+						  (u32) i));
 			}
 		}
 
 		/* Disable all GPEs in all GPE blocks */
 
-		status = acpi_ev_walk_gpe_list (acpi_hw_disable_gpe_block);
+		status = acpi_ev_walk_gpe_list(acpi_hw_disable_gpe_block);
 
 		/* Remove SCI handler */
 
-		status = acpi_ev_remove_sci_handler ();
+		status = acpi_ev_remove_sci_handler();
 		if (ACPI_FAILURE(status)) {
-			ACPI_DEBUG_PRINT ((ACPI_DB_ERROR,
-				"Could not remove SCI handler\n"));
+			ACPI_DEBUG_PRINT((ACPI_DB_ERROR,
+					  "Could not remove SCI handler\n"));
 		}
 	}
 
 	/* Deallocate all handler objects installed within GPE info structs */
 
-	status = acpi_ev_walk_gpe_list (acpi_ev_delete_gpe_handlers);
+	status = acpi_ev_walk_gpe_list(acpi_ev_delete_gpe_handlers);
 
 	/* Return to original mode if necessary */
 
 	if (acpi_gbl_original_mode == ACPI_SYS_MODE_LEGACY) {
-		status = acpi_disable ();
-		if (ACPI_FAILURE (status)) {
-			ACPI_DEBUG_PRINT ((ACPI_DB_WARN, "acpi_disable failed\n"));
+		status = acpi_disable();
+		if (ACPI_FAILURE(status)) {
+			ACPI_DEBUG_PRINT((ACPI_DB_WARN,
+					  "acpi_disable failed\n"));
 		}
 	}
 	return_VOID;
 }
-