[ACPI] Lindent all ACPI files

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

1 files changed, 80 insertions, 96 deletions

diff --git a/drivers/acpi/acpi_memhotplug.c b/drivers/acpi/acpi_memhotplug.c
index 77285ffe41c5..01a1bd239263 100644
--- a/drivers/acpi/acpi_memhotplug.c
+++ b/drivers/acpi/acpi_memhotplug.c
@@ -32,7 +32,6 @@
 #include <linux/memory_hotplug.h>
 #include <acpi/acpi_drivers.h>
 
-
 #define ACPI_MEMORY_DEVICE_COMPONENT		0x08000000UL
 #define ACPI_MEMORY_DEVICE_CLASS		"memory"
 #define ACPI_MEMORY_DEVICE_HID			"PNP0C80"
@@ -41,8 +40,8 @@
 
 #define _COMPONENT		ACPI_MEMORY_DEVICE_COMPONENT
 
-ACPI_MODULE_NAME		("acpi_memory")
-MODULE_AUTHOR("Naveen B S <naveen.b.s@intel.com>");
+ACPI_MODULE_NAME("acpi_memory")
+    MODULE_AUTHOR("Naveen B S <naveen.b.s@intel.com>");
 MODULE_DESCRIPTION(ACPI_MEMORY_DEVICE_DRIVER_NAME);
 MODULE_LICENSE("GPL");
 
@@ -56,34 +55,33 @@ MODULE_LICENSE("GPL");
 #define MEMORY_POWER_ON_STATE	1
 #define MEMORY_POWER_OFF_STATE	2
 
-static int acpi_memory_device_add (struct acpi_device *device);
-static int acpi_memory_device_remove (struct acpi_device *device, int type);
+static int acpi_memory_device_add(struct acpi_device *device);
+static int acpi_memory_device_remove(struct acpi_device *device, int type);
 
 static struct acpi_driver acpi_memory_device_driver = {
-	.name =		ACPI_MEMORY_DEVICE_DRIVER_NAME,
-	.class =	ACPI_MEMORY_DEVICE_CLASS,
-	.ids =		ACPI_MEMORY_DEVICE_HID,
-	.ops =		{
-				.add =		acpi_memory_device_add,
-				.remove =	acpi_memory_device_remove,
-			},
+	.name = ACPI_MEMORY_DEVICE_DRIVER_NAME,
+	.class = ACPI_MEMORY_DEVICE_CLASS,
+	.ids = ACPI_MEMORY_DEVICE_HID,
+	.ops = {
+		.add = acpi_memory_device_add,
+		.remove = acpi_memory_device_remove,
+		},
 };
 
 struct acpi_memory_device {
 	acpi_handle handle;
-	unsigned int state;		/* State of the memory device */
+	unsigned int state;	/* State of the memory device */
 	unsigned short cache_attribute;	/* memory cache attribute */
-	unsigned short read_write_attribute;/* memory read/write attribute */
-	u64 start_addr;	/* Memory Range start physical addr */
-	u64 end_addr;	/* Memory Range end physical addr */
+	unsigned short read_write_attribute;	/* memory read/write attribute */
+	u64 start_addr;		/* Memory Range start physical addr */
+	u64 end_addr;		/* Memory Range end physical addr */
 };
 
