1 files changed, 80 insertions, 93 deletions

diff --git a/drivers/acpi/namespace/nsxfname.c b/drivers/acpi/namespace/nsxfname.c
index 8d097914c49a..6b5f8d4481d1 100644
--- a/drivers/acpi/namespace/nsxfname.c
+++ b/drivers/acpi/namespace/nsxfname.c
@@ -47,10 +47,8 @@
 #include <acpi/acpi.h>
 #include <acpi/acnamesp.h>
 
-
 #define _COMPONENT          ACPI_NAMESPACE
-         ACPI_MODULE_NAME    ("nsxfname")
-
+ACPI_MODULE_NAME("nsxfname")
 
 /******************************************************************************
  *
@@ -69,20 +67,15 @@
  *              namespace handle.
  *
  ******************************************************************************/
-
 acpi_status
-acpi_get_handle (
-        acpi_handle                     parent,
-        acpi_string                     pathname,
-        acpi_handle                     *ret_handle)
+acpi_get_handle(acpi_handle parent,
+                acpi_string pathname, acpi_handle * ret_handle)
 {
-        acpi_status                     status;
-        struct acpi_namespace_node      *node = NULL;
-        struct acpi_namespace_node      *prefix_node = NULL;
-
-
-        ACPI_FUNCTION_ENTRY ();
+        acpi_status status;
+        struct acpi_namespace_node *node = NULL;
+        struct acpi_namespace_node *prefix_node = NULL;
 
+        ACPI_FUNCTION_ENTRY();
 
         /* Parameter Validation */
 
@@ -93,45 +86,47 @@ acpi_get_handle (
         /* Convert a parent handle to a prefix node */
 
         if (parent) {
-                status = acpi_ut_acquire_mutex (ACPI_MTX_NAMESPACE);
-                if (ACPI_FAILURE (status)) {
+                status = acpi_ut_acquire_mutex(ACPI_MTX_NAMESPACE);
+                if (ACPI_FAILURE(status)) {
                         return (status);
                 }
 
-                prefix_node = acpi_ns_map_handle_to_node (parent);
+                prefix_node = acpi_ns_map_handle_to_node(parent);
                 if (!prefix_node) {
-                        (void) acpi_ut_release_mutex (ACPI_MTX_NAMESPACE);
+                        (void)acpi_ut_release_mutex(ACPI_MTX_NAMESPACE);
                         return (AE_BAD_PARAMETER);
                 }
 
-                status = acpi_ut_release_mutex (ACPI_MTX_NAMESPACE);
-                if (ACPI_FAILURE (status)) {
+                status = acpi_ut_release_mutex(ACPI_MTX_NAMESPACE);
+                if (ACPI_FAILURE(status)) {
                         return (status);
                 }
         }
 
         /* Special case for root, since we can't search for it */
 
-        if (ACPI_STRCMP (pathname, ACPI_NS_ROOT_PATH) == 0) {
-                *ret_handle = acpi_ns_convert_entry_to_handle (acpi_gbl_root_node);
+        if (ACPI_STRCMP(pathname, ACPI_NS_ROOT_PATH) == 0) {
+                *ret_handle =
+                    acpi_ns_convert_entry_to_handle(acpi_gbl_root_node);
                 return (AE_OK);
         }
 
         /*
          *  Find the Node and convert to a handle
          */
-        status = acpi_ns_get_node_by_path (pathname, prefix_node, ACPI_NS_NO_UPSEARCH,
-                          &node);
+        status =
+            acpi_ns_get_node_by_path(pathname, prefix_node, ACPI_NS_NO_UPSEARCH,
+                                     &node);
 
         *ret_handle = NULL;
-        if (ACPI_SUCCESS (status)) {
-                *ret_handle = acpi_ns_convert_entry_to_handle (node);
+        if (ACPI_SUCCESS(status)) {
+                *ret_handle = acpi_ns_convert_entry_to_handle(node);
         }
 
         return (status);
 }
-EXPORT_SYMBOL(acpi_get_handle);
 
+EXPORT_SYMBOL(acpi_get_handle);
 
 /******************************************************************************
  *
@@ -150,14 +145,10 @@ EXPORT_SYMBOL(acpi_get_handle);
  ******************************************************************************/
 
 acpi_status
-acpi_get_name (
-        acpi_handle                     handle,
-        u32                             name_type,
-        struct acpi_buffer              *buffer)
+acpi_get_name(acpi_handle handle, u32 name_type, struct acpi_buffer * buffer)
 {
-        acpi_status                     status;
-        struct acpi_namespace_node      *node;
-
+        acpi_status status;
+        struct acpi_namespace_node *node;
 
         /* Parameter validation */
 
@@ -165,15 +156,15 @@ acpi_get_name (
                 return (AE_BAD_PARAMETER);
         }
 
-        status = acpi_ut_validate_buffer (buffer);
-        if (ACPI_FAILURE (status)) {
+        status = acpi_ut_validate_buffer(buffer);
+        if (ACPI_FAILURE(status)) {
                 return (status);
         }
 
         if (name_type == ACPI_FULL_PATHNAME) {
                 /* Get the full pathname (From the namespace root) */
 
-                status = acpi_ns_handle_to_pathname (handle, buffer);
+                status = acpi_ns_handle_to_pathname(handle, buffer);
                 return (status);
         }
 
@@ -181,12 +172,12 @@ acpi_get_name (
          * Wants the single segment ACPI name.
          * Validate handle and convert to a namespace Node
          */
-        status = acpi_ut_acquire_mutex (ACPI_MTX_NAMESPACE);
-        if (ACPI_FAILURE (status)) {
+        status = acpi_ut_acquire_mutex(ACPI_MTX_NAMESPACE);
+        if (ACPI_FAILURE(status)) {
                 return (status);
         }
 
-        node = acpi_ns_map_handle_to_node (handle);
+        node = acpi_ns_map_handle_to_node(handle);
         if (!node) {
                 status = AE_BAD_PARAMETER;
                 goto unlock_and_exit;
@@ -194,26 +185,25 @@ acpi_get_name (
 
         /* Validate/Allocate/Clear caller buffer */
 
-        status = acpi_ut_initialize_buffer (buffer, ACPI_PATH_SEGMENT_LENGTH);
-        if (ACPI_FAILURE (status)) {
+        status = acpi_ut_initialize_buffer(buffer, ACPI_PATH_SEGMENT_LENGTH);
+        if (ACPI_FAILURE(status)) {
                 goto unlock_and_exit;
         }
 
         /* Just copy the ACPI name from the Node and zero terminate it */
 
-        ACPI_STRNCPY (buffer->pointer, acpi_ut_get_node_name (node),
-                         ACPI_NAME_SIZE);
-        ((char *) buffer->pointer) [ACPI_NAME_SIZE] = 0;
+        ACPI_STRNCPY(buffer->pointer, acpi_ut_get_node_name(node),
+                     ACPI_NAME_SIZE);
+        ((char *)buffer->pointer)[ACPI_NAME_SIZE] = 0;
         status = AE_OK;
 
+      unlock_and_exit:
 
-unlock_and_exit:
-
-        (void) acpi_ut_release_mutex (ACPI_MTX_NAMESPACE);
+        (void)acpi_ut_release_mutex(ACPI_MTX_NAMESPACE);
         return (status);
 }
-EXPORT_SYMBOL(acpi_get_name);
 
+EXPORT_SYMBOL(acpi_get_name);
 
 /******************************************************************************
  *
@@ -231,17 +221,14 @@ EXPORT_SYMBOL(acpi_get_name);
  ******************************************************************************/
 
 acpi_status
-acpi_get_object_info (
-        acpi_handle                     handle,
-        struct acpi_buffer              *buffer)
+acpi_get_object_info(acpi_handle handle, struct acpi_buffer * buffer)
 {
-        acpi_status                     status;
-        struct acpi_namespace_node      *node;
-        struct acpi_device_info         *info;
-        struct acpi_device_info         *return_info;
+        acpi_status status;
+        struct acpi_namespace_node *node;
+        struct acpi_device_info *info;
+        struct acpi_device_info *return_info;
         struct acpi_compatible_id_list *cid_list = NULL;
-        acpi_size                       size;
-
+        acpi_size size;
 
         /* Parameter validation */
 
@@ -249,37 +236,37 @@ acpi_get_object_info (
                 return (AE_BAD_PARAMETER);
         }
 
-        status = acpi_ut_validate_buffer (buffer);
-        if (ACPI_FAILURE (status)) {
+        status = acpi_ut_validate_buffer(buffer);
+        if (ACPI_FAILURE(status)) {
                 return (status);
         }
 
-        info = ACPI_MEM_CALLOCATE (sizeof (struct acpi_device_info));
+        info = ACPI_MEM_CALLOCATE(sizeof(struct acpi_device_info));
         if (!info) {
                 return (AE_NO_MEMORY);
         }
 
-        status = acpi_ut_acquire_mutex (ACPI_MTX_NAMESPACE);
-        if (ACPI_FAILURE (status)) {
+        status = acpi_ut_acquire_mutex(ACPI_MTX_NAMESPACE);
+        if (ACPI_FAILURE(status)) {
                 goto cleanup;
         }
 
-        node = acpi_ns_map_handle_to_node (handle);
+        node = acpi_ns_map_handle_to_node(handle);
         if (!node) {
-                (void) acpi_ut_release_mutex (ACPI_MTX_NAMESPACE);
+                (void)acpi_ut_release_mutex(ACPI_MTX_NAMESPACE);
                 goto cleanup;
         }
 
         /* Init return structure */
 
-        size = sizeof (struct acpi_device_info);
+        size = sizeof(struct acpi_device_info);
 
-        info->type  = node->type;
-        info->name  = node->name.integer;
+        info->type = node->type;
+        info->name = node->name.integer;
         info->valid = 0;
 
-        status = acpi_ut_release_mutex (ACPI_MTX_NAMESPACE);
-        if (ACPI_FAILURE (status)) {
+        status = acpi_ut_release_mutex(ACPI_MTX_NAMESPACE);
+        if (ACPI_FAILURE(status)) {
                 goto cleanup;
         }
 
@@ -297,73 +284,73 @@ acpi_get_object_info (
 
                 /* Execute the Device._HID method */
 
-                status = acpi_ut_execute_HID (node, &info->hardware_id);
-                if (ACPI_SUCCESS (status)) {
+                status = acpi_ut_execute_HID(node, &info->hardware_id);
+                if (ACPI_SUCCESS(status)) {
                         info->valid |= ACPI_VALID_HID;
                 }
 
                 /* Execute the Device._UID method */
 
-                status = acpi_ut_execute_UID (node, &info->unique_id);
-                if (ACPI_SUCCESS (status)) {
+                status = acpi_ut_execute_UID(node, &info->unique_id);
+                if (ACPI_SUCCESS(status)) {
                         info->valid |= ACPI_VALID_UID;
                 }
 
                 /* Execute the Device._CID method */
 
-                status = acpi_ut_execute_CID (node, &cid_list);
-                if (ACPI_SUCCESS (status)) {
+                status = acpi_ut_execute_CID(node, &cid_list);
+                if (ACPI_SUCCESS(status)) {
                         size += ((acpi_size) cid_list->count - 1) *
-                                         sizeof (struct acpi_compatible_id);
+                            sizeof(struct acpi_compatible_id);
                         info->valid |= ACPI_VALID_CID;
                 }
 
                 /* Execute the Device._STA method */
 
-                status = acpi_ut_execute_STA (node, &info->current_status);
-                if (ACPI_SUCCESS (status)) {
+                status = acpi_ut_execute_STA(node, &info->current_status);
+                if (ACPI_SUCCESS(status)) {
                         info->valid |= ACPI_VALID_STA;
                 }
 
                 /* Execute the Device._ADR method */
 
-                status = acpi_ut_evaluate_numeric_object (METHOD_NAME__ADR, node,
-                                  &info->address);
-                if (ACPI_SUCCESS (status)) {
+                status = acpi_ut_evaluate_numeric_object(METHOD_NAME__ADR, node,
+                                                         &info->address);
+                if (ACPI_SUCCESS(status)) {
                         info->valid |= ACPI_VALID_ADR;
                 }
 
                 /* Execute the Device._sx_d methods */
 
-                status = acpi_ut_execute_sxds (node, info->highest_dstates);
-                if (ACPI_SUCCESS (status)) {
+                status = acpi_ut_execute_sxds(node, info->highest_dstates);
+                if (ACPI_SUCCESS(status)) {
                         info->valid |= ACPI_VALID_SXDS;
                 }
         }
 
         /* Validate/Allocate/Clear caller buffer */
 
-        status = acpi_ut_initialize_buffer (buffer, size);
-        if (ACPI_FAILURE (status)) {
+        status = acpi_ut_initialize_buffer(buffer, size);
+        if (ACPI_FAILURE(status)) {
                 goto cleanup;
         }
 
         /* Populate the return buffer */
 
         return_info = buffer->pointer;
-        ACPI_MEMCPY (return_info, info, sizeof (struct acpi_device_info));
+        ACPI_MEMCPY(return_info, info, sizeof(struct acpi_device_info));
 
         if (cid_list) {
-                ACPI_MEMCPY (&return_info->compatibility_id, cid_list, cid_list->size);
+                ACPI_MEMCPY(&return_info->compatibility_id, cid_list,
+                            cid_list->size);
         }
 
-
-cleanup:
-        ACPI_MEM_FREE (info);
+      cleanup:
+        ACPI_MEM_FREE(info);
         if (cid_list) {
-                ACPI_MEM_FREE (cid_list);
+                ACPI_MEM_FREE(cid_list);
         }
         return (status);
 }
-EXPORT_SYMBOL(acpi_get_object_info);
 
+EXPORT_SYMBOL(acpi_get_object_info);