Patchwork [U-Boot] USB-CDC: Fix coding style issues

login
register
mail settings
Submitter Vitaly Kuzmichev
Date Sept. 10, 2010, 12:48 p.m.
Message ID <1284122935-23045-1-git-send-email-vkuzmichev@mvista.com>
Download mbox | patch
Permalink /patch/71841/
State Accepted
Delegated to: Remy Bohmer
Headers show

Comments

Vitaly Kuzmichev - Sept. 10, 2010, 12:48 p.m.
Fixed most of checkpatch warnings and errors in USB gadget stack.

Signed-off-by: Vitaly Kuzmichev <vkuzmichev@mvista.com>
---
 drivers/usb/gadget/config.c       |    2 +-
 drivers/usb/gadget/epautoconf.c   |   73 ++++----
 drivers/usb/gadget/ether.c        |  385 ++++++++++++++++++-------------------
 drivers/usb/gadget/gadget_chips.h |   51 +++---
 drivers/usb/gadget/usbstring.c    |   42 ++--
 include/linux/usb/ch9.h           |    4 +-
 include/linux/usb/gadget.h        |   91 +++++-----
 7 files changed, 325 insertions(+), 323 deletions(-)

Patch

diff --git a/drivers/usb/gadget/config.c b/drivers/usb/gadget/config.c
index 84c90f0..cf22629 100644
--- a/drivers/usb/gadget/config.c
+++ b/drivers/usb/gadget/config.c
@@ -101,7 +101,7 @@  int usb_gadget_config_buf(
 	*cp = *config;
 
 	/* then interface/endpoint/class/vendor/... */
-	len = usb_descriptor_fillbuf(USB_DT_CONFIG_SIZE + (u8*)buf,
+	len = usb_descriptor_fillbuf(USB_DT_CONFIG_SIZE + (u8 *)buf,
 			length - USB_DT_CONFIG_SIZE, desc);
 	if (len < 0)
 		return len;
diff --git a/drivers/usb/gadget/epautoconf.c b/drivers/usb/gadget/epautoconf.c
index e11cc20..7cf3c67 100644
--- a/drivers/usb/gadget/epautoconf.c
+++ b/drivers/usb/gadget/epautoconf.c
@@ -32,7 +32,7 @@ 
 /* we must assign addresses for configurable endpoints (like net2280) */
 static unsigned epnum;
 
-// #define MANY_ENDPOINTS
+/* #define MANY_ENDPOINTS */
 #ifdef MANY_ENDPOINTS
 /* more than 15 configurable endpoints */
 static unsigned in_epnum;
@@ -55,8 +55,7 @@  static unsigned in_epnum;
  * NOTE:  each endpoint is unidirectional, as specified by its USB
  * descriptor; and isn't specific to a configuration or altsetting.
  */
-static int
-ep_matches (
+static int ep_matches(
 	struct usb_gadget		*gadget,
 	struct usb_ep			*ep,
 	struct usb_endpoint_descriptor	*desc
@@ -83,37 +82,37 @@  ep_matches (
 	 * direction-restriction:  "in", "out".
 	 */
 	if ('-' != ep->name[2]) {
-		tmp = strrchr (ep->name, '-');
+		tmp = strrchr(ep->name, '-');
 		if (tmp) {
 			switch (type) {
 			case USB_ENDPOINT_XFER_INT:
 				/* bulk endpoints handle interrupt transfers,
 				 * except the toggle-quirky iso-synch kind
 				 */
-				if ('s' == tmp[2])	// == "-iso"
+				if ('s' == tmp[2])	/* == "-iso" */
 					return 0;
 				/* for now, avoid PXA "interrupt-in";
 				 * it's documented as never using DATA1.
 				 */
-				if (gadget_is_pxa (gadget)
-						&& 'i' == tmp [1])
+				if (gadget_is_pxa(gadget)
+						&& 'i' == tmp[1])
 					return 0;
 				break;
 			case USB_ENDPOINT_XFER_BULK:
-				if ('b' != tmp[1])	// != "-bulk"
+				if ('b' != tmp[1])	/* != "-bulk" */
 					return 0;
 				break;
 			case USB_ENDPOINT_XFER_ISOC:
-				if ('s' != tmp[2])	// != "-iso"
+				if ('s' != tmp[2])	/* != "-iso" */
 					return 0;
 			}
 		} else {
-			tmp = ep->name + strlen (ep->name);
+			tmp = ep->name + strlen(ep->name);
 		}
 
 		/* direction-restriction:  "..in-..", "out-.." */
 		tmp--;
-		if (!isdigit (*tmp)) {
+		if (!isdigit(*tmp)) {
 			if (desc->bEndpointAddress & USB_DIR_IN) {
 				if ('n' != *tmp)
 					return 0;
@@ -155,8 +154,8 @@  ep_matches (
 	/* MATCH!! */
 
 	/* report address */
-	if (isdigit (ep->name [2])) {
-		u8	num = simple_strtoul (&ep->name [2], NULL, 10);
+	if (isdigit(ep->name[2])) {
+		u8	num = simple_strtoul(&ep->name[2], NULL, 10);
 		desc->bEndpointAddress |= num;
 #ifdef	MANY_ENDPOINTS
 	} else if (desc->bEndpointAddress & USB_DIR_IN) {
@@ -183,12 +182,12 @@  ep_matches (
 }
 
 static struct usb_ep *
-find_ep (struct usb_gadget *gadget, const char *name)
+find_ep(struct usb_gadget *gadget, const char *name)
 {
 	struct usb_ep	*ep;
 
-	list_for_each_entry (ep, &gadget->ep_list, ep_list) {
-		if (0 == strcmp (ep->name, name))
+	list_for_each_entry(ep, &gadget->ep_list, ep_list) {
+		if (0 == strcmp(ep->name, name))
 			return ep;
 	}
 	return NULL;
@@ -224,7 +223,7 @@  find_ep (struct usb_gadget *gadget, const char *name)
  *
  * On failure, this returns a null endpoint descriptor.
  */
-struct usb_ep * usb_ep_autoconfig (
+struct usb_ep *usb_ep_autoconfig(
 	struct usb_gadget		*gadget,
 	struct usb_endpoint_descriptor	*desc
 )
@@ -237,44 +236,44 @@  struct usb_ep * usb_ep_autoconfig (
 	/* First, apply chip-specific "best usage" knowledge.
 	 * This might make a good usb_gadget_ops hook ...
 	 */
-	if (gadget_is_net2280 (gadget) && type == USB_ENDPOINT_XFER_INT) {
+	if (gadget_is_net2280(gadget) && type == USB_ENDPOINT_XFER_INT) {
 		/* ep-e, ep-f are PIO with only 64 byte fifos */
-		ep = find_ep (gadget, "ep-e");
-		if (ep && ep_matches (gadget, ep, desc))
+		ep = find_ep(gadget, "ep-e");
+		if (ep && ep_matches(gadget, ep, desc))
 			return ep;
-		ep = find_ep (gadget, "ep-f");
-		if (ep && ep_matches (gadget, ep, desc))
+		ep = find_ep(gadget, "ep-f");
+		if (ep && ep_matches(gadget, ep, desc))
 			return ep;
 
-	} else if (gadget_is_goku (gadget)) {
+	} else if (gadget_is_goku(gadget)) {
 		if (USB_ENDPOINT_XFER_INT == type) {
 			/* single buffering is enough */
-			ep = find_ep (gadget, "ep3-bulk");
-			if (ep && ep_matches (gadget, ep, desc))
+			ep = find_ep(gadget, "ep3-bulk");
+			if (ep && ep_matches(gadget, ep, desc))
 				return ep;
 		} else if (USB_ENDPOINT_XFER_BULK == type
 				&& (USB_DIR_IN & desc->bEndpointAddress)) {
 			/* DMA may be available */
-			ep = find_ep (gadget, "ep2-bulk");
-			if (ep && ep_matches (gadget, ep, desc))
+			ep = find_ep(gadget, "ep2-bulk");
+			if (ep && ep_matches(gadget, ep, desc))
 				return ep;
 		}
 
-	} else if (gadget_is_sh (gadget) && USB_ENDPOINT_XFER_INT == type) {
+	} else if (gadget_is_sh(gadget) && USB_ENDPOINT_XFER_INT == type) {
 		/* single buffering is enough; maybe 8 byte fifo is too */
-		ep = find_ep (gadget, "ep3in-bulk");
-		if (ep && ep_matches (gadget, ep, desc))
+		ep = find_ep(gadget, "ep3in-bulk");
+		if (ep && ep_matches(gadget, ep, desc))
 			return ep;
 
-	} else if (gadget_is_mq11xx (gadget) && USB_ENDPOINT_XFER_INT == type) {
-		ep = find_ep (gadget, "ep1-bulk");
-		if (ep && ep_matches (gadget, ep, desc))
+	} else if (gadget_is_mq11xx(gadget) && USB_ENDPOINT_XFER_INT == type) {
+		ep = find_ep(gadget, "ep1-bulk");
+		if (ep && ep_matches(gadget, ep, desc))
 			return ep;
 	}
 
 	/* Second, look at endpoints until an unclaimed one looks usable */
-	list_for_each_entry (ep, &gadget->ep_list, ep_list) {
-		if (ep_matches (gadget, ep, desc))
+	list_for_each_entry(ep, &gadget->ep_list, ep_list) {
+		if (ep_matches(gadget, ep, desc))
 			return ep;
 	}
 
@@ -291,11 +290,11 @@  struct usb_ep * usb_ep_autoconfig (
  * state such as ep->driver_data and the record of assigned endpoints
  * used by usb_ep_autoconfig().
  */
-void usb_ep_autoconfig_reset (struct usb_gadget *gadget)
+void usb_ep_autoconfig_reset(struct usb_gadget *gadget)
 {
 	struct usb_ep	*ep;
 
-	list_for_each_entry (ep, &gadget->ep_list, ep_list) {
+	list_for_each_entry(ep, &gadget->ep_list, ep_list) {
 		ep->driver_data = NULL;
 	}
 #ifdef	MANY_ENDPOINTS
diff --git a/drivers/usb/gadget/ether.c b/drivers/usb/gadget/ether.c
index 2965299..051ab3c 100644
--- a/drivers/usb/gadget/ether.c
+++ b/drivers/usb/gadget/ether.c
@@ -89,8 +89,8 @@  unsigned packet_received, packet_sent;
 /* Based on linux 2.6.27 version */
 #define DRIVER_VERSION		"May Day 2005"
 
-static const char shortname [] = "ether";
-static const char driver_desc [] = DRIVER_DESC;
+static const char shortname[] = "ether";
+static const char driver_desc[] = DRIVER_DESC;
 
 #define RX_EXTRA	20		/* guard against rx overflows */
 
@@ -114,7 +114,7 @@  static inline int is_cdc(struct eth_dev *dev)
 {
 #if	!defined(DEV_CONFIG_SUBSET)
 	return 1;		/* only cdc possible */
-#elif	!defined (DEV_CONFIG_CDC)
+#elif	!defined(DEV_CONFIG_CDC)
 	return 0;		/* only subset possible */
 #else
 	return dev->cdc;	/* depends on what hardware we found */
@@ -122,7 +122,7 @@  static inline int is_cdc(struct eth_dev *dev)
 }
 
 #define	subset_active(dev)	(!is_cdc(dev))
-#define	cdc_active(dev)		( is_cdc(dev))
+#define	cdc_active(dev)		(is_cdc(dev))
 
 #define DEFAULT_QLEN	2	/* double buffering by default */
 
@@ -180,12 +180,12 @@  struct eth_dev {
 	unsigned		zlp:1;
 	unsigned		cdc:1;
 	unsigned		suspended:1;
-	unsigned 		network_started:1;
+	unsigned		network_started:1;
 	u16			cdc_filter;
 	unsigned long		todo;
-	int 			mtu;
+	int			mtu;
 #define	WORK_RX_MEMORY		0
-	u8			host_mac [ETH_ALEN];
+	u8			host_mac[ETH_ALEN];
 };
 
 /* This version autoconfigures as much as possible at run-time.
@@ -276,14 +276,14 @@  device_desc = {
 	.bLength =		sizeof device_desc,
 	.bDescriptorType =	USB_DT_DEVICE,
 
-	.bcdUSB =		__constant_cpu_to_le16 (0x0200),
+	.bcdUSB =		__constant_cpu_to_le16(0x0200),
 
 	.bDeviceClass =		USB_CLASS_COMM,
 	.bDeviceSubClass =	0,
 	.bDeviceProtocol =	0,
 
-	.idVendor =		__constant_cpu_to_le16 (CDC_VENDOR_NUM),
-	.idProduct =		__constant_cpu_to_le16 (CDC_PRODUCT_NUM),
+	.idVendor =		__constant_cpu_to_le16(CDC_VENDOR_NUM),
+	.idProduct =		__constant_cpu_to_le16(CDC_PRODUCT_NUM),
 	.iManufacturer =	STRING_MANUFACTURER,
 	.iProduct =		STRING_PRODUCT,
 	.bNumConfigurations =	1,
@@ -338,7 +338,7 @@  static const struct usb_cdc_header_desc header_desc = {
 	.bDescriptorType =	USB_DT_CS_INTERFACE,
 	.bDescriptorSubType =	USB_CDC_HEADER_TYPE,
 
-	.bcdCDC =		__constant_cpu_to_le16 (0x0110),
+	.bcdCDC =		__constant_cpu_to_le16(0x0110),
 };
 
 #if defined(DEV_CONFIG_CDC)
@@ -391,15 +391,15 @@  static const u8 mdlm_detail_desc[] = {
 
 
 static const struct usb_cdc_ether_desc ether_desc = {
-	.bLength =		sizeof (ether_desc),
+	.bLength =		sizeof(ether_desc),
 	.bDescriptorType =	USB_DT_CS_INTERFACE,
 	.bDescriptorSubType =	USB_CDC_ETHERNET_TYPE,
 
 	/* this descriptor actually adds value, surprise! */
 	.iMACAddress =		STRING_ETHADDR,
-	.bmEthernetStatistics = __constant_cpu_to_le32 (0), /* no statistics */
-	.wMaxSegmentSize =	__constant_cpu_to_le16 (ETH_FRAME_LEN),
-	.wNumberMCFilters =	__constant_cpu_to_le16 (0),
+	.bmEthernetStatistics = __constant_cpu_to_le32(0), /* no statistics */
+	.wMaxSegmentSize =	__constant_cpu_to_le16(ETH_FRAME_LEN),
+	.wNumberMCFilters =	__constant_cpu_to_le16(0),
 	.bNumberPowerFilters =	0,
 };
 
@@ -427,7 +427,7 @@  fs_status_desc = {
 
 	.bEndpointAddress =	USB_DIR_IN,
 	.bmAttributes =		USB_ENDPOINT_XFER_INT,
-	.wMaxPacketSize =	__constant_cpu_to_le16 (STATUS_BYTECOUNT),
+	.wMaxPacketSize =	__constant_cpu_to_le16(STATUS_BYTECOUNT),
 	.bInterval =		1 << LOG2_STATUS_INTERVAL_MSEC,
 };
 #endif
@@ -512,7 +512,7 @@  fs_sink_desc = {
 	.bmAttributes =		USB_ENDPOINT_XFER_BULK,
 };
 
-static const struct usb_descriptor_header *fs_eth_function [11] = {
+static const struct usb_descriptor_header *fs_eth_function[11] = {
 	(struct usb_descriptor_header *) &otg_descriptor,
 #ifdef DEV_CONFIG_CDC
 	/* "cdc" mode descriptors */
@@ -560,7 +560,7 @@  hs_status_desc = {
 	.bDescriptorType =	USB_DT_ENDPOINT,
 
 	.bmAttributes =		USB_ENDPOINT_XFER_INT,
-	.wMaxPacketSize =	__constant_cpu_to_le16 (STATUS_BYTECOUNT),
+	.wMaxPacketSize =	__constant_cpu_to_le16(STATUS_BYTECOUNT),
 	.bInterval =		LOG2_STATUS_INTERVAL_MSEC + 4,
 };
 #endif /* DEV_CONFIG_CDC */
@@ -571,7 +571,7 @@  hs_source_desc = {
 	.bDescriptorType =	USB_DT_ENDPOINT,
 
 	.bmAttributes =		USB_ENDPOINT_XFER_BULK,
-	.wMaxPacketSize =	__constant_cpu_to_le16 (512),
+	.wMaxPacketSize =	__constant_cpu_to_le16(512),
 };
 
 static struct usb_endpoint_descriptor
@@ -580,7 +580,7 @@  hs_sink_desc = {
 	.bDescriptorType =	USB_DT_ENDPOINT,
 
 	.bmAttributes =		USB_ENDPOINT_XFER_BULK,
-	.wMaxPacketSize =	__constant_cpu_to_le16 (512),
+	.wMaxPacketSize =	__constant_cpu_to_le16(512),
 };
 
 static struct usb_qualifier_descriptor
@@ -588,13 +588,13 @@  dev_qualifier = {
 	.bLength =		sizeof dev_qualifier,
 	.bDescriptorType =	USB_DT_DEVICE_QUALIFIER,
 
-	.bcdUSB =		__constant_cpu_to_le16 (0x0200),
+	.bcdUSB =		__constant_cpu_to_le16(0x0200),
 	.bDeviceClass =		USB_CLASS_COMM,
 
 	.bNumConfigurations =	1,
 };
 
-static const struct usb_descriptor_header *hs_eth_function [11] = {
+static const struct usb_descriptor_header *hs_eth_function[11] = {
 	(struct usb_descriptor_header *) &otg_descriptor,
 #ifdef DEV_CONFIG_CDC
 	/* "cdc" mode descriptors */
@@ -645,15 +645,15 @@  ep_desc(struct usb_gadget *g, struct usb_endpoint_descriptor *hs,
 
 /* descriptors that are built on-demand */
 
-static char manufacturer [50];
-static char product_desc [40] = DRIVER_DESC;
-static char serial_number [20];
+static char manufacturer[50];
+static char product_desc[40] = DRIVER_DESC;
+static char serial_number[20];
 
 /* address that the host will use ... usually assigned at random */
-static char ethaddr [2 * ETH_ALEN + 1];
+static char ethaddr[2 * ETH_ALEN + 1];
 
 /* static strings, in UTF-8 */
-static struct usb_string		strings [] = {
+static struct usb_string		strings[] = {
 	{ STRING_MANUFACTURER,	manufacturer, },
 	{ STRING_PRODUCT,	product_desc, },
 	{ STRING_SERIALNUMBER,	serial_number, },
@@ -730,13 +730,13 @@  config_buf(struct usb_gadget *g, u8 *buf, u8 type, unsigned index, int is_otg)
 		return -EINVAL;
 
 	config = &eth_config;
-	function = which_fn (eth);
+	function = which_fn(eth);
 
 	/* for now, don't advertise srp-only devices */
 	if (!is_otg)
 		function++;
 
-	len = usb_gadget_config_buf (config, buf, USB_BUFSIZ, function);
+	len = usb_gadget_config_buf(config, buf, USB_BUFSIZ, function);
 	if (len < 0)
 		return len;
 	((struct usb_config_descriptor *) buf)->bDescriptorType = type;
@@ -745,10 +745,10 @@  config_buf(struct usb_gadget *g, u8 *buf, u8 type, unsigned index, int is_otg)
 
 /*-------------------------------------------------------------------------*/
 
-static int alloc_requests (struct eth_dev *dev, unsigned n, gfp_t gfp_flags);
+static int alloc_requests(struct eth_dev *dev, unsigned n, gfp_t gfp_flags);
 
 static int
-set_ether_config (struct eth_dev *dev, gfp_t gfp_flags)
+set_ether_config(struct eth_dev *dev, gfp_t gfp_flags)
 {
 	int					result = 0;
 	struct usb_gadget			*gadget = dev->gadget;
@@ -756,11 +756,11 @@  set_ether_config (struct eth_dev *dev, gfp_t gfp_flags)
 #if defined(DEV_CONFIG_CDC)
 	/* status endpoint used for (optionally) CDC */
 	if (!subset_active(dev) && dev->status_ep) {
-		dev->status = ep_desc (gadget, &hs_status_desc,
+		dev->status = ep_desc(gadget, &hs_status_desc,
 						&fs_status_desc);
 		dev->status_ep->driver_data = dev;
 
-		result = usb_ep_enable (dev->status_ep, dev->status);
+		result = usb_ep_enable(dev->status_ep, dev->status);
 		if (result != 0) {
 			debug("enable %s --> %d\n",
 				dev->status_ep->name, result);
@@ -780,14 +780,14 @@  set_ether_config (struct eth_dev *dev, gfp_t gfp_flags)
 	 * so we don't activate them yet.  Reset from SET_INTERFACE.
 	 */
 	if (!cdc_active(dev)) {
-		result = usb_ep_enable (dev->in_ep, dev->in);
+		result = usb_ep_enable(dev->in_ep, dev->in);
 		if (result != 0) {
 			debug("enable %s --> %d\n",
 				dev->in_ep->name, result);
 			goto done;
 		}
 
-		result = usb_ep_enable (dev->out_ep, dev->out);
+		result = usb_ep_enable(dev->out_ep, dev->out);
 		if (result != 0) {
 			debug("enable %s --> %d\n",
 				dev->out_ep->name, result);
@@ -797,15 +797,15 @@  set_ether_config (struct eth_dev *dev, gfp_t gfp_flags)
 
 done:
 	if (result == 0)
-		result = alloc_requests (dev, qlen (gadget), gfp_flags);
+		result = alloc_requests(dev, qlen(gadget), gfp_flags);
 
 	/* on error, disable any endpoints  */
 	if (result < 0) {
 		if (!subset_active(dev) && dev->status_ep)
-			(void) usb_ep_disable (dev->status_ep);
+			(void) usb_ep_disable(dev->status_ep);
 		dev->status = NULL;
-		(void) usb_ep_disable (dev->in_ep);
-		(void) usb_ep_disable (dev->out_ep);
+		(void) usb_ep_disable(dev->in_ep);
+		(void) usb_ep_disable(dev->out_ep);
 		dev->in = NULL;
 		dev->out = NULL;
 	}
@@ -815,7 +815,7 @@  done:
 }
 
 
-static void eth_reset_config (struct eth_dev *dev)
+static void eth_reset_config(struct eth_dev *dev)
 {
 	if (dev->config == 0)
 		return;
@@ -827,21 +827,21 @@  static void eth_reset_config (struct eth_dev *dev)
 	 */
 
 	if (dev->in) {
-		usb_ep_disable (dev->in_ep);
+		usb_ep_disable(dev->in_ep);
 		if (dev->tx_req) {
-			usb_ep_free_request (dev->in_ep, dev->tx_req);
-			dev->tx_req=NULL;
+			usb_ep_free_request(dev->in_ep, dev->tx_req);
+			dev->tx_req = NULL;
 		}
 	}
 	if (dev->out) {
-		usb_ep_disable (dev->out_ep);
+		usb_ep_disable(dev->out_ep);
 		if (dev->rx_req) {
-			usb_ep_free_request (dev->out_ep, dev->rx_req);
-			dev->rx_req=NULL;
+			usb_ep_free_request(dev->out_ep, dev->rx_req);
+			dev->rx_req = NULL;
 		}
 	}
 	if (dev->status) {
-		usb_ep_disable (dev->status_ep);
+		usb_ep_disable(dev->status_ep);
 	}
 	dev->cdc_filter = 0;
 	dev->config = 0;
@@ -850,23 +850,24 @@  static void eth_reset_config (struct eth_dev *dev)
 /* change our operational config.  must agree with the code
  * that returns config descriptors, and altsetting code.
  */
-static int eth_set_config (struct eth_dev *dev, unsigned number, gfp_t gfp_flags)
+static int eth_set_config(struct eth_dev *dev, unsigned number,
+				gfp_t gfp_flags)
 {
 	int			result = 0;
 	struct usb_gadget	*gadget = dev->gadget;
 
-	if (gadget_is_sa1100 (gadget)
+	if (gadget_is_sa1100(gadget)
 			&& dev->config
 			&& dev->tx_qlen != 0) {
 		/* tx fifo is full, but we can't clear it...*/
 		error("can't change configurations");
 		return -ESPIPE;
 	}
-	eth_reset_config (dev);
+	eth_reset_config(dev);
 
 	switch (number) {
 	case DEV_CONFIG_VALUE:
-		result = set_ether_config (dev, gfp_flags);
+		result = set_ether_config(dev, gfp_flags);
 		break;
 	default:
 		result = -EINVAL;
@@ -877,7 +878,7 @@  static int eth_set_config (struct eth_dev *dev, unsigned number, gfp_t gfp_flags
 
 	if (result) {
 		if (number)
-			eth_reset_config (dev);
+			eth_reset_config(dev);
 		usb_gadget_vbus_draw(dev->gadget,
 				gadget_is_otg(dev->gadget) ? 8 : 100);
 	} else {
@@ -888,17 +889,20 @@  static int eth_set_config (struct eth_dev *dev, unsigned number, gfp_t gfp_flags
 		usb_gadget_vbus_draw(dev->gadget, power);
 
 		switch (gadget->speed) {
-		case USB_SPEED_FULL:	speed = "full"; break;
+		case USB_SPEED_FULL:
+			speed = "full"; break;
 #ifdef CONFIG_USB_GADGET_DUALSPEED
-		case USB_SPEED_HIGH:	speed = "high"; break;
+		case USB_SPEED_HIGH:
+			speed = "high"; break;
 #endif
-		default:		speed = "?"; break;
+		default:
+			speed = "?"; break;
 		}
 
 		dev->config = number;
 		printf("%s speed config #%d: %d mA, %s, using %s\n",
 				speed, number, power, driver_desc,
-				(cdc_active(dev)? "CDC Ethernet"
+				(cdc_active(dev) ? "CDC Ethernet"
 						: "CDC Ethernet Subset"));
 	}
 	return result;
@@ -914,7 +918,7 @@  static int eth_set_config (struct eth_dev *dev, unsigned number, gfp_t gfp_flags
  * we want this CDC Ethernet code to be vendor-neutral, we don't use that
  * command mechanism; and only one status request is ever queued.
  */
-static void eth_status_complete (struct usb_ep *ep, struct usb_request *req)
+static void eth_status_complete(struct usb_ep *ep, struct usb_request *req)
 {
 	struct usb_cdc_notification	*event = req->buf;
 	int				value = req->status;
@@ -927,32 +931,31 @@  static void eth_status_complete (struct usb_ep *ep, struct usb_request *req)
 
 		event->bmRequestType = 0xA1;
 		event->bNotificationType = USB_CDC_NOTIFY_SPEED_CHANGE;
-		event->wValue = __constant_cpu_to_le16 (0);
-		event->wIndex = __constant_cpu_to_le16 (1);
-		event->wLength = __constant_cpu_to_le16 (8);
+		event->wValue = __constant_cpu_to_le16(0);
+		event->wIndex = __constant_cpu_to_le16(1);
+		event->wLength = __constant_cpu_to_le16(8);
 
 		/* SPEED_CHANGE data is up/down speeds in bits/sec */
-		data [0] = data [1] = cpu_to_le32 (BITRATE (dev->gadget));
+		data[0] = data[1] = cpu_to_le32(BITRATE(dev->gadget));
 
 		req->length = STATUS_BYTECOUNT;
-		value = usb_ep_queue (ep, req, GFP_ATOMIC);
+		value = usb_ep_queue(ep, req, GFP_ATOMIC);
 		debug("send SPEED_CHANGE --> %d\n", value);
 		if (value == 0)
 			return;
 	} else if (value != -ECONNRESET) {
 		debug("event %02x --> %d\n",
 			event->bNotificationType, value);
-		if (event->bNotificationType==
-				USB_CDC_NOTIFY_SPEED_CHANGE)
-		{
-			l_ethdev.network_started=1;
+		if (event->bNotificationType ==
+				USB_CDC_NOTIFY_SPEED_CHANGE) {
+			l_ethdev.network_started = 1;
 			printf("USB network up!\n");
 		}
 	}
 	req->context = NULL;
 }
 
-static void issue_start_status (struct eth_dev *dev)
+static void issue_start_status(struct eth_dev *dev)
 {
 	struct usb_request		*req = dev->stat_req;
 	struct usb_cdc_notification	*event;
@@ -967,8 +970,8 @@  static void issue_start_status (struct eth_dev *dev)
 	 *
 	 * FIXME iff req->context != null just dequeue it
 	 */
-	usb_ep_disable (dev->status_ep);
-	usb_ep_enable (dev->status_ep, dev->status);
+	usb_ep_disable(dev->status_ep);
+	usb_ep_enable(dev->status_ep, dev->status);
 
 	/* 3.8.1 says to issue first NETWORK_CONNECTION, then
 	 * a SPEED_CHANGE.  could be useful in some configs.
@@ -976,15 +979,15 @@  static void issue_start_status (struct eth_dev *dev)
 	event = req->buf;
 	event->bmRequestType = 0xA1;
 	event->bNotificationType = USB_CDC_NOTIFY_NETWORK_CONNECTION;
-	event->wValue = __constant_cpu_to_le16 (1);	/* connected */
-	event->wIndex = __constant_cpu_to_le16 (1);
+	event->wValue = __constant_cpu_to_le16(1);	/* connected */
+	event->wIndex = __constant_cpu_to_le16(1);
 	event->wLength = 0;
 
 	req->length = sizeof *event;
 	req->complete = eth_status_complete;
 	req->context = dev;
 
-	value = usb_ep_queue (dev->status_ep, req, GFP_ATOMIC);
+	value = usb_ep_queue(dev->status_ep, req, GFP_ATOMIC);
 	if (value < 0)
 		debug("status buf queue --> %d\n", value);
 }
@@ -993,7 +996,7 @@  static void issue_start_status (struct eth_dev *dev)
 
 /*-------------------------------------------------------------------------*/
 
-static void eth_setup_complete (struct usb_ep *ep, struct usb_request *req)
+static void eth_setup_complete(struct usb_ep *ep, struct usb_request *req)
 {
 	if (req->status || req->actual != req->length)
 		debug("setup complete --> %d, %d/%d\n",
@@ -1010,9 +1013,9 @@  static void eth_setup_complete (struct usb_ep *ep, struct usb_request *req)
  *  - class-specific control requests
  */
 static int
-eth_setup (struct usb_gadget *gadget, const struct usb_ctrlrequest *ctrl)
+eth_setup(struct usb_gadget *gadget, const struct usb_ctrlrequest *ctrl)
 {
-	struct eth_dev		*dev = get_gadget_data (gadget);
+	struct eth_dev		*dev = get_gadget_data(gadget);
 	struct usb_request	*req = dev->req;
 	int			value = -EOPNOTSUPP;
 	u16			wIndex = le16_to_cpu(ctrl->wIndex);
@@ -1034,14 +1037,14 @@  eth_setup (struct usb_gadget *gadget, const struct usb_ctrlrequest *ctrl)
 		switch (wValue >> 8) {
 
 		case USB_DT_DEVICE:
-			value = min (wLength, (u16) sizeof device_desc);
-			memcpy (req->buf, &device_desc, value);
+			value = min(wLength, (u16) sizeof device_desc);
+			memcpy(req->buf, &device_desc, value);
 			break;
 		case USB_DT_DEVICE_QUALIFIER:
 			if (!gadget_is_dualspeed(gadget))
 				break;
-			value = min (wLength, (u16) sizeof dev_qualifier);
-			memcpy (req->buf, &dev_qualifier, value);
+			value = min(wLength, (u16) sizeof dev_qualifier);
+			memcpy(req->buf, &dev_qualifier, value);
 			break;
 
 		case USB_DT_OTHER_SPEED_CONFIG:
@@ -1054,15 +1057,15 @@  eth_setup (struct usb_gadget *gadget, const struct usb_ctrlrequest *ctrl)
 					wValue & 0xff,
 					gadget_is_otg(gadget));
 			if (value >= 0)
-				value = min (wLength, (u16) value);
+				value = min(wLength, (u16) value);
 			break;
 
 		case USB_DT_STRING:
-			value = usb_gadget_get_string (&stringtab,
+			value = usb_gadget_get_string(&stringtab,
 					wValue & 0xff, req->buf);
 
 			if (value >= 0)
-				value = min (wLength, (u16) value);
+				value = min(wLength, (u16) value);
 
 			break;
 		}
@@ -1075,13 +1078,13 @@  eth_setup (struct usb_gadget *gadget, const struct usb_ctrlrequest *ctrl)
 			debug("HNP available\n");
 		else if (gadget->a_alt_hnp_support)
 			debug("HNP needs a different root port\n");
-		value = eth_set_config (dev, wValue, GFP_ATOMIC);
+		value = eth_set_config(dev, wValue, GFP_ATOMIC);
 		break;
 	case USB_REQ_GET_CONFIGURATION:
 		if (ctrl->bRequestType != USB_DIR_IN)
 			break;
 		*(u8 *)req->buf = dev->config;
-		value = min (wLength, (u16) 1);
+		value = min(wLength, (u16) 1);
 		break;
 
 	case USB_REQ_SET_INTERFACE:
@@ -1095,8 +1098,8 @@  eth_setup (struct usb_gadget *gadget, const struct usb_ctrlrequest *ctrl)
 		/* PXA hardware partially handles SET_INTERFACE;
 		 * we need to kluge around that interference.
 		 */
-		if (gadget_is_pxa (gadget)) {
-			value = eth_set_config (dev, DEV_CONFIG_VALUE,
+		if (gadget_is_pxa(gadget)) {
+			value = eth_set_config(dev, DEV_CONFIG_VALUE,
 						GFP_ATOMIC);
 			goto done_set_intf;
 		}
@@ -1107,29 +1110,29 @@  eth_setup (struct usb_gadget *gadget, const struct usb_ctrlrequest *ctrl)
 			if (wValue != 0)
 				break;
 			if (dev->status) {
-				usb_ep_disable (dev->status_ep);
-				usb_ep_enable (dev->status_ep, dev->status);
+				usb_ep_disable(dev->status_ep);
+				usb_ep_enable(dev->status_ep, dev->status);
 			}
 			value = 0;
 			break;
 		case 1:		/* data intf */
 			if (wValue > 1)
 				break;
-			usb_ep_disable (dev->in_ep);
-			usb_ep_disable (dev->out_ep);
+			usb_ep_disable(dev->in_ep);
+			usb_ep_disable(dev->out_ep);
 
 			/* CDC requires the data transfers not be done from
 			 * the default interface setting ... also, setting
 			 * the non-default interface resets filters etc.
 			 */
 			if (wValue == 1) {
-				if (!cdc_active (dev))
+				if (!cdc_active(dev))
 					break;
-				usb_ep_enable (dev->in_ep, dev->in);
-				usb_ep_enable (dev->out_ep, dev->out);
+				usb_ep_enable(dev->in_ep, dev->in);
+				usb_ep_enable(dev->out_ep, dev->out);
 				dev->cdc_filter = DEFAULT_FILTER;
 				if (dev->status)
-					issue_start_status (dev);
+					issue_start_status(dev);
 			}
 
 			value = 0;
@@ -1160,7 +1163,7 @@  done_set_intf:
 			/* carrier always ok ...*/
 			*(u8 *)req->buf = 1 ;
 		}
-		value = min (wLength, (u16) 1);
+		value = min(wLength, (u16) 1);
 		break;
 
 #ifdef DEV_CONFIG_CDC
@@ -1199,11 +1202,11 @@  done_set_intf:
 		req->length = value;
 		req->zero = value < wLength
 				&& (value % gadget->ep0->maxpacket) == 0;
-		value = usb_ep_queue (gadget->ep0, req, GFP_ATOMIC);
+		value = usb_ep_queue(gadget->ep0, req, GFP_ATOMIC);
 		if (value < 0) {
 			debug("ep_queue --> %d\n", value);
 			req->status = 0;
-			eth_setup_complete (gadget->ep0, req);
+			eth_setup_complete(gadget->ep0, req);
 		}
 	}
 
@@ -1214,9 +1217,9 @@  done_set_intf:
 
 /*-------------------------------------------------------------------------*/
 
-static void rx_complete (struct usb_ep *ep, struct usb_request *req);
+static void rx_complete(struct usb_ep *ep, struct usb_request *req);
 
-static int rx_submit ( struct eth_dev *dev, struct usb_request *req, \
+static int rx_submit(struct eth_dev *dev, struct usb_request *req,
 				gfp_t gfp_flags)
 {
 	int			retval = -ENOMEM;
@@ -1245,7 +1248,7 @@  static int rx_submit ( struct eth_dev *dev, struct usb_request *req, \
 	req->length = size;
 	req->complete = rx_complete;
 
-	retval = usb_ep_queue (dev->out_ep, req, gfp_flags);
+	retval = usb_ep_queue(dev->out_ep, req, gfp_flags);
 
 	if (retval) {
 		error("rx submit --> %d", retval);
@@ -1254,28 +1257,28 @@  static int rx_submit ( struct eth_dev *dev, struct usb_request *req, \
 }
 
 
-static void rx_complete (struct usb_ep *ep, struct usb_request *req)
+static void rx_complete(struct usb_ep *ep, struct usb_request *req)
 {
 	struct eth_dev	*dev = ep->driver_data;
 
 	debug("%s: status %d\n", __func__, req->status);
 
-	packet_received=1;
+	packet_received = 1;
 
 	if (req)
-		dev->rx_req=req;
+		dev->rx_req = req;
 }
 
 
-static int alloc_requests (struct eth_dev *dev, unsigned n, gfp_t gfp_flags)
+static int alloc_requests(struct eth_dev *dev, unsigned n, gfp_t gfp_flags)
 {
 
-	dev->tx_req = usb_ep_alloc_request (dev->in_ep, 0);
+	dev->tx_req = usb_ep_alloc_request(dev->in_ep, 0);
 
 	if (!dev->tx_req)
 		goto fail;
 
-	dev->rx_req = usb_ep_alloc_request (dev->out_ep, 0);
+	dev->rx_req = usb_ep_alloc_request(dev->out_ep, 0);
 
 	if (!dev->rx_req)
 		goto fail;
@@ -1288,16 +1291,16 @@  fail:
 }
 
 
-static void tx_complete (struct usb_ep *ep, struct usb_request *req)
+static void tx_complete(struct usb_ep *ep, struct usb_request *req)
 {
-	debug("%s: status %s\n", __func__, (req->status)?"failed":"ok");
-	packet_sent=1;
+	debug("%s: status %s\n", __func__, (req->status) ? "failed" : "ok");
+	packet_sent = 1;
 }
 
-static inline int eth_is_promisc (struct eth_dev *dev)
+static inline int eth_is_promisc(struct eth_dev *dev)
 {
 	/* no filters for the CDC subset; always promisc */
-	if (subset_active (dev))
+	if (subset_active(dev))
 		return 1;
 	return dev->cdc_filter & USB_CDC_PACKET_TYPE_PROMISCUOUS;
 }
@@ -1415,49 +1418,49 @@  drop:
 /*-------------------------------------------------------------------------*/
 #endif
 
-static void eth_unbind (struct usb_gadget *gadget)
+static void eth_unbind(struct usb_gadget *gadget)
 {
-	struct eth_dev *dev = get_gadget_data (gadget);
+	struct eth_dev *dev = get_gadget_data(gadget);
 
 	debug("%s...\n", __func__);
 
 	/* we've already been disconnected ... no i/o is active */
 	if (dev->req) {
-		usb_ep_free_request (gadget->ep0, dev->req);
+		usb_ep_free_request(gadget->ep0, dev->req);
 		dev->req = NULL;
 	}
 	if (dev->stat_req) {
-		usb_ep_free_request (dev->status_ep, dev->stat_req);
+		usb_ep_free_request(dev->status_ep, dev->stat_req);
 		dev->stat_req = NULL;
 	}
 
 	if (dev->tx_req) {
-		usb_ep_free_request (dev->in_ep, dev->tx_req);
-		dev->tx_req=NULL;
+		usb_ep_free_request(dev->in_ep, dev->tx_req);
+		dev->tx_req = NULL;
 	}
 
 	if (dev->rx_req) {
-		usb_ep_free_request (dev->out_ep, dev->rx_req);
-		dev->rx_req=NULL;
+		usb_ep_free_request(dev->out_ep, dev->rx_req);
+		dev->rx_req = NULL;
 	}
 
 /*	unregister_netdev (dev->net);*/
 /*	free_netdev(dev->net);*/
 
-	set_gadget_data (gadget, NULL);
+	set_gadget_data(gadget, NULL);
 }
 
-static void eth_disconnect (struct usb_gadget *gadget)
+static void eth_disconnect(struct usb_gadget *gadget)
 {
-	eth_reset_config (get_gadget_data (gadget));
+	eth_reset_config(get_gadget_data(gadget));
 }
 
-static void eth_suspend (struct usb_gadget *gadget)
+static void eth_suspend(struct usb_gadget *gadget)
 {
 	/* Not used */
 }
 
-static void eth_resume (struct usb_gadget *gadget)
+static void eth_resume(struct usb_gadget *gadget)
 {
 	/* Not used */
 }
@@ -1492,12 +1495,12 @@  static int is_eth_addr_valid(char *str)
 	return 0;
 }
 
-static u8 nibble (unsigned char c)
+static u8 nibble(unsigned char c)
 {
-	if (likely (isdigit (c)))
+	if (likely(isdigit(c)))
 		return c - '0';
-	c = toupper (c);
-	if (likely (isxdigit (c)))
+	c = toupper(c);
+	if (likely(isxdigit(c)))
 		return 10 + c - 'A';
 	return 0;
 }
@@ -1510,13 +1513,13 @@  static int get_ether_addr(const char *str, u8 *dev_addr)
 		for (i = 0; i < 6; i++) {
 			unsigned char num;
 
-			if((*str == '.') || (*str == ':'))
+			if ((*str == '.') || (*str == ':'))
 				str++;
 			num = nibble(*str++) << 4;
 			num |= (nibble(*str++));
-			dev_addr [i] = num;
+			dev_addr[i] = num;
 		}
-		if (is_valid_ether_addr (dev_addr))
+		if (is_valid_ether_addr(dev_addr))
 			return 0;
 	}
 	return 1;
@@ -1528,7 +1531,7 @@  static int eth_bind(struct usb_gadget *gadget)
 	u8			cdc = 1, zlp = 1;
 	struct usb_ep		*in_ep, *out_ep, *status_ep = NULL;
 	int			gcnum;
-	u8 			tmp[7];
+	u8			tmp[7];
 
 	/* these flags are only ever cleared; compiler take note */
 #ifndef	DEV_CONFIG_CDC
@@ -1538,7 +1541,7 @@  static int eth_bind(struct usb_gadget *gadget)
 	 * standard protocol is _strongly_ preferred for interop purposes.
 	 * (By everyone except Microsoft.)
 	 */
-	if (gadget_is_pxa (gadget)) {
+	if (gadget_is_pxa(gadget)) {
 		/* pxa doesn't support altsettings */
 		cdc = 0;
 	} else if (gadget_is_musbhdrc(gadget)) {
@@ -1547,7 +1550,7 @@  static int eth_bind(struct usb_gadget *gadget)
 	} else if (gadget_is_sh(gadget)) {
 		/* sh doesn't support multiple interfaces or configs */
 		cdc = 0;
-	} else if (gadget_is_sa1100 (gadget)) {
+	} else if (gadget_is_sa1100(gadget)) {
 		/* hardware can't write zlps */
 		zlp = 0;
 		/* sa1100 CAN do CDC, without status endpoint ... we use
@@ -1556,9 +1559,9 @@  static int eth_bind(struct usb_gadget *gadget)
 		cdc = 0;
 	}
 
-	gcnum = usb_gadget_controller_number (gadget);
+	gcnum = usb_gadget_controller_number(gadget);
 	if (gcnum >= 0)
-		device_desc.bcdDevice = cpu_to_le16 (0x0300 + gcnum);
+		device_desc.bcdDevice = cpu_to_le16(0x0300 + gcnum);
 	else {
 		/* can't assume CDC works.  don't want to default to
 		 * anything less functional on CDC-capable hardware,
@@ -1588,17 +1591,17 @@  static int eth_bind(struct usb_gadget *gadget)
 	if (bcdDevice)
 		device_desc.bcdDevice = cpu_to_le16(bcdDevice);
 	if (iManufacturer)
-		strlcpy (manufacturer, iManufacturer, sizeof manufacturer);
+		strlcpy(manufacturer, iManufacturer, sizeof manufacturer);
 	if (iProduct)
-		strlcpy (product_desc, iProduct, sizeof product_desc);
+		strlcpy(product_desc, iProduct, sizeof product_desc);
 	if (iSerialNumber) {
 		device_desc.iSerialNumber = STRING_SERIALNUMBER,
 		strlcpy(serial_number, iSerialNumber, sizeof serial_number);
 	}
 
 	/* all we really need is bulk IN/OUT */
-	usb_ep_autoconfig_reset (gadget);
-	in_ep = usb_ep_autoconfig (gadget, &fs_source_desc);
+	usb_ep_autoconfig_reset(gadget);
+	in_ep = usb_ep_autoconfig(gadget, &fs_source_desc);
 	if (!in_ep) {
 autoconf_fail:
 		error("can't autoconfigure on %s\n",
@@ -1607,7 +1610,7 @@  autoconf_fail:
 	}
 	in_ep->driver_data = in_ep;	/* claim */
 
-	out_ep = usb_ep_autoconfig (gadget, &fs_sink_desc);
+	out_ep = usb_ep_autoconfig(gadget, &fs_sink_desc);
 	if (!out_ep)
 		goto autoconf_fail;
 	out_ep->driver_data = out_ep;	/* claim */
@@ -1617,7 +1620,7 @@  autoconf_fail:
 	 * Since some hosts expect one, try to allocate one anyway.
 	 */
 	if (cdc) {
-		status_ep = usb_ep_autoconfig (gadget, &fs_status_desc);
+		status_ep = usb_ep_autoconfig(gadget, &fs_status_desc);
 		if (status_ep) {
 			status_ep->driver_data = status_ep;	/* claim */
 		} else if (cdc) {
@@ -1640,7 +1643,7 @@  autoconf_fail:
 	}
 
 	device_desc.bMaxPacketSize0 = gadget->ep0->maxpacket;
-	usb_gadget_set_selfpowered (gadget);
+	usb_gadget_set_selfpowered(gadget);
 
 	if (gadget_is_dualspeed(gadget)) {
 		if (!cdc)
@@ -1668,7 +1671,7 @@  autoconf_fail:
 	}
 
 	dev->net = &l_netdev;
-	strcpy (dev->net->name, USB_NET_NAME);
+	strcpy(dev->net->name, USB_NET_NAME);
 
 	dev->cdc = cdc;
 	dev->zlp = zlp;
@@ -1690,10 +1693,10 @@  autoconf_fail:
 
 	get_ether_addr(host_addr, dev->host_mac);
 
-	sprintf (ethaddr, "%02X%02X%02X%02X%02X%02X",
-		dev->host_mac [0], dev->host_mac [1],
-			dev->host_mac [2], dev->host_mac [3],
-			dev->host_mac [4], dev->host_mac [5]);
+	sprintf(ethaddr, "%02X%02X%02X%02X%02X%02X",
+		dev->host_mac[0], dev->host_mac[1],
+			dev->host_mac[2], dev->host_mac[3],
+			dev->host_mac[4], dev->host_mac[5]);
 
 	printf("using %s, OUT %s IN %s%s%s\n", gadget->name,
 		out_ep->name, in_ep->name,
@@ -1701,15 +1704,15 @@  autoconf_fail:
 		status_ep ? status_ep->name : ""
 		);
 	printf("MAC %02x:%02x:%02x:%02x:%02x:%02x\n",
-		dev->net->enetaddr [0], dev->net->enetaddr [1],
-		dev->net->enetaddr [2], dev->net->enetaddr [3],
-		dev->net->enetaddr [4], dev->net->enetaddr [5]);
+		dev->net->enetaddr[0], dev->net->enetaddr[1],
+		dev->net->enetaddr[2], dev->net->enetaddr[3],
+		dev->net->enetaddr[4], dev->net->enetaddr[5]);
 
 	if (cdc) {
 		printf("HOST MAC %02x:%02x:%02x:%02x:%02x:%02x\n",
-			dev->host_mac [0], dev->host_mac [1],
-			dev->host_mac [2], dev->host_mac [3],
-			dev->host_mac [4], dev->host_mac [5]);
+			dev->host_mac[0], dev->host_mac[1],
+			dev->host_mac[2], dev->host_mac[3],
+			dev->host_mac[4], dev->host_mac[5]);
 	}
 
 	/* use PKTSIZE (or aligned... from u-boot) and set
@@ -1717,7 +1720,7 @@  autoconf_fail:
 	dev->mtu = PKTSIZE_ALIGN; /* RNDIS does not like this, only 1514, TODO*/
 
 	/* preallocate control message data and buffer */
-	dev->req = usb_ep_alloc_request (gadget->ep0, GFP_KERNEL);
+	dev->req = usb_ep_alloc_request(gadget->ep0, GFP_KERNEL);
 	if (!dev->req)
 		goto fail;
 	dev->req->buf = control_req;
@@ -1728,7 +1731,7 @@  autoconf_fail:
 	if (dev->status_ep) {
 		dev->stat_req = usb_ep_alloc_request(dev->status_ep, GFP_KERNEL);
 		if (!dev->stat_req) {
-			usb_ep_free_request (dev->status_ep, dev->req);
+			usb_ep_free_request(dev->status_ep, dev->req);
 
 			goto fail;
 		}
@@ -1739,7 +1742,7 @@  autoconf_fail:
 
 	/* finish hookup to lower layer ... */
 	dev->gadget = gadget;
-	set_gadget_data (gadget, dev);
+	set_gadget_data(gadget, dev);
 	gadget->ep0->driver_data = dev;
 
 	/* two kinds of host-initiated state changes:
@@ -1750,13 +1753,13 @@  autoconf_fail:
 
 fail:
 	error("%s failed", __func__);
-	eth_unbind (gadget);
+	eth_unbind(gadget);
 	return -ENOMEM;
 }
 
-static int usb_eth_init(struct eth_device* netdev, bd_t* bd)
+static int usb_eth_init(struct eth_device *netdev, bd_t *bd)
 {
-	struct eth_dev *dev=&l_ethdev;
+	struct eth_dev *dev = &l_ethdev;
 	struct usb_gadget *gadget;
 	unsigned long ts;
 	unsigned long timeout = USB_CONNECT_TIMEOUT;
@@ -1780,8 +1783,7 @@  static int usb_eth_init(struct eth_device* netdev, bd_t* bd)
 		timeout = simple_strtoul(getenv("cdc_connect_timeout"),
 						NULL, 10) * CONFIG_SYS_HZ;
 	ts = get_timer(0);
-	while (!l_ethdev.network_started)
-	{
+	while (!l_ethdev.network_started) {
 		/* Handle control-c and timeouts */
 		if (ctrlc() || (get_timer(ts) > timeout)) {
 			error("The remote end did not respond in time.");
@@ -1790,19 +1792,20 @@  static int usb_eth_init(struct eth_device* netdev, bd_t* bd)
 		usb_gadget_handle_interrupts();
 	}
 
-	rx_submit (dev, dev->rx_req, 0);
+	rx_submit(dev, dev->rx_req, 0);
 	return 0;
 fail:
 	return -1;
 }
 
-static int usb_eth_send(struct eth_device* netdev, volatile void* packet, int length)
+static int usb_eth_send(struct eth_device *netdev,
+			volatile void *packet, int length)
 {
 	int			retval;
 	struct usb_request	*req = NULL;
 	struct eth_dev		*dev = &l_ethdev;
- 	unsigned long ts;
- 	unsigned long timeout = USB_CONNECT_TIMEOUT;
+	unsigned long ts;
+	unsigned long timeout = USB_CONNECT_TIMEOUT;
 
 	debug("%s:...\n", __func__);
 
@@ -1827,54 +1830,50 @@  static int usb_eth_send(struct eth_device* netdev, volatile void* packet, int le
 		req->no_interrupt = (dev->gadget->speed == USB_SPEED_HIGH)
 			? ((dev->tx_qlen % qmult) != 0) : 0;
 #endif
-	dev->tx_qlen=1;
- 	ts = get_timer(0);
- 	packet_sent = 0;
+	dev->tx_qlen = 1;
+	ts = get_timer(0);
+	packet_sent = 0;
 
-	retval = usb_ep_queue (dev->in_ep, req, GFP_ATOMIC);
+	retval = usb_ep_queue(dev->in_ep, req, GFP_ATOMIC);
 
 	if (!retval)
 		debug("%s: packet queued\n", __func__);
-	while(!packet_sent)
-	{
- 		if (get_timer(ts) > timeout) {
- 			printf("timeout sending packets to usb ethernet\n");
- 			return -1;
- 		}
- 		usb_gadget_handle_interrupts();
+	while (!packet_sent) {
+		if (get_timer(ts) > timeout) {
+			printf("timeout sending packets to usb ethernet\n");
+			return -1;
+		}
+		usb_gadget_handle_interrupts();
 	}
 
 	return 0;
 }
 
-static int usb_eth_recv(struct eth_device* netdev)
+static int usb_eth_recv(struct eth_device *netdev)
 {
 	struct eth_dev *dev = &l_ethdev;
 
 	usb_gadget_handle_interrupts();
 
-	if (packet_received)
-	{
-		debug("%s: packet received \n", __func__);
-		if (dev->rx_req)
-		{
-			NetReceive(NetRxPackets[0],dev->rx_req->length);
-			packet_received=0;
+	if (packet_received) {
+		debug("%s: packet received\n", __func__);
+		if (dev->rx_req) {
+			NetReceive(NetRxPackets[0], dev->rx_req->length);
+			packet_received = 0;
 
 			if (dev->rx_req)
 				rx_submit (dev, dev->rx_req, 0);
-		}
-		else error("dev->rx_req invalid");
+		} else
+			error("dev->rx_req invalid");
 	}
 	return 0;
 }
 
-void usb_eth_halt(struct eth_device* netdev)
+void usb_eth_halt(struct eth_device *netdev)
 {
-	struct eth_dev *dev =&l_ethdev;
+	struct eth_dev *dev = &l_ethdev;
 
-	if (!netdev)
-	{
+	if (!netdev) {
 		error("received NULL ptr");
 		return;
 	}
@@ -1898,9 +1897,9 @@  static struct usb_gadget_driver eth_driver = {
 int usb_eth_initialize(bd_t *bi)
 {
 	int status = 0;
-	struct eth_device *netdev=&l_netdev;
+	struct eth_device *netdev = &l_netdev;
 
-	sprintf(netdev->name,"usb_ether");
+	sprintf(netdev->name, "usb_ether");
 
 	netdev->init = usb_eth_init;
 	netdev->send = usb_eth_send;
diff --git a/drivers/usb/gadget/gadget_chips.h b/drivers/usb/gadget/gadget_chips.h
index 480bc87..9bb7e2e 100644
--- a/drivers/usb/gadget/gadget_chips.h
+++ b/drivers/usb/gadget/gadget_chips.h
@@ -15,109 +15,109 @@ 
  *                      Remy Bohmer <linux@bohmer.net>
  */
 #ifdef CONFIG_USB_GADGET_NET2280
-#define	gadget_is_net2280(g)	!strcmp("net2280", (g)->name)
+#define	gadget_is_net2280(g)	(!strcmp("net2280", (g)->name))
 #else
 #define	gadget_is_net2280(g)	0
 #endif
 
 #ifdef CONFIG_USB_GADGET_AMD5536UDC
-#define	gadget_is_amd5536udc(g)	!strcmp("amd5536udc", (g)->name)
+#define	gadget_is_amd5536udc(g)	(!strcmp("amd5536udc", (g)->name))
 #else
 #define	gadget_is_amd5536udc(g)	0
 #endif
 
 #ifdef CONFIG_USB_GADGET_DUMMY_HCD
-#define	gadget_is_dummy(g)	!strcmp("dummy_udc", (g)->name)
+#define	gadget_is_dummy(g)	(!strcmp("dummy_udc", (g)->name))
 #else
 #define	gadget_is_dummy(g)	0
 #endif
 
 #ifdef CONFIG_USB_GADGET_PXA2XX
-#define	gadget_is_pxa(g)	!strcmp("pxa2xx_udc", (g)->name)
+#define	gadget_is_pxa(g)	(!strcmp("pxa2xx_udc", (g)->name))
 #else
 #define	gadget_is_pxa(g)	0
 #endif
 
 #ifdef CONFIG_USB_GADGET_GOKU
-#define	gadget_is_goku(g)	!strcmp("goku_udc", (g)->name)
+#define	gadget_is_goku(g)	(!strcmp("goku_udc", (g)->name))
 #else
 #define	gadget_is_goku(g)	0
 #endif
 
 /* SH3 UDC -- not yet ported 2.4 --> 2.6 */
 #ifdef CONFIG_USB_GADGET_SUPERH
-#define	gadget_is_sh(g)		!strcmp("sh_udc", (g)->name)
+#define	gadget_is_sh(g)		(!strcmp("sh_udc", (g)->name))
 #else
 #define	gadget_is_sh(g)		0
 #endif
 
 /* not yet stable on 2.6 (would help "original Zaurus") */
 #ifdef CONFIG_USB_GADGET_SA1100
-#define	gadget_is_sa1100(g)	!strcmp("sa1100_udc", (g)->name)
+#define	gadget_is_sa1100(g)	(!strcmp("sa1100_udc", (g)->name))
 #else
 #define	gadget_is_sa1100(g)	0
 #endif
 
 #ifdef CONFIG_USB_GADGET_LH7A40X
-#define	gadget_is_lh7a40x(g)	!strcmp("lh7a40x_udc", (g)->name)
+#define	gadget_is_lh7a40x(g)	(!strcmp("lh7a40x_udc", (g)->name))
 #else
 #define	gadget_is_lh7a40x(g)	0
 #endif
 
 /* handhelds.org tree (?) */
 #ifdef CONFIG_USB_GADGET_MQ11XX
-#define	gadget_is_mq11xx(g)	!strcmp("mq11xx_udc", (g)->name)
+#define	gadget_is_mq11xx(g)	(!strcmp("mq11xx_udc", (g)->name))
 #else
 #define	gadget_is_mq11xx(g)	0
 #endif
 
 #ifdef CONFIG_USB_GADGET_OMAP
-#define	gadget_is_omap(g)	!strcmp("omap_udc", (g)->name)
+#define	gadget_is_omap(g)	(!strcmp("omap_udc", (g)->name))
 #else
 #define	gadget_is_omap(g)	0
 #endif
 
 /* not yet ported 2.4 --> 2.6 */
 #ifdef CONFIG_USB_GADGET_N9604
-#define	gadget_is_n9604(g)	!strcmp("n9604_udc", (g)->name)
+#define	gadget_is_n9604(g)	(!strcmp("n9604_udc", (g)->name))
 #else
 #define	gadget_is_n9604(g)	0
 #endif
 
 /* various unstable versions available */
 #ifdef CONFIG_USB_GADGET_PXA27X
-#define	gadget_is_pxa27x(g)	!strcmp("pxa27x_udc", (g)->name)
+#define	gadget_is_pxa27x(g)	(!strcmp("pxa27x_udc", (g)->name))
 #else
 #define	gadget_is_pxa27x(g)	0
 #endif
 
 #ifdef CONFIG_USB_GADGET_ATMEL_USBA
-#define gadget_is_atmel_usba(g)	!strcmp("atmel_usba_udc", (g)->name)
+#define gadget_is_atmel_usba(g)	(!strcmp("atmel_usba_udc", (g)->name))
 #else
 #define gadget_is_atmel_usba(g)	0
 #endif
 
 #ifdef CONFIG_USB_GADGET_S3C2410
-#define gadget_is_s3c2410(g)    !strcmp("s3c2410_udc", (g)->name)
+#define gadget_is_s3c2410(g)    (!strcmp("s3c2410_udc", (g)->name))
 #else
 #define gadget_is_s3c2410(g)    0
 #endif
 
 #ifdef CONFIG_USB_GADGET_AT91
-#define gadget_is_at91(g)	!strcmp("at91_udc", (g)->name)
+#define gadget_is_at91(g)	(!strcmp("at91_udc", (g)->name))
 #else
 #define gadget_is_at91(g)	0
 #endif
 
 /* status unclear */
 #ifdef CONFIG_USB_GADGET_IMX
-#define gadget_is_imx(g)	!strcmp("imx_udc", (g)->name)
+#define gadget_is_imx(g)	(!strcmp("imx_udc", (g)->name))
 #else
 #define gadget_is_imx(g)	0
 #endif
 
 #ifdef CONFIG_USB_GADGET_FSL_USB2
-#define gadget_is_fsl_usb2(g)	!strcmp("fsl-usb2-udc", (g)->name)
+#define gadget_is_fsl_usb2(g)	(!strcmp("fsl-usb2-udc", (g)->name))
 #else
 #define gadget_is_fsl_usb2(g)	0
 #endif
@@ -125,36 +125,37 @@ 
 /* Mentor high speed function controller */
 /* from Montavista kernel (?) */
 #ifdef CONFIG_USB_GADGET_MUSBHSFC
-#define gadget_is_musbhsfc(g)	!strcmp("musbhsfc_udc", (g)->name)
+#define gadget_is_musbhsfc(g)	(!strcmp("musbhsfc_udc", (g)->name))
 #else
 #define gadget_is_musbhsfc(g)	0
 #endif
 
 /* Mentor high speed "dual role" controller, in peripheral role */
 #ifdef CONFIG_USB_GADGET_MUSB_HDRC
-#define gadget_is_musbhdrc(g)	!strcmp("musb_hdrc", (g)->name)
+#define gadget_is_musbhdrc(g)	(!strcmp("musb_hdrc", (g)->name))
 #else
 #define gadget_is_musbhdrc(g)	0
 #endif
 
 /* from Montavista kernel (?) */
 #ifdef CONFIG_USB_GADGET_MPC8272
-#define gadget_is_mpc8272(g)	!strcmp("mpc8272_udc", (g)->name)
+#define gadget_is_mpc8272(g)	(!strcmp("mpc8272_udc", (g)->name))
 #else
 #define gadget_is_mpc8272(g)	0
 #endif
 
 #ifdef CONFIG_USB_GADGET_M66592
-#define	gadget_is_m66592(g)	!strcmp("m66592_udc", (g)->name)
+#define	gadget_is_m66592(g)	(!strcmp("m66592_udc", (g)->name))
 #else
 #define	gadget_is_m66592(g)	0
 #endif
 
 
-// CONFIG_USB_GADGET_SX2
-// CONFIG_USB_GADGET_AU1X00
-// ...
-
+/*
+ * CONFIG_USB_GADGET_SX2
+ * CONFIG_USB_GADGET_AU1X00
+ * ...
+ */
 
 /**
  * usb_gadget_controller_number - support bcdDevice id convention
diff --git a/drivers/usb/gadget/usbstring.c b/drivers/usb/gadget/usbstring.c
index 168f75f..45dfb1a 100644
--- a/drivers/usb/gadget/usbstring.c
+++ b/drivers/usb/gadget/usbstring.c
@@ -30,8 +30,9 @@  static int utf8_to_utf16le(const char *s, __le16 *cp, unsigned len)
 	 */
 	while (len != 0 && (c = (u8) *s++) != 0) {
 		if ((c & 0x80)) {
-			// 2-byte sequence:
-			// 00000yyyyyxxxxxx = 110yyyyy 10xxxxxx
+			/* 2-byte sequence:
+			 * 00000yyyyyxxxxxx = 110yyyyy 10xxxxxx
+			 */
 			if ((c & 0xe0) == 0xc0) {
 				uchar = (c & 0x1f) << 6;
 
@@ -41,8 +42,9 @@  static int utf8_to_utf16le(const char *s, __le16 *cp, unsigned len)
 				c &= 0x3f;
 				uchar |= c;
 
-			// 3-byte sequence (most CJKV characters):
-			// zzzzyyyyyyxxxxxx = 1110zzzz 10yyyyyy 10xxxxxx
+			/* 3-byte sequence (most CJKV characters):
+			 * zzzzyyyyyyxxxxxx = 1110zzzz 10yyyyyy 10xxxxxx
+			 */
 			} else if ((c & 0xf0) == 0xe0) {
 				uchar = (c & 0x0f) << 12;
 
@@ -62,12 +64,12 @@  static int utf8_to_utf16le(const char *s, __le16 *cp, unsigned len)
 				if (0xd800 <= uchar && uchar <= 0xdfff)
 					goto fail;
 
-			// 4-byte sequence (surrogate pairs, currently rare):
-			// 11101110wwwwzzzzyy + 110111yyyyxxxxxx
-			//     = 11110uuu 10uuzzzz 10yyyyyy 10xxxxxx
-			// (uuuuu = wwww + 1)
-			// FIXME accept the surrogate code points (only)
-
+			/* 4-byte sequence (surrogate pairs, currently rare):
+			 * 11101110wwwwzzzzyy + 110111yyyyxxxxxx
+			 *     = 11110uuu 10uuzzzz 10yyyyyy 10xxxxxx
+			 * (uuuuu = wwww + 1)
+			 * FIXME accept the surrogate code points (only)
+			 */
 			} else
 				goto fail;
 		} else
@@ -100,17 +102,17 @@  fail:
  * characters (which are also widely used in C strings).
  */
 int
-usb_gadget_get_string (struct usb_gadget_strings *table, int id, u8 *buf)
+usb_gadget_get_string(struct usb_gadget_strings *table, int id, u8 *buf)
 {
 	struct usb_string	*s;
 	int			len;
 
 	/* descriptor 0 has the language id */
 	if (id == 0) {
-		buf [0] = 4;
-		buf [1] = USB_DT_STRING;
-		buf [2] = (u8) table->language;
-		buf [3] = (u8) (table->language >> 8);
+		buf[0] = 4;
+		buf[1] = USB_DT_STRING;
+		buf[2] = (u8) table->language;
+		buf[3] = (u8) (table->language >> 8);
 		return 4;
 	}
 	for (s = table->strings; s && s->s; s++)
@@ -122,13 +124,13 @@  usb_gadget_get_string (struct usb_gadget_strings *table, int id, u8 *buf)
 		return -EINVAL;
 
 	/* string descriptors have length, tag, then UTF16-LE text */
-	len = min ((size_t) 126, strlen (s->s));
-	memset (buf + 2, 0, 2 * len);	/* zero all the bytes */
+	len = min((size_t) 126, strlen(s->s));
+	memset(buf + 2, 0, 2 * len);	/* zero all the bytes */
 	len = utf8_to_utf16le(s->s, (__le16 *)&buf[2], len);
 	if (len < 0)
 		return -EINVAL;
-	buf [0] = (len + 1) * 2;
-	buf [1] = USB_DT_STRING;
-	return buf [0];
+	buf[0] = (len + 1) * 2;
+	buf[1] = USB_DT_STRING;
+	return buf[0];
 }
 
diff --git a/include/linux/usb/ch9.h b/include/linux/usb/ch9.h
index 1091692..49b7483 100644
--- a/include/linux/usb/ch9.h
+++ b/include/linux/usb/ch9.h
@@ -69,8 +69,8 @@ 
 #define USB_RECIP_ENDPOINT		0x02
 #define USB_RECIP_OTHER			0x03
 /* From Wireless USB 1.0 */
-#define USB_RECIP_PORT 			0x04
-#define USB_RECIP_RPIPE 		0x05
+#define USB_RECIP_PORT			0x04
+#define USB_RECIP_RPIPE			0x05
 
 /*
  * Standard requests, for the bRequest field of a SETUP packet.
diff --git a/include/linux/usb/gadget.h b/include/linux/usb/gadget.h
index 344fc78..cad2eeb 100644
--- a/include/linux/usb/gadget.h
+++ b/include/linux/usb/gadget.h
@@ -74,8 +74,9 @@  struct usb_ep;
  * Bulk endpoints can use any size buffers, and can also be used for interrupt
  * transfers. interrupt-only endpoints can be much less functional.
  */
-	// NOTE this is analagous to 'struct urb' on the host side,
-	// except that it's thinner and promotes more pre-allocation.
+	/* NOTE this is analagous to 'struct urb' on the host side,
+	 * except that it's thinner and promotes more pre-allocation.
+	 */
 
 struct usb_request {
 	void			*buf;
@@ -171,9 +172,9 @@  struct usb_ep {
  * returns zero, or a negative error code.
  */
 static inline int
-usb_ep_enable (struct usb_ep *ep, const struct usb_endpoint_descriptor *desc)
+usb_ep_enable(struct usb_ep *ep, const struct usb_endpoint_descriptor *desc)
 {
-	return ep->ops->enable (ep, desc);
+	return ep->ops->enable(ep, desc);
 }
 
 /**
@@ -189,9 +190,9 @@  usb_ep_enable (struct usb_ep *ep, const struct usb_endpoint_descriptor *desc)
  * returns zero, or a negative error code.
  */
 static inline int
-usb_ep_disable (struct usb_ep *ep)
+usb_ep_disable(struct usb_ep *ep)
 {
-	return ep->ops->disable (ep);
+	return ep->ops->disable(ep);
 }
 
 /**
@@ -209,9 +210,9 @@  usb_ep_disable (struct usb_ep *ep)
  * Returns the request, or null if one could not be allocated.
  */
 static inline struct usb_request *
-usb_ep_alloc_request (struct usb_ep *ep, gfp_t gfp_flags)
+usb_ep_alloc_request(struct usb_ep *ep, gfp_t gfp_flags)
 {
-	return ep->ops->alloc_request (ep, gfp_flags);
+	return ep->ops->alloc_request(ep, gfp_flags);
 }
 
 /**
@@ -224,9 +225,9 @@  usb_ep_alloc_request (struct usb_ep *ep, gfp_t gfp_flags)
  * no longer be requeued (or otherwise used).
  */
 static inline void
-usb_ep_free_request (struct usb_ep *ep, struct usb_request *req)
+usb_ep_free_request(struct usb_ep *ep, struct usb_request *req)
 {
-	ep->ops->free_request (ep, req);
+	ep->ops->free_request(ep, req);
 }
 
 /**
@@ -284,9 +285,9 @@  usb_ep_free_request (struct usb_ep *ep, struct usb_request *req)
  * reported when the usb peripheral is disconnected.
  */
 static inline int
-usb_ep_queue (struct usb_ep *ep, struct usb_request *req, gfp_t gfp_flags)
+usb_ep_queue(struct usb_ep *ep, struct usb_request *req, gfp_t gfp_flags)
 {
-	return ep->ops->queue (ep, req, gfp_flags);
+	return ep->ops->queue(ep, req, gfp_flags);
 }
 
 /**
@@ -303,9 +304,9 @@  usb_ep_queue (struct usb_ep *ep, struct usb_request *req, gfp_t gfp_flags)
  * restrictions prevent drivers from supporting configuration changes,
  * even to configuration zero (a "chapter 9" requirement).
  */
-static inline int usb_ep_dequeue (struct usb_ep *ep, struct usb_request *req)
+static inline int usb_ep_dequeue(struct usb_ep *ep, struct usb_request *req)
 {
-	return ep->ops->dequeue (ep, req);
+	return ep->ops->dequeue(ep, req);
 }
 
 /**
@@ -330,9 +331,9 @@  static inline int usb_ep_dequeue (struct usb_ep *ep, struct usb_request *req)
  * (usually a FIFO) still holds bytes that the host hasn't collected.
  */
 static inline int
-usb_ep_set_halt (struct usb_ep *ep)
+usb_ep_set_halt(struct usb_ep *ep)
 {
-	return ep->ops->set_halt (ep, 1);
+	return ep->ops->set_halt(ep, 1);
 }
 
 /**
@@ -349,9 +350,9 @@  usb_ep_set_halt (struct usb_ep *ep)
  * and accordingly can't correctly implement interface altsettings.
  */
 static inline int
-usb_ep_clear_halt (struct usb_ep *ep)
+usb_ep_clear_halt(struct usb_ep *ep)
 {
-	return ep->ops->set_halt (ep, 0);
+	return ep->ops->set_halt(ep, 0);
 }
 
 /**
@@ -370,10 +371,10 @@  usb_ep_clear_halt (struct usb_ep *ep)
  * precise handling.
  */
 static inline int
-usb_ep_fifo_status (struct usb_ep *ep)
+usb_ep_fifo_status(struct usb_ep *ep)
 {
 	if (ep->ops->fifo_status)
-		return ep->ops->fifo_status (ep);
+		return ep->ops->fifo_status(ep);
 	else
 		return -EOPNOTSUPP;
 }
@@ -388,10 +389,10 @@  usb_ep_fifo_status (struct usb_ep *ep)
  * protocol translation.
  */
 static inline void
-usb_ep_fifo_flush (struct usb_ep *ep)
+usb_ep_fifo_flush(struct usb_ep *ep)
 {
 	if (ep->ops->fifo_flush)
-		ep->ops->fifo_flush (ep);
+		ep->ops->fifo_flush(ep);
 }
 
 
@@ -475,18 +476,18 @@  struct usb_gadget {
 	struct device			dev;
 };
 
-static inline void set_gadget_data (struct usb_gadget *gadget, void *data)
+static inline void set_gadget_data(struct usb_gadget *gadget, void *data)
 {
 	gadget->dev.driver_data = data;
 }
 
-static inline void *get_gadget_data (struct usb_gadget *gadget)
+static inline void *get_gadget_data(struct usb_gadget *gadget)
 {
 	return gadget->dev.driver_data;
 }
 
 /* iterates the non-control endpoints; 'tmp' is a struct usb_ep pointer */
-#define gadget_for_each_ep(tmp,gadget) \
+#define gadget_for_each_ep(tmp, gadget) \
 	list_for_each_entry(tmp, &(gadget)->ep_list, ep_list)
 
 
@@ -530,9 +531,9 @@  static inline int gadget_is_otg(struct usb_gadget *g)
  * Returns the usb frame number, normally eleven bits from a SOF packet,
  * or negative errno if this device doesn't support this capability.
  */
-static inline int usb_gadget_frame_number (struct usb_gadget *gadget)
+static inline int usb_gadget_frame_number(struct usb_gadget *gadget)
 {
-	return gadget->ops->get_frame (gadget);
+	return gadget->ops->get_frame(gadget);
 }
 
 /**
@@ -548,11 +549,11 @@  static inline int usb_gadget_frame_number (struct usb_gadget *gadget)
  * even if OTG isn't otherwise in use.  OTG devices may also start
  * remote wakeup even when hosts don't explicitly enable it.
  */
-static inline int usb_gadget_wakeup (struct usb_gadget *gadget)
+static inline int usb_gadget_wakeup(struct usb_gadget *gadget)
 {
 	if (!gadget->ops->wakeup)
 		return -EOPNOTSUPP;
-	return gadget->ops->wakeup (gadget);
+	return gadget->ops->wakeup(gadget);
 }
 
 /**
@@ -565,11 +566,11 @@  static inline int usb_gadget_wakeup (struct usb_gadget *gadget)
  * returns zero on success, else negative errno.
  */
 static inline int
-usb_gadget_set_selfpowered (struct usb_gadget *gadget)
+usb_gadget_set_selfpowered(struct usb_gadget *gadget)
 {
 	if (!gadget->ops->set_selfpowered)
 		return -EOPNOTSUPP;
-	return gadget->ops->set_selfpowered (gadget, 1);
+	return gadget->ops->set_selfpowered(gadget, 1);
 }
 
 /**
@@ -583,11 +584,11 @@  usb_gadget_set_selfpowered (struct usb_gadget *gadget)
  * returns zero on success, else negative errno.
  */
 static inline int
-usb_gadget_clear_selfpowered (struct usb_gadget *gadget)
+usb_gadget_clear_selfpowered(struct usb_gadget *gadget)
 {
 	if (!gadget->ops->set_selfpowered)
 		return -EOPNOTSUPP;
-	return gadget->ops->set_selfpowered (gadget, 0);
+	return gadget->ops->set_selfpowered(gadget, 0);
 }
 
 /**
@@ -607,7 +608,7 @@  usb_gadget_vbus_connect(struct usb_gadget *gadget)
 {
 	if (!gadget->ops->vbus_session)
 		return -EOPNOTSUPP;
-	return gadget->ops->vbus_session (gadget, 1);
+	return gadget->ops->vbus_session(gadget, 1);
 }
 
 /**
@@ -627,7 +628,7 @@  usb_gadget_vbus_draw(struct usb_gadget *gadget, unsigned mA)
 {
 	if (!gadget->ops->vbus_draw)
 		return -EOPNOTSUPP;
-	return gadget->ops->vbus_draw (gadget, mA);
+	return gadget->ops->vbus_draw(gadget, mA);
 }
 
 /**
@@ -645,7 +646,7 @@  usb_gadget_vbus_disconnect(struct usb_gadget *gadget)
 {
 	if (!gadget->ops->vbus_session)
 		return -EOPNOTSUPP;
-	return gadget->ops->vbus_session (gadget, 0);
+	return gadget->ops->vbus_session(gadget, 0);
 }
 
 /**
@@ -660,11 +661,11 @@  usb_gadget_vbus_disconnect(struct usb_gadget *gadget)
  * Returns zero on success, else negative errno.
  */
 static inline int
-usb_gadget_connect (struct usb_gadget *gadget)
+usb_gadget_connect(struct usb_gadget *gadget)
 {
 	if (!gadget->ops->pullup)
 		return -EOPNOTSUPP;
-	return gadget->ops->pullup (gadget, 1);
+	return gadget->ops->pullup(gadget, 1);
 }
 
 /**
@@ -683,11 +684,11 @@  usb_gadget_connect (struct usb_gadget *gadget)
  * Returns zero on success, else negative errno.
  */
 static inline int
-usb_gadget_disconnect (struct usb_gadget *gadget)
+usb_gadget_disconnect(struct usb_gadget *gadget)
 {
 	if (!gadget->ops->pullup)
 		return -EOPNOTSUPP;
-	return gadget->ops->pullup (gadget, 0);
+	return gadget->ops->pullup(gadget, 0);
 }
 
 
@@ -795,7 +796,7 @@  struct usb_gadget_driver {
  * the bind() functions will be in init sections.
  * This function must be called in a context that can sleep.
  */
-int usb_gadget_register_driver (struct usb_gadget_driver *driver);
+int usb_gadget_register_driver(struct usb_gadget_driver *driver);
 
 /**
  * usb_gadget_unregister_driver - unregister a gadget driver
@@ -810,7 +811,7 @@  int usb_gadget_register_driver (struct usb_gadget_driver *driver);
  * will in in exit sections, so may not be linked in some kernels.
  * This function must be called in a context that can sleep.
  */
-int usb_gadget_unregister_driver (struct usb_gadget_driver *driver);
+int usb_gadget_unregister_driver(struct usb_gadget_driver *driver);
 
 /*-------------------------------------------------------------------------*/
 
@@ -843,7 +844,7 @@  struct usb_gadget_strings {
 };
 
 /* put descriptor for string with that id into buf (buflen >= 256) */
-int usb_gadget_get_string (struct usb_gadget_strings *table, int id, u8 *buf);
+int usb_gadget_get_string(struct usb_gadget_strings *table, int id, u8 *buf);
 
 /*-------------------------------------------------------------------------*/
 
@@ -861,10 +862,10 @@  int usb_gadget_config_buf(const struct usb_config_descriptor *config,
 
 /* utility wrapping a simple endpoint selection policy */
 
-extern struct usb_ep *usb_ep_autoconfig (struct usb_gadget *,
+extern struct usb_ep *usb_ep_autoconfig(struct usb_gadget *,
 			struct usb_endpoint_descriptor *);
 
-extern void usb_ep_autoconfig_reset (struct usb_gadget *);
+extern void usb_ep_autoconfig_reset(struct usb_gadget *);
 
 extern int usb_gadget_handle_interrupts(void);