USB: a bit more coding style cleanup

I was sitting in a train threatened to be blocked by ice. I took this
as a hint to do some more boring work for the common good. Here's
a bit more for coding style.

Signed-off-by: Oliver Neukum <oneukum@suse.de>
Signed-off-by: Greg Kroah-Hartman <gregkh@suse.de>

2 files changed, 25 insertions, 25 deletions

diff --git a/drivers/usb/core/buffer.c b/drivers/usb/core/buffer.c
index c3915dc28608..ead2475406b8 100644
--- a/drivers/usb/core/buffer.c
+++ b/drivers/usb/core/buffer.c
@@ -49,9 +49,9 @@ static const size_t	pool_max [HCD_BUFFER_POOLS] = {
  *
  * Call hcd_buffer_destroy() to clean up after using those pools.
  */
-int hcd_buffer_create (struct usb_hcd *hcd)
+int hcd_buffer_create(struct usb_hcd *hcd)
 {
-        char            name [16];
+        char            name[16];
         int             i, size;
 
         if (!hcd->self.controller->dma_mask)
@@ -60,11 +60,11 @@ int hcd_buffer_create (struct usb_hcd *hcd)
         for (i = 0; i < HCD_BUFFER_POOLS; i++) { 
                 if (!(size = pool_max [i]))
                         continue;
-                snprintf (name, sizeof name, "buffer-%d", size);
-                hcd->pool [i] = dma_pool_create (name, hcd->self.controller,
+                snprintf(name, sizeof name, "buffer-%d", size);
+                hcd->pool[i] = dma_pool_create(name, hcd->self.controller,
                                 size, size, 0);
                 if (!hcd->pool [i]) {
-                        hcd_buffer_destroy (hcd);
+                        hcd_buffer_destroy(hcd);
                         return -ENOMEM;
                 }
         }
@@ -79,14 +79,14 @@ int hcd_buffer_create (struct usb_hcd *hcd)
  *
  * This frees the buffer pools created by hcd_buffer_create().
  */
-void hcd_buffer_destroy (struct usb_hcd *hcd)
+void hcd_buffer_destroy(struct usb_hcd *hcd)
 {
         int             i;
 
         for (i = 0; i < HCD_BUFFER_POOLS; i++) { 
-                struct dma_pool         *pool = hcd->pool [i];
+                struct dma_pool         *pool = hcd->pool[i];
                 if (pool) {
-                        dma_pool_destroy (pool);
+                        dma_pool_destroy(pool);
                         hcd->pool[i] = NULL;
                 }
         }
@@ -97,8 +97,8 @@ void hcd_buffer_destroy (struct usb_hcd *hcd)
  * better sharing and to leverage mm/slab.c intelligence.
  */
 
-void *hcd_buffer_alloc (
-        struct usb_bus          *bus,
+void *hcd_buffer_alloc(
+        struct usb_bus  *bus,
         size_t                  size,
         gfp_t                   mem_flags,
         dma_addr_t              *dma
@@ -110,18 +110,18 @@ void *hcd_buffer_alloc (
         /* some USB hosts just use PIO */
         if (!bus->controller->dma_mask) {
                 *dma = ~(dma_addr_t) 0;
-                return kmalloc (size, mem_flags);
+                return kmalloc(size, mem_flags);
         }
 
         for (i = 0; i < HCD_BUFFER_POOLS; i++) {
                 if (size <= pool_max [i])
-                        return dma_pool_alloc (hcd->pool [i], mem_flags, dma);
+                        return dma_pool_alloc(hcd->pool [i], mem_flags, dma);
         }
-        return dma_alloc_coherent (hcd->self.controller, size, dma, 0);
+        return dma_alloc_coherent(hcd->self.controller, size, dma, 0);
 }
 
-void hcd_buffer_free (
-        struct usb_bus          *bus,
+void hcd_buffer_free(
+        struct usb_bus  *bus,
         size_t                  size,
         void                    *addr,
         dma_addr_t              dma
@@ -134,15 +134,15 @@ void hcd_buffer_free (
                 return;
 
         if (!bus->controller->dma_mask) {
-                kfree (addr);
+                kfree(addr);
                 return;
         }
 
         for (i = 0; i < HCD_BUFFER_POOLS; i++) {
                 if (size <= pool_max [i]) {
-                        dma_pool_free (hcd->pool [i], addr, dma);
+                        dma_pool_free(hcd->pool [i], addr, dma);
                         return;
                 }
         }
-        dma_free_coherent (hcd->self.controller, size, addr, dma);
+        dma_free_coherent(hcd->self.controller, size, addr, dma);
 }
diff --git a/drivers/usb/core/devices.c b/drivers/usb/core/devices.c
index 1ff429c37d52..a47c30b2d764 100644
--- a/drivers/usb/core/devices.c
+++ b/drivers/usb/core/devices.c
@@ -164,10 +164,10 @@ static const char *class_decode(const int class)
         for (ix = 0; clas_info[ix].class != -1; ix++)
                 if (clas_info[ix].class == class)
                         break;
-        return (clas_info[ix].class_name);
+        return clas_info[ix].class_name;
 }
 
-static char *usb_dump_endpoint_descriptor (
+static char *usb_dump_endpoint_descriptor(
         int speed,
         char *start,
         char *end,
@@ -212,9 +212,9 @@ static char *usb_dump_endpoint_descriptor (
                 break;
         case USB_ENDPOINT_XFER_INT:
                 type = "Int.";
-                if (speed == USB_SPEED_HIGH) {
+                if (speed == USB_SPEED_HIGH)
                         interval = 1 << (desc->bInterval - 1);
-                } else
+                else
                         interval = desc->bInterval;
                 break;
         default:        /* "can't happen" */
@@ -347,7 +347,7 @@ static char *usb_dump_device_descriptor(char *start, char *end, const struct usb
 
         if (start > end)
                 return start;
-        start += sprintf (start, format_device1,
+        start += sprintf(start, format_device1,
                           bcdUSB >> 8, bcdUSB & 0xff,
                           desc->bDeviceClass,
                           class_decode (desc->bDeviceClass),
@@ -367,7 +367,7 @@ static char *usb_dump_device_descriptor(char *start, char *end, const struct usb
 /*
  * Dump the different strings that this device holds.
  */
-static char *usb_dump_device_strings (char *start, char *end, struct usb_device *dev)
+static char *usb_dump_device_strings(char *start, char *end, struct usb_device *dev)
 {
         if (start > end)
                 return start;
@@ -399,7 +399,7 @@ static char *usb_dump_desc(char *start, char *end, struct usb_device *dev)
         if (start > end)
                 return start;
         
-        start = usb_dump_device_strings (start, end, dev);
+        start = usb_dump_device_strings(start, end, dev);
 
         for (i = 0; i < dev->descriptor.bNumConfigurations; i++) {
                 if (start > end)