-
 static int
 acpi_memory_get_device_resources(struct acpi_memory_device *mem_device)
 {
 	acpi_status status;
-	struct acpi_buffer buffer = {ACPI_ALLOCATE_BUFFER, NULL};
+	struct acpi_buffer buffer = { ACPI_ALLOCATE_BUFFER, NULL };
 	struct acpi_resource *resource = NULL;
 	struct acpi_resource_address64 address64;
 
@@ -94,15 +92,15 @@ acpi_memory_get_device_resources(struct acpi_memory_device *mem_device)
 	if (ACPI_FAILURE(status))
 		return_VALUE(-EINVAL);
 
-	resource = (struct acpi_resource *) buffer.pointer;
+	resource = (struct acpi_resource *)buffer.pointer;
 	status = acpi_resource_to_address64(resource, &address64);
 	if (ACPI_SUCCESS(status)) {
 		if (address64.resource_type == ACPI_MEMORY_RANGE) {
 			/* Populate the structure */
 			mem_device->cache_attribute =
-				address64.attribute.memory.cache_attribute;
+			    address64.attribute.memory.cache_attribute;
 			mem_device->read_write_attribute =
-			address64.attribute.memory.read_write_attribute;
+			    address64.attribute.memory.read_write_attribute;
 			mem_device->start_addr = address64.min_address_range;
 			mem_device->end_addr = address64.max_address_range;
 		}
@@ -114,7 +112,7 @@ acpi_memory_get_device_resources(struct acpi_memory_device *mem_device)
 
 static int
 acpi_memory_get_device(acpi_handle handle,
-	struct acpi_memory_device **mem_device)
+		       struct acpi_memory_device **mem_device)
 {
 	acpi_status status;
 	acpi_handle phandle;
@@ -128,8 +126,7 @@ acpi_memory_get_device(acpi_handle handle,
 
 	status = acpi_get_parent(handle, &phandle);
 	if (ACPI_FAILURE(status)) {
-		ACPI_DEBUG_PRINT((ACPI_DB_ERROR,
-			"Error in acpi_get_parent\n"));
+		ACPI_DEBUG_PRINT((ACPI_DB_ERROR, "Error in acpi_get_parent\n"));
 		return_VALUE(-EINVAL);
 	}
 
@@ -137,7 +134,7 @@ acpi_memory_get_device(acpi_handle handle,
 	status = acpi_bus_get_device(phandle, &pdevice);
 	if (ACPI_FAILURE(status)) {
 		ACPI_DEBUG_PRINT((ACPI_DB_ERROR,
-			"Error in acpi_bus_get_device\n"));
+				  "Error in acpi_bus_get_device\n"));
 		return_VALUE(-EINVAL);
 	}
 
@@ -147,23 +144,21 @@ acpi_memory_get_device(acpi_handle handle,
 	 */
 	status = acpi_bus_add(&device, pdevice, handle, ACPI_BUS_TYPE_DEVICE);
 	if (ACPI_FAILURE(status)) {
-		ACPI_DEBUG_PRINT((ACPI_DB_ERROR,
-			"Error in acpi_bus_add\n"));
+		ACPI_DEBUG_PRINT((ACPI_DB_ERROR, "Error in acpi_bus_add\n"));
 		return_VALUE(-EINVAL);
 	}
 
-end:
+      end:
 	*mem_device = acpi_driver_data(device);
 	if (!(*mem_device)) {
-		printk(KERN_ERR "\n driver data not found" );
+		printk(KERN_ERR "\n driver data not found");
 		return_VALUE(-ENODEV);
 	}
 
 	return_VALUE(0);
 }
 
-static int
-acpi_memory_check_device(struct acpi_memory_device *mem_device)
+static int acpi_memory_check_device(struct acpi_memory_device *mem_device)
 {
 	unsigned long current_status;
 
@@ -171,22 +166,21 @@ acpi_memory_check_device(struct acpi_memory_device *mem_device)
 
 	/* Get device present/absent information from the _STA */
 	if (ACPI_FAILURE(acpi_evaluate_integer(mem_device->handle, "_STA",
-		NULL, &current_status)))
+					       NULL, &current_status)))
 		return_VALUE(-ENODEV);
 	/*
 	 * Check for device status. Device should be
 	 * present/enabled/functioning.
 	 */
 	if (!((current_status & ACPI_MEMORY_STA_PRESENT)
-		&& (current_status & ACPI_MEMORY_STA_ENABLED)
-		&& (current_status & ACPI_MEMORY_STA_FUNCTIONAL)))
+	      && (current_status & ACPI_MEMORY_STA_ENABLED)
+	      && (current_status & ACPI_MEMORY_STA_FUNCTIONAL)))
 		return_VALUE(-ENODEV);
 
 	return_VALUE(0);
 }
 
-static int
-acpi_memory_enable_device(struct acpi_memory_device *mem_device)
+static int acpi_memory_enable_device(struct acpi_memory_device *mem_device)
 {
 	int result;
 
@@ -196,7 +190,7 @@ acpi_memory_enable_device(struct acpi_memory_device *mem_device)
 	result = acpi_memory_get_device_resources(mem_device);
 	if (result) {
 		ACPI_DEBUG_PRINT((ACPI_DB_ERROR,
-			"\nget_device_resources failed\n"));
+				  "\nget_device_resources failed\n"));
 		mem_device->state = MEMORY_INVALID_STATE;
 		return result;
 	}
