Cosmetic changes only - tab, whitespace and brace policing

git-svn-id: svn://svn.rockbox.org/rockbox/trunk@14484 a1c6a512-1295-4272-9138-f99709370657

13 files changed, 562 insertions, 559 deletions

diff --git a/firmware/drivers/usb/arcotg_dcd.c b/firmware/drivers/usb/arcotg_dcd.c
index b545026..59ca93a 100644
--- a/firmware/drivers/usb/arcotg_dcd.c
+++ b/firmware/drivers/usb/arcotg_dcd.c
@@ -118,14 +118,15 @@ timer_expired(struct timer * timer)
 /* gets called by usb_stack_init() to register 
  * this arcotg device conrtollder driver in the 
  * stack. */
-void usb_dcd_init(void) {
+void usb_dcd_init(void)
+{
     usb_controller_register(&arcotg_dcd);
 }
 
 /*-------------------------------------------------------------------------*/
 
-void usb_arcotg_dcd_init(void) {
-
+void usb_arcotg_dcd_init(void)
+{
     struct timer t;
     int i, ep_num = 0;
 
@@ -180,35 +181,36 @@ void usb_arcotg_dcd_init(void) {
     /* put controller in device mode */
     UDC_USBMODE |= USB_MODE_CTRL_MODE_DEVICE;
 
-    /* init queue heads */    
+    /* init queue heads */
     qh_init(0, USB_RECV, USB_ENDPOINT_XFER_CONTROL, USB_MAX_CTRL_PAYLOAD, 0, 0);
-    qh_init(0, USB_SEND, USB_ENDPOINT_XFER_CONTROL, USB_MAX_CTRL_PAYLOAD, 0, 0);    
+    qh_init(0, USB_SEND, USB_ENDPOINT_XFER_CONTROL, USB_MAX_CTRL_PAYLOAD, 0, 0);
 
     UDC_ENDPOINTLISTADDR = (unsigned int)dev_qh;
 }
 
-void usb_arcotg_dcd_shutdown(void) {
+void usb_arcotg_dcd_shutdown(void)
+{
 
 }
 
-void usb_arcotg_dcd_start(void) {
-
+void usb_arcotg_dcd_start(void)
+{
     logf("start");
 
     if (arcotg_dcd.device_driver != NULL) {
-    	logf("YEEEEEEESSSSSSS");
+        logf("YEEEEEEESSSSSSS");
     } else {
-    	logf("NOOOOOO");
+        logf("NOOOOOO");
     }
-    
+
     /* clear stopped bit */
-    dcd_controller.stopped = false;   
+    dcd_controller.stopped = false;
 
     UDC_USBCMD |= USB_CMD_RUN;
 }
 
-void usb_arcotg_dcd_stop(void) {
-
+void usb_arcotg_dcd_stop(void)
+{
     logf("stop");
 
     /* set stopped bit */
@@ -217,8 +219,8 @@ void usb_arcotg_dcd_stop(void) {
     UDC_USBCMD &= ~USB_CMD_RUN;
 }
 
-void usb_arcotg_dcd_irq(void) {
-
+void usb_arcotg_dcd_irq(void)
+{
     if (dcd_controller.stopped == true) {
         return;
     }
@@ -241,10 +243,10 @@ void usb_arcotg_dcd_irq(void) {
         }
 
         if (UDC_ENDPTCOMPLETE) {
-        	UDC_ENDPTCOMPLETE = UDC_ENDPTCOMPLETE;
+            UDC_ENDPTCOMPLETE = UDC_ENDPTCOMPLETE;
         }
     }
-    
+
     if (UDC_USBSTS & USB_STS_PORT_CHANGE) {
         port_change_int();
     }
@@ -269,12 +271,12 @@ void usb_arcotg_dcd_irq(void) {
 /*-------------------------------------------------------------------------*/
 /* interrupt handlers */
 
-static void setup_received_int(struct usb_ctrlrequest* request) {
-
+static void setup_received_int(struct usb_ctrlrequest* request)
+{
     int error = 0;
     uint8_t address = 0;
     int handled = 0;    /* set to zero if we do not handle the message, */
-                        /* and should pass it to the driver */	
+                        /* and should pass it to the driver */
 
     logf("setup_int");
     into_usb_ctrlrequest(request);
@@ -324,16 +326,16 @@ static void setup_received_int(struct usb_ctrlrequest* request) {
                 }
 
                 if (handled == 0) {
-                	handled = 1; /* dont pass it to driver */
+                    handled = 1; /* dont pass it to driver */
                 }
             }
-#if 0            
+#if 0
             if (rc == 0) {
                 /* send status only if _arcotg_ep_set_halt success */
                 if (ep0_prime_status(udc, EP_DIR_IN))
                     Ep0Stall(udc);
-            }		
-#endif		
+            }
+#endif
             break;
     }
 
@@ -358,8 +360,8 @@ static void setup_received_int(struct usb_ctrlrequest* request) {
     }
 }
 
-static void port_change_int(void) {
-
+static void port_change_int(void)
+{
     //logf("port_change_int");
     uint32_t tmp;
     enum usb_device_speed speed = USB_SPEED_UNKNOWN; 
@@ -386,7 +388,7 @@ static void port_change_int(void) {
 
     /* update speed */
     arcotg_dcd.speed = speed;
-    
+
     /* update USB state */
     if (!dcd_controller.resume_state) {
         dcd_controller.usb_state = USB_STATE_DEFAULT;
@@ -398,8 +400,8 @@ static void port_change_int(void) {
     }
 }
 
-static void suspend_int(void) {
-
+static void suspend_int(void)
+{
     //logf("suspend_int");
     dcd_controller.resume_state = dcd_controller.usb_state;
     dcd_controller.usb_state = USB_STATE_SUSPENDED;
@@ -410,8 +412,8 @@ static void suspend_int(void) {
     }
 }
 
-static void resume_int(void) {
-
+static void resume_int(void)
+{
     //logf("resume_int");
     dcd_controller.usb_state = dcd_controller.resume_state;
     dcd_controller.resume_state = USB_STATE_NOTATTACHED;
@@ -422,8 +424,8 @@ static void resume_int(void) {
     }
 }
 
-static void reset_int(void) {
-
+static void reset_int(void)
+{
     //logf("reset_int");
     struct timer t;
 
@@ -459,12 +461,12 @@ static void reset_int(void) {
 /*-------------------------------------------------------------------------*/
 /* usb controller ops */
 
-int usb_arcotg_dcd_enable(struct usb_ep* ep) {
-
+int usb_arcotg_dcd_enable(struct usb_ep* ep)
+{
     unsigned short max = 0;
     unsigned char mult = 0, zlt = 0;
     int retval = 0;
-    char *val = NULL;	/* for debug */
+    char *val = NULL;    /* for debug */
 
     /* catch bogus parameter */
     if (!ep) {
@@ -496,105 +498,105 @@ int usb_arcotg_dcd_enable(struct usb_ep* ep) {
 
 #if 0
     switch (ep->desc->bmAttributes & 0x03) {
-	case USB_ENDPOINT_XFER_BULK:
-		if (strstr(ep->ep.name, "-iso") || strstr(ep->ep.name, "-int")) {
-			goto en_done;
-		}
-		mult = 0;
-		zlt = 1;
-		
-		switch (arcotg_dcd.speed) {
-		case USB_SPEED_HIGH:
-			if ((max == 128) || (max == 256) || (max == 512)) {
-				break;
-			}
-		default:
-			switch (max) {
-			case 4:
-			case 8:
-			case 16:
-			case 32:
-			case 64:
-				break;
-			default:
-	+			case USB_SPEED_LOW:
-	+				goto en_done;
-	+			}
-	+		}
-	+		break;
-	+	case USB_ENDPOINT_XFER_INT:
-	+		if (strstr(ep->ep.name, "-iso"))	/* bulk is ok */
-	+			goto en_done;
-	+		mult = 0;
-	+		zlt = 1;
-	+		switch (udc->gadget.speed) {
-	+		case USB_SPEED_HIGH:
-	+			if (max <= 1024)
-	+				break;
-	+		case USB_SPEED_FULL:
-	+			if (max <= 64)
-	+				break;
-	+		default:
-	+			if (max <= 8)
-	+				break;
-	+			goto en_done;
-	+		}
-	+		break;
-	+	case USB_ENDPOINT_XFER_ISOC:
-	+		if (strstr(ep->ep.name, "-bulk") || strstr(ep->ep.name, "-int"))
-	+			goto en_done;
-	+		mult = (unsigned char)
-	+		    (1 + ((le16_to_cpu(desc->wMaxPacketSize) >> 11) & 0x03));
-	+		zlt = 0;
-	+		switch (udc->gadget.speed) {
-	+		case USB_SPEED_HIGH:
-	+			if (max <= 1024)
-	+				break;
-	+		case USB_SPEED_FULL:
-	+			if (max <= 1023)
-	+				break;
-	+		default:
-	+			goto en_done;
-	+		}
-	+		break;
-	+	case USB_ENDPOINT_XFER_CONTROL:
-	+		if (strstr(ep->ep.name, "-iso") || strstr(ep->ep.name, "-int"))
-	+			goto en_done;
-	+		mult = 0;
-	+		zlt = 1;
-	+		switch (udc->gadget.speed) {
-	+		case USB_SPEED_HIGH:
-	+		case USB_SPEED_FULL:
-	+			switch (max) {
-	+			case 1:
-	+			case 2:
-	+			case 4:
-	+			case 8:
-	+			case 16:
-	+			case 32:
-	+			case 64:
-	+				break;
-	+			default:
-	+				goto en_done;
-	+			}
-	+		case USB_SPEED_LOW:
-	+			switch (max) {
-	+			case 1:
-	+			case 2:
-	+			case 4:
-	+			case 8:
-	+				break;
-	+			default:
-	+				goto en_done;
-	+			}
-	+		default:
-	+			goto en_done;
-	+		}
-	+		break;
-	+
-	+	default:
-	+		goto en_done;
-	+	}
+    case USB_ENDPOINT_XFER_BULK:
+        if (strstr(ep->ep.name, "-iso") || strstr(ep->ep.name, "-int")) {
+            goto en_done;
+        }
+        mult = 0;
+        zlt = 1;
+
+        switch (arcotg_dcd.speed) {
+        case USB_SPEED_HIGH:
+            if ((max == 128) || (max == 256) || (max == 512)) {
+                break;
+            }
+        default:
+            switch (max) {
+            case 4:
+            case 8:
+            case 16:
+            case 32:
+            case 64:
+                break;
+            default:
+    +            case USB_SPEED_LOW:
+    +                goto en_done;
+    +            }
+    +        }
+    +        break;
+    +    case USB_ENDPOINT_XFER_INT:
+    +        if (strstr(ep->ep.name, "-iso"))    /* bulk is ok */
+    +            goto en_done;
+    +        mult = 0;
+    +        zlt = 1;
+    +        switch (udc->gadget.speed) {
+    +        case USB_SPEED_HIGH:
+    +            if (max <= 1024)
+    +                break;
+    +        case USB_SPEED_FULL:
+    +            if (max <= 64)
+    +                break;
+    +        default:
+    +            if (max <= 8)
+    +                break;
+    +            goto en_done;
+    +        }
+    +        break;
+    +    case USB_ENDPOINT_XFER_ISOC:
+    +        if (strstr(ep->ep.name, "-bulk") || strstr(ep->ep.name, "-int"))
+    +            goto en_done;
+    +        mult = (unsigned char)
+    +            (1 + ((le16_to_cpu(desc->wMaxPacketSize) >> 11) & 0x03));
+    +        zlt = 0;
+    +        switch (udc->gadget.speed) {
+    +        case USB_SPEED_HIGH:
+    +            if (max <= 1024)
+    +                break;
+    +        case USB_SPEED_FULL:
+    +            if (max <= 1023)
+    +                break;
+    +        default:
+    +            goto en_done;
+    +        }
+    +        break;
+    +    case USB_ENDPOINT_XFER_CONTROL:
+    +        if (strstr(ep->ep.name, "-iso") || strstr(ep->ep.name, "-int"))
+    +            goto en_done;
+    +        mult = 0;
+    +        zlt = 1;
+    +        switch (udc->gadget.speed) {
+    +        case USB_SPEED_HIGH:
+    +        case USB_SPEED_FULL:
+    +            switch (max) {
+    +            case 1:
+    +            case 2:
+    +            case 4:
+    +            case 8:
+    +            case 16:
+    +            case 32:
+    +            case 64:
+    +                break;
+    +            default:
+    +                goto en_done;
+    +            }
+    +        case USB_SPEED_LOW:
+    +            switch (max) {
+    +            case 1:
+    +            case 2:
+    +            case 4:
+    +            case 8:
+    +                break;
+    +            default:
+    +                goto en_done;
+    +            }
+    +        default:
+    +            goto en_done;
+    +        }
+    +        break;
+    +
+    +    default:
+    +        goto en_done;
+    +    }
 #endif
 
     /* here initialize variable of ep */
@@ -643,8 +645,8 @@ int usb_arcotg_dcd_enable(struct usb_ep* ep) {
     return retval;
 }
 
-int usb_arcotg_dcd_set_halt(struct usb_ep* ep, bool halt) {
-
+int usb_arcotg_dcd_set_halt(struct usb_ep* ep, bool halt)
+{
     int status = -EOPNOTSUPP; /* operation not supported */
     unsigned char dir = 0;
     unsigned int tmp_epctrl = 0;
@@ -688,8 +690,8 @@ out:
     return status;
 }
 
-int usb_arcotg_dcd_send(struct usb_ep* ep, struct usb_response* res) {
-
+int usb_arcotg_dcd_send(struct usb_ep* ep, struct usb_response* res)
+{
     char* ptr;
     int todo, error, size, done = 0;
     int index = 1; /* use as default ep0 tx qh and td */
@@ -750,8 +752,8 @@ int usb_arcotg_dcd_send(struct usb_ep* ep, struct usb_response* res) {
     return done;
 }
 
-int usb_arcotg_dcd_receive(struct usb_ep* ep, struct usb_response* res) {
-
+int usb_arcotg_dcd_receive(struct usb_ep* ep, struct usb_response* res)
+{
     char* ptr;
     int todo, error, size, done = 0;
     int index = 0; /* use as default ep0 rx qh and td */
@@ -812,9 +814,9 @@ int usb_arcotg_dcd_receive(struct usb_ep* ep, struct usb_response* res) {
 /* lifecylce */
 
 static void qh_init(unsigned char ep_num, unsigned char dir, unsigned char ep_type,
-                    unsigned int max_pkt_len, unsigned int zlt, unsigned char mult) {
-
-    struct dqh *qh = &dev_qh[2 * ep_num + dir];   
+                    unsigned int max_pkt_len, unsigned int zlt, unsigned char mult)
+{
+    struct dqh *qh = &dev_qh[2 * ep_num + dir];
     uint32_t tmp = 0;
     memset(qh, 0, sizeof(struct dqh));
 
@@ -856,8 +858,8 @@ static void qh_init(unsigned char ep_num, unsigned char dir, unsigned char ep_ty
     logf("qh: init %d", (2 * ep_num + dir));
 }
 
-static void td_init(struct dtd* td, void* buffer, uint32_t todo) {
-
+static void td_init(struct dtd* td, void* buffer, uint32_t todo)
+{
     /* see 32.14.5.2 Building a Transfer Descriptor */
 
     /* init first 7 dwords with 0 */
@@ -878,8 +880,8 @@ static void td_init(struct dtd* td, void* buffer, uint32_t todo) {
     td->buf_ptr0 = (uint32_t)buffer;
 }
 
-static void ep_setup(unsigned char ep_num, unsigned char dir, unsigned char ep_type) {
-
+static void ep_setup(unsigned char ep_num, unsigned char dir, unsigned char ep_type)
+{
     unsigned int tmp_epctrl = 0;
     struct timer t;
 
@@ -901,23 +903,23 @@ static void ep_setup(unsigned char ep_num, unsigned char dir, unsigned char ep_t
     }
 
     UDC_ENDPTCTRL(ep_num) = tmp_epctrl;
-    
+
     /* wait for the write reg to finish */
 
-    timer_set(&t, SETUP_TIMER);    
+    timer_set(&t, SETUP_TIMER);
     while (!(UDC_ENDPTCTRL(ep_num) & (tmp_epctrl & (EPCTRL_TX_ENABLE | EPCTRL_RX_ENABLE)))) {
         if (timer_expired(&t)) {
-        	logf("TIMEOUT: enable ep");
+            logf("TIMEOUT: enable ep");
             return;
-        }    	
+        }
     }
 }
 
 /*-------------------------------------------------------------------------*/
 /* helpers for sending/receiving */
 
-static int td_enqueue(struct dtd* td, struct dqh* qh, unsigned int mask) {
-
+static int td_enqueue(struct dtd* td, struct dqh* qh, unsigned int mask)
+{
     struct timer t;
 
     qh->dtd_ovrl.next_dtd   = (unsigned int)td;
@@ -940,8 +942,8 @@ static int td_enqueue(struct dtd* td, struct dqh* qh, unsigned int mask) {
     return 0;
 }
 
-static int td_wait(struct dtd* td, unsigned int mask) {
-
+static int td_wait(struct dtd* td, unsigned int mask)
+{
     struct timer t;
     timer_set(&t, TRANSFER_TIMER);
 
@@ -960,8 +962,8 @@ static int td_wait(struct dtd* td, unsigned int mask) {
     }
 }
 
-static int usb_ack(struct usb_ctrlrequest * s, int error) {
-
+static int usb_ack(struct usb_ctrlrequest * s, int error)
+{
     if (error) {
         logf("STALLing ep0");
         UDC_ENDPTCTRL0 |= 1 << 16; /* stall */
diff --git a/firmware/drivers/usb/arcotg_dcd.h b/firmware/drivers/usb/arcotg_dcd.h
index 127ee43..68c2468 100644
--- a/firmware/drivers/usb/arcotg_dcd.h
+++ b/firmware/drivers/usb/arcotg_dcd.h
@@ -42,8 +42,8 @@
 
 #define ep_is_in(EP)    (((EP)->desc->bEndpointAddress & USB_DIR_IN)==USB_DIR_IN)
 
-#define EP_DIR_IN	1
-#define EP_DIR_OUT	0
+#define EP_DIR_IN       1
+#define EP_DIR_OUT      0
 
 /*-------------------------------------------------------------------------*/
 
diff --git a/firmware/target/arm/usb-fw-pp502x.c b/firmware/target/arm/usb-fw-pp502x.c
index 3c6b689..e76c250 100644
--- a/firmware/target/arm/usb-fw-pp502x.c
+++ b/firmware/target/arm/usb-fw-pp502x.c
@@ -150,7 +150,7 @@ bool usb_detect(void)
     if ((usbstatus1 == true) && (prev_usbstatus1 == false)) {
         usb_stack_start();
     } else if ((usbstatus1 == false) && (prev_usbstatus1 == true)) {
-    	usb_stack_stop();
+        usb_stack_stop();
     }
 #else
     if ((usbstatus1 == true) && (prev_usbstatus1 == false)) {
diff --git a/firmware/usbstack/config.h b/firmware/usbstack/config.h
index 95b00da..e9cbe63 100644
--- a/firmware/usbstack/config.h
+++ b/firmware/usbstack/config.h
@@ -25,7 +25,7 @@
 #define USBSTACK_CAPS 0
 #endif
 
-#define CONTROLLER_DEVICE	 (1 << 0)
+#define CONTROLLER_DEVICE    (1 << 0)
 #define CONTROLLER_HOST      (1 << 1)
 
 #endif /*_USBSTACK_CONFIG_H_*/
diff --git a/firmware/usbstack/core.h b/firmware/usbstack/core.h
index 7bda293..33805ac 100644
--- a/firmware/usbstack/core.h
+++ b/firmware/usbstack/core.h
@@ -38,7 +38,7 @@ struct usb_response {
 struct usb_ep {
     const char name[15];
     uint8_t type;
-    uint32_t ep_num;	/* which endpoint? */
+    uint32_t ep_num;    /* which endpoint? */
     uint32_t pipe_num;  /* which pipe? */
     uint32_t maxpacket;
     bool claimed;
diff --git a/firmware/usbstack/core/config.c b/firmware/usbstack/core/config.c
index a05a508..277156d 100644
--- a/firmware/usbstack/core/config.c
+++ b/firmware/usbstack/core/config.c
@@ -23,58 +23,58 @@
 #include <string.h>
 #include "usbstack/core.h"
 
-static int usb_descriptor_fillbuf(void* buf, unsigned buflen, struct usb_descriptor_header** src) {
-	
-	uint8_t* dest = buf;
+static int usb_descriptor_fillbuf(void* buf, unsigned buflen, struct usb_descriptor_header** src)
+{
+    uint8_t* dest = buf;
 
-	if (!src) {
-		return -EINVAL;
-	}
+    if (!src) {
+        return -EINVAL;
+    }
 
-	/* fill buffer from src[] until null descriptor ptr */
-	for (; 0 != *src; src++) {
-		unsigned len = (*src)->bLength;
+    /* fill buffer from src[] until null descriptor ptr */
+    for (; 0 != *src; src++) {
+        unsigned len = (*src)->bLength;
 
-		logf("len: %d", len);
-		
-		if (len > buflen)
-			return -EINVAL;
-		memcpy(dest, *src, len);
-		buflen -= len;
-		dest += len;
-	}
-	return dest - (uint8_t *)buf;
+        logf("len: %d", len);
+
+        if (len > buflen)
+            return -EINVAL;
+        memcpy(dest, *src, len);
+        buflen -= len;
+        dest += len;
+    }
+    return dest - (uint8_t *)buf;
 }
 
-int usb_stack_configdesc(const struct usb_config_descriptor* config, void* buf, unsigned length, struct usb_descriptor_header** desc) {
-	
+int usb_stack_configdesc(const struct usb_config_descriptor* config, void* buf, unsigned length, struct usb_descriptor_header** desc)
+{
     struct usb_config_descriptor* cp = buf;
-	int len;
+    int len;
+
+    if (length < USB_DT_CONFIG_SIZE || !desc) {
+        return -EINVAL;
+    }
+
+    /* config descriptor first */
+    *cp = *config; 
+
+    /* then interface/endpoint/class/vendor/... */
+    len = usb_descriptor_fillbuf(USB_DT_CONFIG_SIZE + (uint8_t*)buf, length - USB_DT_CONFIG_SIZE, desc);
+
+    if (len < 0) {
+        return len;
+    }
 
-	if (length < USB_DT_CONFIG_SIZE || !desc) {
-		return -EINVAL;
-	}
-	
-	/* config descriptor first */
-	*cp = *config; 
+    len += USB_DT_CONFIG_SIZE;
+    if (len > 0xffff) {
+        return -EINVAL;
+    }
 
-	/* then interface/endpoint/class/vendor/... */
-	len = usb_descriptor_fillbuf(USB_DT_CONFIG_SIZE + (uint8_t*)buf, length - USB_DT_CONFIG_SIZE, desc);
-	
-	if (len < 0) {
-		return len;
-	}
-	
-	len += USB_DT_CONFIG_SIZE;
-	if (len > 0xffff) {
-		return -EINVAL;
-	}
+    /* patch up the config descriptor */
+    cp->bLength = USB_DT_CONFIG_SIZE;
+    cp->bDescriptorType = USB_DT_CONFIG;
+    cp->wTotalLength = len;
+    cp->bmAttributes |= USB_CONFIG_ATT_ONE;
 
-	/* patch up the config descriptor */
-	cp->bLength = USB_DT_CONFIG_SIZE;
-	cp->bDescriptorType = USB_DT_CONFIG;
-	cp->wTotalLength = len;
-	cp->bmAttributes |= USB_CONFIG_ATT_ONE;
-	
-	return len;
+    return len;
 }
diff --git a/firmware/usbstack/core/core.c b/firmware/usbstack/core/core.c
index 61b7f83..94131ac 100644
--- a/firmware/usbstack/core/core.c
+++ b/firmware/usbstack/core/core.c
@@ -39,26 +39,26 @@ static void bind_device_driver(struct usb_device_driver* driver);
 /**
  * Initialize usb stack.
  */
-void usb_stack_init(void) {
+void usb_stack_init(void)
+{
+    int i;
+    logf("usb_stack_init");
 
-    int i;	
-	logf("usb_stack_init");
-	
     /* init datastructures */
     usbcore.controller[0] = NULL;
     usbcore.controller[1] = NULL;
     usbcore.active_controller = NULL;
     usbcore.device_driver = NULL;
     usbcore.running = false;
-    
+
     memset(&device_driver_names, 0, USB_STACK_MAX_SETTINGS_NAME);
-    
+
     /* init arrays */
     for (i = 0; i < NUM_DRIVERS; i++) {
-    	usbcore.device_drivers[i] = NULL;
-    	usbcore.host_drivers[i] = NULL;
+        usbcore.device_drivers[i] = NULL;
+        usbcore.host_drivers[i] = NULL;
     }
-    
+
     /* init controllers */
 #if (USBSTACK_CAPS & CONTROLLER_DEVICE)
     usb_dcd_init();
@@ -77,31 +77,31 @@ void usb_stack_init(void) {
  * Start processing of usb stack. This function init
  * active usb controller.
  */
-void usb_stack_start(void) {
-
-	/* are we allready running? */
-	if (usbcore.running) {
-		logf("allready running!");
-		return;
-	}
-	
-	if (usbcore.active_controller == NULL) {
-		logf("no active controller!");
-		return;
-	}
-	
+void usb_stack_start(void)
+{
+    /* are we allready running? */
+    if (usbcore.running) {
+        logf("allready running!");
+        return;
+    }
+
+    if (usbcore.active_controller == NULL) {
+        logf("no active controller!");
+        return;
+    }
+
     /* forward to controller */
-	logf("starting controller");
+    logf("starting controller");
     usbcore.active_controller->start();
     usbcore.running = true;
-    
+
     /* look if started controller is a device controller
      * and if it has a device driver bind to it */
     logf("check for auto bind");
     if (usbcore.active_controller->type == DEVICE) {
         if (usbcore.active_controller->device_driver == NULL && usbcore.device_driver != NULL) {
             /* bind driver */
-        	logf("binding...");
+            logf("binding...");
             bind_device_driver(usbcore.device_driver);
         }
     }
@@ -111,15 +111,15 @@ void usb_stack_start(void) {
  * Stop processing of usb stack. This function shutsdown
  * active usb controller.
  */
-void usb_stack_stop(void) {
+void usb_stack_stop(void)
+{
+    /* are we allready stopped? */
+    if (usbcore.running == false) {
+        return;
+    }
 
-	/* are we allready stopped? */
-	if (usbcore.running == false) {
-		return;
-	}
-	
     /* forward to controller */
-    usbcore.active_controller->stop();    
+    usbcore.active_controller->stop();
     usbcore.running = false;
 }
 
@@ -127,8 +127,8 @@ void usb_stack_stop(void) {
  * Gets called by upper layers to indicate that there is
  * an interrupt waiting for the controller.
  */
-void usb_stack_irq(void) {
-
+void usb_stack_irq(void)
+{
     /* simply notify usb controller */
     if (usbcore.active_controller != NULL && usbcore.active_controller->irq != NULL) {
         usbcore.active_controller->irq();
@@ -140,7 +140,8 @@ void usb_stack_irq(void) {
  * to call for maintanence. We need to check if a new device has connected,
  * find suitable drivers for new devices.
  */
-void usb_stack_work(void) {
+void usb_stack_work(void)
+{
     /* TODO will be used with host device controllers 
      * and needs to be called in a loop (thread) */
 }
@@ -153,8 +154,8 @@ void usb_stack_work(void) {
  * @param ctrl pointer to controller to register.
  * @return 0 on success else a defined error code. 
  */
-int usb_controller_register(struct usb_controller* ctrl) {
-
+int usb_controller_register(struct usb_controller* ctrl)
+{
     if (ctrl == NULL) {
         return EINVAL;
     }
@@ -220,21 +221,21 @@ int usb_controller_unregister(struct usb_controller* ctrl) {
  * 
  * @param type of controller to activate.
  */
-void usb_controller_select(int type) {
-	
+void usb_controller_select(int type)
+{
     struct usb_controller* new = NULL;
 
     /* check if a controller of the wanted type is already loaded */
     if (usbcore.active_controller != NULL && (int)usbcore.active_controller->type == type) {
-    	logf("controller already set");
-    	return;
+        logf("controller already set");
+        return;
     }
 
-	logf("usb_controller_select");
-	logf("  -> type: %d", type);    
+    logf("usb_controller_select");
+    logf("  -> type: %d", type);
+
+    usbcore.mode = type;
 
-	usbcore.mode = type;
-	
     switch (type) {
     case DEVICE:
         new = usbcore.controller[0];
@@ -246,20 +247,20 @@ void usb_controller_select(int type) {
 
     /* if there is only one controller, stop here */
     if (new == NULL) {
-    	logf("no suitable cntrl found");
+        logf("no suitable cntrl found");
         return;
     }
 
     /* shutdown current used controller */
     if (usbcore.active_controller != NULL) {
-    	logf("shuting down old one");
+        logf("shuting down old one");
         usbcore.active_controller->shutdown();
     }
 
     /* set and init new controller */
     usbcore.active_controller = new;
     logf("init controller");
-    usbcore.active_controller->init();   
+    usbcore.active_controller->init();
 }
 
 int usb_stack_get_mode(void) {
@@ -272,10 +273,10 @@ int usb_stack_get_mode(void) {
  * @param driver pointer to an usb_device_driver struct.
  * @return 0 on success, else a defined error code.
  */
-int usb_device_driver_register(struct usb_device_driver* driver) {
-
+int usb_device_driver_register(struct usb_device_driver* driver)
+{
     int i;
-    
+
     if (driver == NULL) {
         return EINVAL;
     }
@@ -284,109 +285,109 @@ int usb_device_driver_register(struct usb_device_driver* driver) {
     logf("usb_stack: register usb driver");
     for (i = 0; i < NUM_DRIVERS; i++) {
         if (usbcore.device_drivers[i] == NULL) {
-        	usbcore.device_drivers[i] = driver;
-        	update_driver_names(device_driver_names);
-        	return 0;
+            usbcore.device_drivers[i] = driver;
+            update_driver_names(device_driver_names);
+            return 0;
         }
     }
 
     update_driver_names(device_driver_names);
-    
+
     return 0;
 }
 
 int usb_device_driver_bind(const char* name) {
 
-	int i;
-	struct usb_device_driver *tmp = NULL;
-	struct usb_device_driver *driver = NULL;
-	
+    int i;
+    struct usb_device_driver *tmp = NULL;
+    struct usb_device_driver *driver = NULL;
+
     if (name == NULL) {
         return EINVAL;
     }
-	
+
     /* look for driver */
     logf("looking for driver %s", name);
     for (i = 0; i < NUM_DRIVERS; i++) {
-    	tmp = usbcore.device_drivers[i];
-    	if (tmp != NULL && strcmp(name, tmp->name) == 0) {
-    		driver = tmp;
-    	}
+        tmp = usbcore.device_drivers[i];
+        if (tmp != NULL && strcmp(name, tmp->name) == 0) {
+            driver = tmp;
+        }
     }
  
     if (driver == NULL) {
- 	    logf("no driver found");
- 	    return ENODRIVERFOUND;
+         logf("no driver found");
+         return ENODRIVERFOUND;
     } 
-    
-	/* look if there is an usb controller loaded */
+
+    /* look if there is an usb controller loaded */
     if (usbcore.active_controller == NULL) {
-    	/* safe choosen driver and set it when controller starts */
-    	usbcore.device_driver = driver;
-        
+        /* safe choosen driver and set it when controller starts */
+        usbcore.device_driver = driver;
+
     } else {
-    
+
         /* we need to have an active dcd controller */
         if (usbcore.active_controller->type != DEVICE) {
-    	    logf("wrong type");
+            logf("wrong type");
             return EWRONGCONTROLLERTYPE;
         }
-    
+
         /* bind driver to controller */
         bind_device_driver(driver);
     }
-    
+
     return 0;
 }
 
 void usb_device_driver_unbind(void) {
 
-	logf("usb_device_driver_unbind");
-	if (usbcore.active_controller->device_driver != NULL) {
-		usbcore.active_controller->device_driver->unbind();
-		usbcore.active_controller->device_driver = NULL;
-	}
-	
-	usbcore.device_driver = NULL;
+    logf("usb_device_driver_unbind");
+    if (usbcore.active_controller->device_driver != NULL) {
+        usbcore.active_controller->device_driver->unbind();
+        usbcore.active_controller->device_driver = NULL;
+    }
+
+    usbcore.device_driver = NULL;
 }
 
 static void update_driver_names(unsigned char* result) {
 
-	int i;
+    int i;
     int pos = 0;
-	unsigned char terminator = ',';
+    unsigned char terminator = ',';
     struct usb_device_driver* dd = NULL;
-    
+
     /* reset buffer, iterate through drivers and add to char array */
     memset(result, 0, USB_STACK_MAX_SETTINGS_NAME);
     for (i = 0; i < NUM_DRIVERS; i++) {
-    	int len;
+        int len;
         dd = usbcore.device_drivers[i];
-        
+
         if (dd !=  NULL) {
-        	len = strlen(dd->name);
-        	if (pos > 0) {
-        		memcpy(result + pos, &terminator, 1);
-        		pos++;
-        	}
-        	memcpy(result + pos, dd->name, len);
-        	pos += len;
+            len = strlen(dd->name);
+            if (pos > 0) {
+                memcpy(result + pos, &terminator, 1);
+                pos++;
+            }
+            memcpy(result + pos, dd->name, len);
+            pos += len;
         }
     }
 }
 
 static void bind_device_driver(struct usb_device_driver* driver) {
-	
+
     /* look if there is an old driver */
     if (usbcore.active_controller->device_driver != NULL) {
         usbcore.active_controller->device_driver->unbind();
     }
-	
+
     /* bind driver to controller */
     usbcore.active_controller->device_driver = driver;
-    
+
     /* init dirver */
-    driver->bind(usbcore.active_controller->controller_ops);    
+    driver->bind(usbcore.active_controller->controller_ops);
 }
 
 
diff --git a/firmware/usbstack/core/epsetup.c b/firmware/usbstack/core/epsetup.c
index 6ae54fb..36c24e6 100644
--- a/firmware/usbstack/core/epsetup.c
+++ b/firmware/usbstack/core/epsetup.c
@@ -25,27 +25,27 @@
  * 
  * Naming Convention for Endpoint Names
  * 
- *	- ep1, ep2, ... address is fixed, not direction or type
- *	- ep1in, ep2out, ... address and direction are fixed, not type
- *	- ep1-bulk, ep2-bulk, ... address and type are fixed, not direction
- *	- ep1in-bulk, ep2out-iso, ... all three are fixed
- *	- ep-* ... no functionality restrictions
+ *    - ep1, ep2, ... address is fixed, not direction or type
+ *    - ep1in, ep2out, ... address and direction are fixed, not type
+ *    - ep1-bulk, ep2-bulk, ... address and type are fixed, not direction
+ *    - ep1in-bulk, ep2out-iso, ... all three are fixed
+ *    - ep-* ... no functionality restrictions
  *
  * Type suffixes are "-bulk", "-iso", or "-int".  Numbers are decimal.
  *
  */
 static int ep_matches(struct usb_ep* ep, struct usb_endpoint_descriptor* desc);
 
-void usb_ep_autoconfig_reset(void) {
-
+void usb_ep_autoconfig_reset(void)
+{
     struct usb_ep* ep = NULL;
     if (usbcore.active_controller == NULL) {
         return;
     }
-	
+
     logf("resetting endpoints");
     list_for_each_entry(ep, &usbcore.active_controller->endpoints.list, list) {
-    	logf("reset %s", ep->name);
+        logf("reset %s", ep->name);
         ep->claimed = false;
     }
 }
@@ -55,48 +55,48 @@ void usb_ep_autoconfig_reset(void) {
  * @param desc usb descritpro to use for seraching.
  * @return NULL or a valid endpoint.
  */
-struct usb_ep* usb_ep_autoconfig(struct usb_endpoint_descriptor* desc) {
-
-	struct usb_ep* ep = NULL;
+struct usb_ep* usb_ep_autoconfig(struct usb_endpoint_descriptor* desc)
+{
+    struct usb_ep* ep = NULL;
     if (usbcore.active_controller == NULL) {
-    	logf("active controller NULL");
+        logf("active controller NULL");
         return NULL;
     }
-        
+
     list_for_each_entry(ep, &usbcore.active_controller->endpoints.list, list) {
         if (ep_matches (ep, desc)) {
             return ep;
         }
     }
-    
+
     return NULL;
 }
 
-static int ep_matches(struct usb_ep* ep, struct usb_endpoint_descriptor* desc) {
-	
+static int ep_matches(struct usb_ep* ep, struct usb_endpoint_descriptor* desc)
+{
     uint8_t     type;
-	const char* tmp;
-	uint16_t    max;
+    const char* tmp;
+    uint16_t    max;
 
-	/* endpoint already claimed? */
-	if (ep->claimed) {
-		logf("!! claimed !!");
+    /* endpoint already claimed? */
+    if (ep->claimed) {
+        logf("!! claimed !!");
         return 0;
     }
 
     /* only support ep0 for portable CONTROL traffic */
     type = desc->bmAttributes & USB_ENDPOINT_XFERTYPE_MASK;
     if (type == USB_ENDPOINT_XFER_CONTROL) {
-    	logf("type == control");
+        logf("type == control");
         return 0;
     }
 
     /* some other naming convention */
     if (ep->name[0] != 'e') {
-    	logf("wrong name");
+        logf("wrong name");
         return 0;
     }
-    
+
     /* type-restriction:  "-iso", "-bulk", or "-int".
      * direction-restriction:  "in", "out".
      */
@@ -111,20 +111,20 @@ static int ep_matches(struct usb_ep* ep, struct usb_endpoint_descriptor* desc) {
                 if (tmp[2] == 's') { // == "-iso"
                     return 0;
                 }
-				break;
-	        case USB_ENDPOINT_XFER_BULK:
-	            if (tmp[1] != 'b') { // != "-bulk"
-	                return 0;
-	            }
-	            break;
-	        case USB_ENDPOINT_XFER_ISOC:
-	            if (tmp[2] != 's') { // != "-iso"
-	                return 0;
-	            }
-	        }
+                break;
+            case USB_ENDPOINT_XFER_BULK:
+                if (tmp[1] != 'b') { // != "-bulk"
+                    return 0;
+                }
+                break;
+            case USB_ENDPOINT_XFER_ISOC:
+                if (tmp[2] != 's') { // != "-iso"
+                    return 0;
+                }
+            }
         } else {
             tmp = ep->name + strlen (ep->name);
-	    }
+        }
 
         /* direction-restriction:  "..in-..", "out-.." */
         tmp--;
@@ -132,7 +132,7 @@ static int ep_matches(struct usb_ep* ep, struct usb_endpoint_descriptor* desc) {
             if (desc->bEndpointAddress & USB_DIR_IN) {
                 if ('n' != *tmp) {
                     return 0;
-			    }
+                }
             } else {
                 if ('t' != *tmp) {
                     return 0;
@@ -147,40 +147,40 @@ static int ep_matches(struct usb_ep* ep, struct usb_endpoint_descriptor* desc) {
      * the usb spec fixes high speed bulk maxpacket at 512 bytes.
      */
     max = 0x7ff & desc->wMaxPacketSize;
-    
+
     switch (type) {
     case USB_ENDPOINT_XFER_INT:
         /* INT:  limit 64 bytes full speed, 1024 high speed */
-    	if ((usbcore.active_controller->speed != USB_SPEED_HIGH) && (max > 64)) {
+        if ((usbcore.active_controller->speed != USB_SPEED_HIGH) && (max > 64)) {
             return 0;
         }
-		/* FALLTHROUGH */
+        /* FALLTHROUGH */
 
-	case USB_ENDPOINT_XFER_ISOC:
+    case USB_ENDPOINT_XFER_ISOC:
         if ((usbcore.active_controller->speed != USB_SPEED_HIGH) && (max > 1023)) {
             return 0;
         }
-		break;
-	}
+        break;
+    }
 
-	/* MATCH!! */
+    /* MATCH!! */
 
-	/* report address */
+    /* report address */
     desc->bEndpointAddress |= ep->ep_num;
 
     /* report (variable) full speed bulk maxpacket */
     if (type == USB_ENDPOINT_XFER_BULK) {
-    	int size = max;
+        int size = max;
 
         /* min() doesn't work on bitfields with gcc-3.5 */
         if (size > 64) {
             size = 64;
-	    }
+        }
         desc->wMaxPacketSize = size;
     }
 
     /* save desc in endpoint */
     ep->desc = desc;
-    
+
     return 1;
 }
diff --git a/firmware/usbstack/core/utils.c b/firmware/usbstack/core/utils.c
index 2fb2695..0ec4faa 100644
--- a/firmware/usbstack/core/utils.c
+++ b/firmware/usbstack/core/utils.c
@@ -20,98 +20,98 @@
 #include <string.h>
 #include "usbstack/core.h"
 
-void into_usb_ctrlrequest(struct usb_ctrlrequest* request) {
+void into_usb_ctrlrequest(struct usb_ctrlrequest* request)
+{
+    char* type = "";
+    char* req = "";
+    char* extra = 0;
 
-	char* type = "";
-	char* req = "";
-	char* extra = 0;
-	
-	logf("-usb request-");
+    logf("-usb request-");
     /* check if packet is okay */
-	if (request->bRequestType == 0 &&
+    if (request->bRequestType == 0 &&
         request->bRequest == 0 &&
         request->wValue == 0 &&
         request->wIndex == 0 &&
         request->wLength == 0) {
         logf(" -> INVALID <-");
         return;
-	}	
-	
+    }
+
     switch (request->bRequestType & USB_TYPE_MASK) {
-	case USB_TYPE_STANDARD:
-		type = "standard";
-		
+    case USB_TYPE_STANDARD:
+        type = "standard";
+
         switch (request->bRequest) {
         case USB_REQ_GET_STATUS:
-        	req  = "get status";
+            req  = "get status";
             break;
         case USB_REQ_CLEAR_FEATURE:
-        	req = "clear feature";
+            req = "clear feature";
             break;
         case USB_REQ_SET_FEATURE:
-        	req = "set feature";
+            req = "set feature";
             break;
         case USB_REQ_SET_ADDRESS:
-        	req = "set address";
+            req = "set address";
             break;
         case USB_REQ_GET_DESCRIPTOR:
-        	req = "get descriptor";
-        	
-    		switch (request->wValue >> 8) {
-    		case USB_DT_DEVICE:
-    			extra = "get device descriptor";
-    			break;
-    		case USB_DT_DEVICE_QUALIFIER:
-    			extra = "get device qualifier";
-    			break;
-    		case USB_DT_OTHER_SPEED_CONFIG:
-    			extra = "get other-speed config descriptor";
-    		case USB_DT_CONFIG:
-    			extra = "get configuration descriptor";
-    			break;
-    		case USB_DT_STRING:
-    			extra = "get string descriptor";
-    			break;
-    		case USB_DT_DEBUG:
-    			extra = "debug";
-    			break;
-    		}
-    		break;        	
-        	
+            req = "get descriptor";
+
+            switch (request->wValue >> 8) {
+            case USB_DT_DEVICE:
+                extra = "get device descriptor";
+                break;
+            case USB_DT_DEVICE_QUALIFIER:
+                extra = "get device qualifier";
+                break;
+            case USB_DT_OTHER_SPEED_CONFIG:
+                extra = "get other-speed config descriptor";
+            case USB_DT_CONFIG:
+                extra = "get configuration descriptor";
+                break;
+            case USB_DT_STRING:
+                extra = "get string descriptor";
+                break;
+            case USB_DT_DEBUG:
+                extra = "debug";
+                break;
+            }
+            break;
+
             break;
         case USB_REQ_SET_DESCRIPTOR:
-        	req = "set descriptor";
+            req = "set descriptor";
             break;
         case USB_REQ_GET_CONFIGURATION:
-        	req = "get configuration";
+            req = "get configuration";
             break;
         case USB_REQ_SET_CONFIGURATION:
-        	req = "set configuration";
+            req = "set configuration";
             break;
         case USB_REQ_GET_INTERFACE:
-        	req = "get interface";
+            req = "get interface";
             break;
         case USB_REQ_SET_INTERFACE:
-        	req = "set interface";
+            req = "set interface";
             break;
         case USB_REQ_SYNCH_FRAME:
-        	req = "sync frame";
+            req = "sync frame";
             break;
         default:
-        	req = "unkown";
-        	break;
+            req = "unkown";
+            break;
         }
 
         break;
     case USB_TYPE_CLASS:
-    	type = "class";
+        type = "class";
         break;
 
     case USB_TYPE_VENDOR:
-    	type = "vendor";
+        type = "vendor";
         break;
     }
-        
+
     logf(" -b 0x%x", request->bRequestType);
     logf(" -b 0x%x", request->bRequest);
     logf(" -b 0x%x", request->wValue);
@@ -120,6 +120,6 @@ void into_usb_ctrlrequest(struct usb_ctrlrequest* request) {
     logf(" -> t: %s", type);
     logf(" -> r: %s", req);
     if (extra != 0) {
-    	logf(" -> e: %s", extra);
+        logf(" -> e: %s", extra);
     }
 }
diff --git a/firmware/usbstack/device.h b/firmware/usbstack/device.h
index 8993c9b..cfdaa1e 100644
--- a/firmware/usbstack/device.h
+++ b/firmware/usbstack/device.h
@@ -41,7 +41,7 @@ struct usb_config_descriptor;
 struct usb_descriptor_header;
 
 int usb_stack_configdesc(const struct usb_config_descriptor* config,
-						void* buf, unsigned length,
-						struct usb_descriptor_header** desc);
+                         void* buf, unsigned length,
+                         struct usb_descriptor_header** desc);
 
 #endif /*_USBSTACK_DEVICE_H_*/
diff --git a/firmware/usbstack/drivers/device/usb_serial.c b/firmware/usbstack/drivers/device/usb_serial.c
index fe1e52f..e44a76a 100644
--- a/firmware/usbstack/drivers/device/usb_serial.c
+++ b/firmware/usbstack/drivers/device/usb_serial.c
@@ -128,69 +128,69 @@ static int set_config(int config);
 
 
 struct device {
-	struct usb_ep* in;
-	struct usb_ep* out;
-	uint32_t used_config;
+    struct usb_ep* in;
+    struct usb_ep* out;
+    uint32_t used_config;
 };
 
 static struct device dev;
 
 /*-------------------------------------------------------------------------*/
 
-void usb_serial_driver_init(void) {
-
+void usb_serial_driver_init(void)
+{
     logf("usb serial: register");
     usb_device_driver_register(&usb_serial_driver);
 }
 
 /*-------------------------------------------------------------------------*/
 
-void usb_serial_driver_bind(void* controler_ops) {
-
+void usb_serial_driver_bind(void* controler_ops)
+{
     logf("usb serial: bind");
     ops = controler_ops;
-    
+
     /* serach and asign endpoints */
     usb_ep_autoconfig_reset();
 
     dev.in = usb_ep_autoconfig(&serial_fullspeed_in_desc);
-	if (!dev.in) {
-		goto autoconf_fail;
-	}
-	dev.in->claimed = true;
-	logf("usb serial: in: %s", dev.in->name);
-	
-	dev.out = usb_ep_autoconfig(&serial_fullspeed_out_desc);
-	if (!dev.out) {
-		goto autoconf_fail;
-	}
-	dev.out->claimed = true;
-	logf("usb serial: out: %s", dev.out->name);
-
-	/* update device decsriptor */
-	serial_device_desc.bMaxPacketSize0 = ops->ep0->maxpacket;
-	
-	/* update qualifie descriptor */
-	serial_qualifier_desc.bMaxPacketSize0 = ops->ep0->maxpacket;
-	
-	/* update debug descriptor */
-	serial_debug_desc.bDebugInEndpoint = dev.in->ep_num;
-	serial_debug_desc.bDebugOutEndpoint = dev.out->ep_num;
-		
-	return;
-	
+    if (!dev.in) {
+        goto autoconf_fail;
+    }
+    dev.in->claimed = true;
+    logf("usb serial: in: %s", dev.in->name);
+
+    dev.out = usb_ep_autoconfig(&serial_fullspeed_out_desc);
+    if (!dev.out) {
+        goto autoconf_fail;
+    }
+    dev.out->claimed = true;
+    logf("usb serial: out: %s", dev.out->name);
+
+    /* update device decsriptor */
+    serial_device_desc.bMaxPacketSize0 = ops->ep0->maxpacket;
+
+    /* update qualifie descriptor */
+    serial_qualifier_desc.bMaxPacketSize0 = ops->ep0->maxpacket;
+
+    /* update debug descriptor */
+    serial_debug_desc.bDebugInEndpoint = dev.in->ep_num;
+    serial_debug_desc.bDebugOutEndpoint = dev.out->ep_num;
+
+    return;
+
 autoconf_fail:
-	logf("failed to find endpoiunts");
+    logf("failed to find endpoiunts");
 }
 
-int usb_serial_driver_request(struct usb_ctrlrequest* request) {
-
+int usb_serial_driver_request(struct usb_ctrlrequest* request)
+{
     int ret = -EOPNOTSUPP;
     logf("usb serial: request");
 
     res.length = 0;
     res.buf = NULL;
-    
+
     switch (request->bRequestType & USB_TYPE_MASK) {
     case USB_TYPE_STANDARD:
 
@@ -205,26 +205,26 @@ int usb_serial_driver_request(struct usb_ctrlrequest* request) {
                 break;
 
             case USB_DT_DEVICE_QUALIFIER:
-            	logf("usb serial: sending qualifier dec");
+                logf("usb serial: sending qualifier dec");
                 ret = MIN(sizeof(struct usb_qualifier_descriptor), request->wLength);
-                res.buf = &serial_qualifier_desc;            	
-                
+                res.buf = &serial_qualifier_desc;
+
             case USB_DT_CONFIG:
                 logf("usb serial: sending config desc");
-                
-    			ret = config_buf(buf, request->wValue >> 8, request->wValue & 0xff);
-    			if (ret >= 0) {
-    				logf("%d, vs %d", request->wLength, ret);
-    				ret = MIN(request->wLength, (uint16_t)ret);
-    			}
+
+                ret = config_buf(buf, request->wValue >> 8, request->wValue & 0xff);
+                if (ret >= 0) {
+                    logf("%d, vs %d", request->wLength, ret);
+                    ret = MIN(request->wLength, (uint16_t)ret);
+                }
                 res.buf = buf;
                 break;
-                
+
             case USB_DT_DEBUG:
-            	logf("usb serial: sending debug desc");
-            	ret = MIN(sizeof(struct usb_debug_descriptor), request->wLength);
-            	res.buf = &serial_debug_desc;
-            	break;
+                logf("usb serial: sending debug desc");
+                ret = MIN(sizeof(struct usb_debug_descriptor), request->wLength);
+                res.buf = &serial_debug_desc;
+                break;
             }
             break;
 
@@ -232,9 +232,9 @@ int usb_serial_driver_request(struct usb_ctrlrequest* request) {
             logf("usb serial: set configuration %d", request->wValue);
             ret = set_config(request->wValue);
             break;
-            
+
         case USB_REQ_GET_CONFIGURATION:
-        	logf("usb serial: get configuration");
+            logf("usb serial: get configuration");
             ret = 1;
             res.buf = &dev.used_config;
             break;
@@ -245,56 +245,56 @@ int usb_serial_driver_request(struct usb_ctrlrequest* request) {
         res.length = ret;
         ret = ops->send(NULL, &res);
     }
-    
+
     return ret;
 }
 
-void usb_serial_driver_speed(enum usb_device_speed speed) {
-
+void usb_serial_driver_speed(enum usb_device_speed speed)
+{
     switch (speed) {
     case USB_SPEED_LOW:
     case USB_SPEED_FULL:
-    	logf("usb serial: using fullspeed");
-    	break;
+        logf("usb serial: using fullspeed");
+        break;
     case USB_SPEED_HIGH:
-    	logf("usb serial: using highspeed");
-    	break;
+        logf("usb serial: using highspeed");
+        break;
     default:
-    	logf("speed: hmm");
-    	break;
+        logf("speed: hmm");
+        break;
     }
 }
 
 /*-------------------------------------------------------------------------*/
 /* helper functions */
 
-static int config_buf(uint8_t *buf, uint8_t type, unsigned index) {
-    
-	int len;
-
-	/* TODO check index*/
-	
-	len = usb_stack_configdesc(&serial_bulk_config_desc, buf, BUFFER_SIZE, serial_bulk_fullspeed_function);
-	if (len < 0) {
-		return len;
-	}
-	((struct usb_config_descriptor *)buf)->bDescriptorType = type;
-	return len;
+static int config_buf(uint8_t *buf, uint8_t type, unsigned index)
+{
+    int len;
+
+    /* TODO check index*/
+
+    len = usb_stack_configdesc(&serial_bulk_config_desc, buf, BUFFER_SIZE, serial_bulk_fullspeed_function);
+    if (len < 0) {
+        return len;
+    }
+    ((struct usb_config_descriptor *)buf)->bDescriptorType = type;
+    return len;
 }
 
-static int set_config(int config) {
+static int set_config(int config)
+{
+    /* TODO check config*/
 
-	/* TODO check config*/
-    
     /* enable endpoints */
     logf("setup %s", dev.in->name);
     ops->enable(dev.in);
     logf("setup %s", dev.out->name);
     ops->enable(dev.out);
-    
-	/* store config */
-	logf("using config %d", config);
-	dev.used_config = config;
-		
+
+    /* store config */
+    logf("using config %d", config);
+    dev.used_config = config;
+
     return 0;
 }
diff --git a/firmware/usbstack/drivers/device/usb_storage.c b/firmware/usbstack/drivers/device/usb_storage.c
index 0cb1f10..355fc4d 100644
--- a/firmware/usbstack/drivers/device/usb_storage.c
+++ b/firmware/usbstack/drivers/device/usb_storage.c
@@ -128,8 +128,8 @@ static int set_config(int config);
 
 /*-------------------------------------------------------------------------*/
 
-void usb_storage_driver_init(void) {
-
+void usb_storage_driver_init(void)
+{
     logf("usb storage: register");
     usb_device_driver_register(&usb_storage_driver);
 }
@@ -137,41 +137,41 @@ void usb_storage_driver_init(void) {
 /*-------------------------------------------------------------------------*/
 /* device driver ops */
 
-void usb_storage_driver_bind(void* controler_ops) {
-
+void usb_storage_driver_bind(void* controler_ops)
+{
     ops = controler_ops;
-    
+
     /* serach and asign endpoints */
     usb_ep_autoconfig_reset();
-    
+
     dev.in = usb_ep_autoconfig(&storage_bulk_in_desc);
-	if (!dev.in) {
-		goto autoconf_fail;
-	}
-	dev.in->claimed = true;
-	logf("usb storage: in: %s", dev.in->name);
-	
-	dev.out = usb_ep_autoconfig(&storage_bulk_out_desc);
-	if (!dev.out) {
-		goto autoconf_fail;
-	}
-	dev.out->claimed = true;
-	logf("usb storage: out: %s", dev.out->name);
-	
-	return;
-	
+    if (!dev.in) {
+        goto autoconf_fail;
+    }
+    dev.in->claimed = true;
+    logf("usb storage: in: %s", dev.in->name);
+
+    dev.out = usb_ep_autoconfig(&storage_bulk_out_desc);
+    if (!dev.out) {
+        goto autoconf_fail;
+    }
+    dev.out->claimed = true;
+    logf("usb storage: out: %s", dev.out->name);
+
+    return;
+
 autoconf_fail:
-	logf("failed to find endpoints");
+    logf("failed to find endpoints");
 }
 
-int usb_storage_driver_request(struct usb_ctrlrequest* request) {
-
+int usb_storage_driver_request(struct usb_ctrlrequest* request)
+{
     int ret = -EOPNOTSUPP;
     logf("usb storage: request");
 
     res.length = 0;
     res.buf = NULL;
-    
+
     switch (request->bRequestType & USB_TYPE_MASK) {
     case USB_TYPE_STANDARD:
 
@@ -187,12 +187,12 @@ int usb_storage_driver_request(struct usb_ctrlrequest* request) {
 
             case USB_DT_CONFIG:
                 logf("usb storage: sending config desc");
-                
-    			ret = config_buf(buf, request->wValue >> 8, request->wValue & 0xff);
-    			if (ret >= 0) {
-    				logf("%d, vs %d", request->wLength, ret);
-    				ret = MIN(request->wLength, (uint16_t)ret);
-    			}
+
+                ret = config_buf(buf, request->wValue >> 8, request->wValue & 0xff);
+                if (ret >= 0) {
+                    logf("%d, vs %d", request->wLength, ret);
+                    ret = MIN(request->wLength, (uint16_t)ret);
+                }
                 res.buf = buf;
                 break;
             }
@@ -202,68 +202,68 @@ int usb_storage_driver_request(struct usb_ctrlrequest* request) {
             logf("usb storage: set configuration %d", request->wValue);
             ret = set_config(request->wValue);
             break;
-            
+
         case USB_REQ_SET_INTERFACE:
             logf("usb storage: set interface");
             ret = 0;
             break;
         }
-        
+
     case USB_TYPE_CLASS:
-    	
-    	switch (request->bRequest) {
-    	case USB_BULK_RESET_REQUEST:
-    		logf("usb storage: bulk reset");
-    		break;
-    		
-    	case USB_BULK_GET_MAX_LUN_REQUEST:
-    		logf("usb storage: get max lun");
-    		/* we support no LUNs (Logical Unit Number) */
-    		buf[0] = 0;
-    		ret = 1;
-    		break;
-    	}
-    	break;
+
+        switch (request->bRequest) {
+        case USB_BULK_RESET_REQUEST:
+            logf("usb storage: bulk reset");
+            break;
+
+        case USB_BULK_GET_MAX_LUN_REQUEST:
+            logf("usb storage: get max lun");
+            /* we support no LUNs (Logical Unit Number) */
+            buf[0] = 0;
+            ret = 1;
+            break;
+        }
+        break;
     }
 
     if (ret >= 0) {
         res.length = ret;
         ret = ops->send(NULL, &res);
     }
-    
+
     return ret;
 }
 
 /*-------------------------------------------------------------------------*/
 /* S/GET CONFIGURATION helpers */
 
-static int config_buf(uint8_t *buf, uint8_t type, unsigned index) {
-    
-	int len;
-
-	/* only one configuration */
-	if (index != 0) {
-		return -EINVAL;
-	}
-	
-	len = usb_stack_configdesc(&storage_config_desc, buf, BUFFER_SIZE, storage_fullspeed_function);
-	if (len < 0) {
-		return len;
-	}
-	((struct usb_config_descriptor *)buf)->bDescriptorType = type;
-	return len;
-}
+static int config_buf(uint8_t *buf, uint8_t type, unsigned index)
+{
+    int len;
 
-static int set_config(int config) {
+    /* only one configuration */
+    if (index != 0) {
+        return -EINVAL;
+    }
 
+    len = usb_stack_configdesc(&storage_config_desc, buf, BUFFER_SIZE, storage_fullspeed_function);
+    if (len < 0) {
+        return len;
+    }
+    ((struct usb_config_descriptor *)buf)->bDescriptorType = type;
+    return len;
+}
+
+static int set_config(int config)
+{
     /* enable endpoints */
     logf("setup %s", dev.in->name);
     ops->enable(dev.in);
     logf("setup %s", dev.out->name);
     ops->enable(dev.out);
-    
+
     /* setup buffers */
-    
+
     return 0;
 }
 
diff --git a/firmware/usbstack/host.h b/firmware/usbstack/host.h
index cb2f550..862584d 100644
--- a/firmware/usbstack/host.h
+++ b/firmware/usbstack/host.h
@@ -25,7 +25,7 @@
  */
 struct usb_host_driver {
     const char* name;
-    void* data;			/* used to store controller specific ops struct */
+    void* data;        /* used to store controller specific ops struct */
 };
 
 #endif /*_USBSTACK_HOST_H_*/