@@ -206,11 +200,10 @@ acpi_memory_enable_device(struct acpi_memory_device *mem_device)
 	 * Note: Assume that this function returns zero on success
 	 */
 	result = add_memory(mem_device->start_addr,
-			(mem_device->end_addr - mem_device->start_addr) + 1,
-			mem_device->read_write_attribute);
+			    (mem_device->end_addr - mem_device->start_addr) + 1,
+			    mem_device->read_write_attribute);
 	if (result) {
-		ACPI_DEBUG_PRINT((ACPI_DB_ERROR,
-			"\nadd_memory failed\n"));
+		ACPI_DEBUG_PRINT((ACPI_DB_ERROR, "\nadd_memory failed\n"));
 		mem_device->state = MEMORY_INVALID_STATE;
 		return result;
 	}
@@ -218,11 +211,10 @@ acpi_memory_enable_device(struct acpi_memory_device *mem_device)
 	return result;
 }
 
-static int
-acpi_memory_powerdown_device(struct acpi_memory_device *mem_device)
+static int acpi_memory_powerdown_device(struct acpi_memory_device *mem_device)
 {
 	acpi_status status;
-	struct acpi_object_list	arg_list;
+	struct acpi_object_list arg_list;
 	union acpi_object arg;
 	unsigned long current_status;
 
@@ -234,16 +226,16 @@ acpi_memory_powerdown_device(struct acpi_memory_device *mem_device)
 	arg.type = ACPI_TYPE_INTEGER;
 	arg.integer.value = 1;
 	status = acpi_evaluate_object(mem_device->handle,
-			"_EJ0", &arg_list, NULL);
+				      "_EJ0", &arg_list, NULL);
 	/* Return on _EJ0 failure */
 	if (ACPI_FAILURE(status)) {
-		ACPI_DEBUG_PRINT((ACPI_DB_ERROR,"_EJ0 failed.\n"));
+		ACPI_DEBUG_PRINT((ACPI_DB_ERROR, "_EJ0 failed.\n"));
 		return_VALUE(-ENODEV);
 	}
 
 	/* Evalute _STA to check if the device is disabled */
 	status = acpi_evaluate_integer(mem_device->handle, "_STA",
-		NULL, &current_status);
+				       NULL, &current_status);
 	if (ACPI_FAILURE(status))
 		return_VALUE(-ENODEV);
 
@@ -254,8 +246,7 @@ acpi_memory_powerdown_device(struct acpi_memory_device *mem_device)
 	return_VALUE(0);
 }
 
-static int
-acpi_memory_disable_device(struct acpi_memory_device *mem_device)
+static int acpi_memory_disable_device(struct acpi_memory_device *mem_device)
 {
 	int result;
 	u64 start = mem_device->start_addr;
@@ -278,7 +269,7 @@ acpi_memory_disable_device(struct acpi_memory_device *mem_device)
 	result = acpi_memory_powerdown_device(mem_device);
 	if (result) {
 		ACPI_DEBUG_PRINT((ACPI_DB_ERROR,
-					"Device Power Down failed.\n"));
+				  "Device Power Down failed.\n"));
 		/* Set the status of the device to invalid */
 		mem_device->state = MEMORY_INVALID_STATE;
 		return result;
@@ -288,8 +279,7 @@ acpi_memory_disable_device(struct acpi_memory_device *mem_device)
 	return result;
 }
 
-static void
-acpi_memory_device_notify(acpi_handle handle, u32 event, void *data)
+static void acpi_memory_device_notify(acpi_handle handle, u32 event, void *data)
 {
 	struct acpi_memory_device *mem_device;
 	struct acpi_device *device;
@@ -299,37 +289,37 @@ acpi_memory_device_notify(acpi_handle handle, u32 event, void *data)
 	switch (event) {
 	case ACPI_NOTIFY_BUS_CHECK:
 		ACPI_DEBUG_PRINT((ACPI_DB_INFO,
-			"\nReceived BUS CHECK notification for device\n"));
+				  "\nReceived BUS CHECK notification for device\n"));
 		/* Fall Through */
 	case ACPI_NOTIFY_DEVICE_CHECK:
 		if (event == ACPI_NOTIFY_DEVICE_CHECK)
 			ACPI_DEBUG_PRINT((ACPI_DB_INFO,
-			"\nReceived DEVICE CHECK notification for device\n"));
+					  "\nReceived DEVICE CHECK notification for device\n"));
 		if (acpi_memory_get_device(handle, &mem_device)) {
 			ACPI_DEBUG_PRINT((ACPI_DB_ERROR,
-				"Error in finding driver data\n"));
+					  "Error in finding driver data\n"));
 			return_VOID;
 		}
 
 		if (!acpi_memory_check_device(mem_device)) {
 			if (acpi_memory_enable_device(mem_device))
 				ACPI_DEBUG_PRINT((ACPI_DB_ERROR,
-				"Error in acpi_memory_enable_device\n"));
+						  "Error in acpi_memory_enable_device\n"));
 		}
 		break;
 	case ACPI_NOTIFY_EJECT_REQUEST:
 		ACPI_DEBUG_PRINT((ACPI_DB_INFO,
-			"\nReceived EJECT REQUEST notification for device\n"));
+				  "\nReceived EJECT REQUEST notification for device\n"));
 
 		if (acpi_bus_get_device(handle, &device)) {
 			ACPI_DEBUG_PRINT((ACPI_DB_ERROR,
-					"Device doesn't exist\n"));
+					  "Device doesn't exist\n"));
 			break;
 		}
 		mem_device = acpi_driver_data(device);
 		if (!mem_device) {
 			ACPI_DEBUG_PRINT((ACPI_DB_ERROR,
-					"Driver Data is NULL\n"));
+					  "Driver Data is NULL\n"));
 			break;
 		}
 
@@ -337,26 +327,25 @@ acpi_memory_device_notify(acpi_handle handle, u32 event, void *data)
 		 * Currently disabling memory device from kernel mode
 		 * TBD: Can also be disabled from user mode scripts
 		 * TBD: Can also be disabled by Callback registration
-		 * 	with generic sysfs driver
+		 *      with generic sysfs driver
 		 */
 		if (acpi_memory_disable_device(mem_device))
 			ACPI_DEBUG_PRINT((ACPI_DB_ERROR,
-				"Error in acpi_memory_disable_device\n"));
+					  "Error in acpi_memory_disable_device\n"));
 		/*
 		 * TBD: Invoke acpi_bus_remove to cleanup data structures
 		 */
 		break;
 	default:
 		ACPI_DEBUG_PRINT((ACPI_DB_INFO,
-			"Unsupported event [0x%x]\n", event));
+				  "Unsupported event [0x%x]\n", event));
 		break;
 	}
 
 	return_VOID;
 }
 
-static int
-acpi_memory_device_add(struct acpi_device *device)
+static int acpi_memory_device_add(struct acpi_device *device)
 {
 	int result;
 	struct acpi_memory_device *mem_device = NULL;
@@ -391,8 +380,7 @@ acpi_memory_device_add(struct acpi_device *device)
 	return_VALUE(result);
 }
 
-static int
-acpi_memory_device_remove (struct acpi_device *device, int type)
+static int acpi_memory_device_remove(struct acpi_device *device, int type)
 {
 	struct acpi_memory_device *mem_device = NULL;
 
@@ -401,7 +389,7 @@ acpi_memory_device_remove (struct acpi_device *device, int type)
 	if (!device || !acpi_driver_data(device))
 		return_VALUE(-EINVAL);
 
-	mem_device = (struct acpi_memory_device *) acpi_driver_data(device);
+	mem_device = (struct acpi_memory_device *)acpi_driver_data(device);
 	kfree(mem_device);
 
 	return_VALUE(0);
@@ -410,12 +398,11 @@ acpi_memory_device_remove (struct acpi_device *device, int type)
 /*
  * Helper function to check for memory device
  */
-static acpi_status
-is_memory_device(acpi_handle handle)
+static acpi_status is_memory_device(acpi_handle handle)
 {
 	char *hardware_id;
 	acpi_status status;
-	struct acpi_buffer buffer = {ACPI_ALLOCATE_BUFFER, NULL};
+	struct acpi_buffer buffer = { ACPI_ALLOCATE_BUFFER, NULL };
 	struct acpi_device_info *info;
 
 	ACPI_FUNCTION_TRACE("is_memory_device");
@@ -432,7 +419,7 @@ is_memory_device(acpi_handle handle)
 
 	hardware_id = info->hardware_id.value;
 	if ((hardware_id == NULL) ||
-		(strcmp(hardware_id, ACPI_MEMORY_DEVICE_HID)))
+	    (strcmp(hardware_id, ACPI_MEMORY_DEVICE_HID)))
 		status = AE_ERROR;
 
 	acpi_os_free(buffer.pointer);
@@ -440,8 +427,8 @@ is_memory_device(acpi_handle handle)
 }
 
 static acpi_status
-acpi_memory_register_notify_handler (acpi_handle handle,
-	u32 level, void *ctxt, void **retv)
+acpi_memory_register_notify_handler(acpi_handle handle,
+				    u32 level, void *ctxt, void **retv)
 {
 	acpi_status status;
 
@@ -452,10 +439,10 @@ acpi_memory_register_notify_handler (acpi_handle handle,
 		return_ACPI_STATUS(AE_OK);	/* continue */
 
 	status = acpi_install_notify_handler(handle, ACPI_SYSTEM_NOTIFY,
-			acpi_memory_device_notify, NULL);
+					     acpi_memory_device_notify, NULL);
 	if (ACPI_FAILURE(status)) {
 		ACPI_DEBUG_PRINT((ACPI_DB_ERROR,
-			"Error installing notify handler\n"));
+				  "Error installing notify handler\n"));
 		return_ACPI_STATUS(AE_OK);	/* continue */
 	}
 
@@ -463,8 +450,8 @@ acpi_memory_register_notify_handler (acpi_handle handle,
 }
 
 static acpi_status
-acpi_memory_deregister_notify_handler (acpi_handle handle,
-			       u32 level, void *ctxt, void **retv)
+acpi_memory_deregister_notify_handler(acpi_handle handle,
+				      u32 level, void *ctxt, void **retv)
 {
 	acpi_status status;
 
@@ -475,18 +462,18 @@ acpi_memory_deregister_notify_handler (acpi_handle handle,
 		return_ACPI_STATUS(AE_OK);	/* continue */
 
 	status = acpi_remove_notify_handler(handle,
-			ACPI_SYSTEM_NOTIFY, acpi_memory_device_notify);
+					    ACPI_SYSTEM_NOTIFY,
+					    acpi_memory_device_notify);
 	if (ACPI_FAILURE(status)) {
 		ACPI_DEBUG_PRINT((ACPI_DB_ERROR,
-				"Error removing notify handler\n"));
+				  "Error removing notify handler\n"));
 		return_ACPI_STATUS(AE_OK);	/* continue */
 	}
 
 	return_ACPI_STATUS(status);
 }
 
-static int __init
-acpi_memory_device_init (void)
+static int __init acpi_memory_device_init(void)
 {
 	int result;
 	acpi_status status;
@@ -499,21 +486,20 @@ acpi_memory_device_init (void)
 		return_VALUE(-ENODEV);
 
 	status = acpi_walk_namespace(ACPI_TYPE_DEVICE, ACPI_ROOT_OBJECT,
-				ACPI_UINT32_MAX,
-				acpi_memory_register_notify_handler,
-				NULL, NULL);
+				     ACPI_UINT32_MAX,
+				     acpi_memory_register_notify_handler,
+				     NULL, NULL);
 
-	if (ACPI_FAILURE (status)) {
-		ACPI_DEBUG_PRINT ((ACPI_DB_ERROR, "walk_namespace failed\n"));
+	if (ACPI_FAILURE(status)) {
+		ACPI_DEBUG_PRINT((ACPI_DB_ERROR, "walk_namespace failed\n"));
 		acpi_bus_unregister_driver(&acpi_memory_device_driver);
 		return_VALUE(-ENODEV);
-        }
+	}
 
 	return_VALUE(0);
 }
 
-static void __exit
-acpi_memory_device_exit (void)
+static void __exit acpi_memory_device_exit(void)
 {
 	acpi_status status;
 
@@ -524,12 +510,12 @@ acpi_memory_device_exit (void)
 	 * handles.
 	 */
 	status = acpi_walk_namespace(ACPI_TYPE_DEVICE, ACPI_ROOT_OBJECT,
-			ACPI_UINT32_MAX,
-			acpi_memory_deregister_notify_handler,
-			NULL, NULL);
+				     ACPI_UINT32_MAX,
+				     acpi_memory_deregister_notify_handler,
+				     NULL, NULL);
 
-	if (ACPI_FAILURE (status))
-		ACPI_DEBUG_PRINT ((ACPI_DB_ERROR, "walk_namespace failed\n"));
+	if (ACPI_FAILURE(status))
+		ACPI_DEBUG_PRINT((ACPI_DB_ERROR, "walk_namespace failed\n"));
 
 	acpi_bus_unregister_driver(&acpi_memory_device_driver);
 
@@ -538,5 +524,3 @@ acpi_memory_device_exit (void)
 
 module_init(acpi_memory_device_init);
 module_exit(acpi_memory_device_exit);
-
-