Usb Stack: only setup packet handling, and not enabled by default as there is a lot to do.

* settings code is not fully ready -> changing device driver has no effect
* clean ups
* check copyriths
* find a way to detect IN transfers
* support for full and highspeed
* ...




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

4 files changed, 783 insertions, 0 deletions

diff --git a/firmware/usbstack/core/config.c b/firmware/usbstack/core/config.c
new file mode 100644
index 0000000000..a05a508bf9
--- /dev/null
+++ b/firmware/usbstack/core/config.c
@@ -0,0 +1,80 @@
+/***************************************************************************
+ *             __________               __   ___.
+ *   Open      \______   \ ____   ____ |  | _\_ |__   _______  ___
+ *   Source     |       _//  _ \_/ ___\|  |/ /| __ \ /  _ \  \/  /
+ *   Jukebox    |    |   (  <_> )  \___|    < | \_\ (  <_> > <  <
+ *   Firmware   |____|_  /\____/ \___  >__|_ \|___  /\____/__/\_ \
+ *                     \/            \/     \/    \/            \/
+ * $Id: $
+ *
+ * Copyright (C) 2007 by Christian Gmeiner
+ *
+ * Based on linux/drivers/usb/gadget/config.c
+ *   Copyright (C) 2003 David Brownell
+ * 
+ * All files in this archive are subject to the GNU General Public License.
+ * See the file COPYING in the source tree root for full license agreement.
+ *
+ * This software is distributed on an "AS IS" basis, WITHOUT WARRANTY OF ANY
+ * KIND, either express or implied.
+ *
+ ****************************************************************************/
+
+#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;
+
+	if (!src) {
+		return -EINVAL;
+	}
+
+	/* 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;
+}
+
+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;
+
+	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;
+	}
+	
+	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;
+	
+	return len;
+}
diff --git a/firmware/usbstack/core/core.c b/firmware/usbstack/core/core.c
new file mode 100644
index 0000000000..61b7f83636
--- /dev/null
+++ b/firmware/usbstack/core/core.c
@@ -0,0 +1,392 @@
+/***************************************************************************
+ *             __________               __   ___.
+ *   Open      \______   \ ____   ____ |  | _\_ |__   _______  ___
+ *   Source     |       _//  _ \_/ ___\|  |/ /| __ \ /  _ \  \/  /
+ *   Jukebox    |    |   (  <_> )  \___|    < | \_\ (  <_> > <  <
+ *   Firmware   |____|_  /\____/ \___  >__|_ \|___  /\____/__/\_ \
+ *                     \/            \/     \/    \/            \/
+ * $Id: $
+ *
+ * Copyright (C) 2007 by Christian Gmeiner
+ *
+ * All files in this archive are subject to the GNU General Public License.
+ * See the file COPYING in the source tree root for full license agreement.
+ *
+ * This software is distributed on an "AS IS" basis, WITHOUT WARRANTY OF ANY
+ * KIND, either express or implied.
+ *
+ ****************************************************************************/
+
+#include <errno.h>
+#include <string.h>
+#include <ctype.h>
+#include "usbstack.h"
+
+#include "config.h"
+
+#include "usbstack/core.h"
+#include "usbstack/config.h"
+#include "usbstack/controller.h"
+#include "usbstack/drivers/device/usb_serial.h"
+#include "usbstack/drivers/device/usb_storage.h"
+
+struct usb_core usbcore;
+
+/* private used functions */
+static void update_driver_names(unsigned char* result);
+static void bind_device_driver(struct usb_device_driver* driver);
+
+/**
+ * Initialize usb stack.
+ */
+void usb_stack_init(void) {
+
+    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;
+    }
+    
+    /* init controllers */
+#if (USBSTACK_CAPS & CONTROLLER_DEVICE)
+    usb_dcd_init();
+#endif
+
+#if (USBSTACK_CAPS & CONTROLLER_HOST)
+    usb_hcd_init();
+#endif
+
+    /* init drivers */
+    usb_serial_driver_init();
+    usb_storage_driver_init();
+}
+
+/**
+ * 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;
+	}
+	
+    /* forward to 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...");
+            bind_device_driver(usbcore.device_driver);
+        }
+    }
+}
+
+/**
+ * Stop processing of usb stack. This function shutsdown
+ * active usb controller.
+ */
+void usb_stack_stop(void) {
+
+	/* are we allready stopped? */
+	if (usbcore.running == false) {
+		return;
+	}
+	
+    /* forward to controller */
+    usbcore.active_controller->stop();    
+    usbcore.running = false;
+}
+
+/**
+ * Gets called by upper layers to indicate that there is
+ * an interrupt waiting for the controller.
+ */
+void usb_stack_irq(void) {
+
+    /* simply notify usb controller */
+    if (usbcore.active_controller != NULL && usbcore.active_controller->irq != NULL) {
+        usbcore.active_controller->irq();
+    }
+}
+
+/**
+ * If a host device controller is loaded, we need to have a function
+ * 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) {
+    /* TODO will be used with host device controllers 
+     * and needs to be called in a loop (thread) */
+}
+
+/**
+ * Register an usb controller in the stack. The stack can
+ * only have two controllers registered at one time.
+ * One device host controller and one host device controller.
+ * 
+ * @param ctrl pointer to controller to register.
+ * @return 0 on success else a defined error code. 
+ */
+int usb_controller_register(struct usb_controller* ctrl) {
+
+    if (ctrl == NULL) {
+        return EINVAL;
+    }
+
+    logf("usb_stack: register usb ctrl");
+    logf("  -> name: %s", ctrl->name);
+    logf("  -> type: %d", ctrl->type);
+
+    switch (ctrl->type) {
+    case DEVICE:
+        if (usbcore.controller[0] == NULL) {
+            usbcore.controller[0] = ctrl;
+            return 0;
+        }
+        break;
+    case HOST:
+        if (usbcore.controller[1] == NULL) {
+            usbcore.controller[1] = ctrl;
+            return 0;
+        }
+        break;
+    default:
+        return EINVAL;
+    }
+
+    return ENOFREESLOT;
+}
+
+/**
+ * Unregister an usb controller from the stack.
+ * 
+ * @param ctrl pointer to controller to unregister.
+ * @return 0 on success else a defined error code. 
+ */
+int usb_controller_unregister(struct usb_controller* ctrl) {
+
+    if (ctrl == NULL) {
+        return EINVAL;
+    }
+
+    switch (ctrl->type) {
+    case DEVICE:
+        if (usbcore.controller[0] == ctrl) {
+            usbcore.controller[0] = NULL;
+            return 0;
+        }
+        break;
+    case HOST:
+        if (usbcore.controller[1] == ctrl) {
+            usbcore.controller[1] = NULL;
+            return 0;
+        }
+        break;
+    default:
+        return EINVAL;
+    }
+
+    return 0; /* never reached */
+}
+
+/**
+ * Select an usb controller and active it.
+ * 
+ * @param type of controller to activate.
+ */
+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("usb_controller_select");
+	logf("  -> type: %d", type);    
+
+	usbcore.mode = type;
+	
+    switch (type) {
+    case DEVICE:
+        new = usbcore.controller[0];
+        break;
+    case HOST:
+        new = usbcore.controller[1];
+        break;
+    }
+
+    /* if there is only one controller, stop here */
+    if (new == NULL) {
+    	logf("no suitable cntrl found");
+        return;
+    }
+
+    /* shutdown current used controller */
+    if (usbcore.active_controller != NULL) {
+    	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();   
+}
+
+int usb_stack_get_mode(void) {
+    return usbcore.mode;
+}
+
+/**
+ * Register an usb device driver.
+ * 
+ * @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 i;
+    
+    if (driver == NULL) {
+        return EINVAL;
+    }
+
+    /* add to linked list */
+    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;
+        }
+    }
+
+    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;
+	
+    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;
+    	}
+    }
+ 
+    if (driver == NULL) {
+ 	    logf("no driver found");
+ 	    return ENODRIVERFOUND;
+    } 
+    
+	/* 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;
+        
+    } else {
+    
+        /* we need to have an active dcd controller */
+        if (usbcore.active_controller->type != DEVICE) {
+    	    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;
+}
+
+static void update_driver_names(unsigned char* result) {
+
+	int i;
+    int pos = 0;
+	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;
+        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;
+        }
+    }
+}
+
+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);    
+}
+
+
diff --git a/firmware/usbstack/core/epsetup.c b/firmware/usbstack/core/epsetup.c
new file mode 100644
index 0000000000..6ae54fb9ac
--- /dev/null
+++ b/firmware/usbstack/core/epsetup.c
@@ -0,0 +1,186 @@
+/***************************************************************************
+ *             __________               __   ___.
+ *   Open      \______   \ ____   ____ |  | _\_ |__   _______  ___
+ *   Source     |       _//  _ \_/ ___\|  |/ /| __ \ /  _ \  \/  /
+ *   Jukebox    |    |   (  <_> )  \___|    < | \_\ (  <_> > <  <
+ *   Firmware   |____|_  /\____/ \___  >__|_ \|___  /\____/__/\_ \
+ *                     \/            \/     \/    \/            \/
+ * $Id: $
+ *
+ * Copyright (C) 2007 by Christian Gmeiner
+ *
+ * All files in this archive are subject to the GNU General Public License.
+ * See the file COPYING in the source tree root for full license agreement.
+ *
+ * This software is distributed on an "AS IS" basis, WITHOUT WARRANTY OF ANY
+ * KIND, either express or implied.
+ *
+ ****************************************************************************/
+
+#include <string.h>
+#include <ctype.h>
+#include "usbstack/core.h"
+
+/**
+ * 
+ * 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
+ *
+ * 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) {
+
+    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);
+        ep->claimed = false;
+    }
+}
+
+/**
+ * Find a suitable endpoint for the requested endpoint descriptor.
+ * @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;
+    if (usbcore.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) {
+	
+    uint8_t     type;
+	const char* tmp;
+	uint16_t    max;
+
+	/* 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");
+        return 0;
+    }
+
+    /* some other naming convention */
+    if (ep->name[0] != 'e') {
+    	logf("wrong name");
+        return 0;
+    }
+    
+    /* type-restriction:  "-iso", "-bulk", or "-int".
+     * direction-restriction:  "in", "out".
+     */
+    if (ep->name[2] != '-' ) {
+        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 (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--;
+        if (!isdigit(*tmp)) {
+            if (desc->bEndpointAddress & USB_DIR_IN) {
+                if ('n' != *tmp) {
+                    return 0;
+			    }
+            } else {
+                if ('t' != *tmp) {
+                    return 0;
+                }
+            }
+        }
+    }
+
+
+    /* endpoint maxpacket size is an input parameter, except for bulk
+     * where it's an output parameter representing the full speed limit.
+     * 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)) {
+            return 0;
+        }
+		/* FALLTHROUGH */
+
+	case USB_ENDPOINT_XFER_ISOC:
+        if ((usbcore.active_controller->speed != USB_SPEED_HIGH) && (max > 1023)) {
+            return 0;
+        }
+		break;
+	}
+
+	/* MATCH!! */
+
+	/* report address */
+    desc->bEndpointAddress |= ep->ep_num;
+
+    /* report (variable) full speed bulk maxpacket */
+    if (type == USB_ENDPOINT_XFER_BULK) {
+    	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
new file mode 100644
index 0000000000..2fb2695732
--- /dev/null
+++ b/firmware/usbstack/core/utils.c
@@ -0,0 +1,125 @@
+/***************************************************************************
+ *             __________               __   ___.
+ *   Open      \______   \ ____   ____ |  | _\_ |__   _______  ___
+ *   Source     |       _//  _ \_/ ___\|  |/ /| __ \ /  _ \  \/  /
+ *   Jukebox    |    |   (  <_> )  \___|    < | \_\ (  <_> > <  <
+ *   Firmware   |____|_  /\____/ \___  >__|_ \|___  /\____/__/\_ \
+ *                     \/            \/     \/    \/            \/
+ * $Id: $
+ *
+ * Copyright (C) 2007 by Christian Gmeiner
+ *
+ * All files in this archive are subject to the GNU General Public License.
+ * See the file COPYING in the source tree root for full license agreement.
+ *
+ * This software is distributed on an "AS IS" basis, WITHOUT WARRANTY OF ANY
+ * KIND, either express or implied.
+ *
+ ****************************************************************************/
+
+#include <string.h>
+#include "usbstack/core.h"
+
+void into_usb_ctrlrequest(struct usb_ctrlrequest* request) {
+
+	char* type = "";
+	char* req = "";
+	char* extra = 0;
+	
+	logf("-usb request-");
+    /* check if packet is okay */
+	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";
+		
+        switch (request->bRequest) {
+        case USB_REQ_GET_STATUS:
+        	req  = "get status";
+            break;
+        case USB_REQ_CLEAR_FEATURE:
+        	req = "clear feature";
+            break;
+        case USB_REQ_SET_FEATURE:
+        	req = "set feature";
+            break;
+        case USB_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;        	
+        	
+            break;
+        case USB_REQ_SET_DESCRIPTOR:
+        	req = "set descriptor";
+            break;
+        case USB_REQ_GET_CONFIGURATION:
+        	req = "get configuration";
+            break;
+        case USB_REQ_SET_CONFIGURATION:
+        	req = "set configuration";
+            break;
+        case USB_REQ_GET_INTERFACE:
+        	req = "get interface";
+            break;
+        case USB_REQ_SET_INTERFACE:
+        	req = "set interface";
+            break;
+        case USB_REQ_SYNCH_FRAME:
+        	req = "sync frame";
+            break;
+        default:
+        	req = "unkown";
+        	break;
+        }
+
+        break;
+    case USB_TYPE_CLASS:
+    	type = "class";
+        break;
+
+    case USB_TYPE_VENDOR:
+    	type = "vendor";
+        break;
+    }
+        
+    logf(" -b 0x%x", request->bRequestType);
+    logf(" -b 0x%x", request->bRequest);
+    logf(" -b 0x%x", request->wValue);
+    logf(" -b 0x%x", request->wIndex);
+    logf(" -b 0x%x", request->wLength);
+    logf(" -> t: %s", type);
+    logf(" -> r: %s", req);
+    if (extra != 0) {
+    	logf(" -> e: %s", extra);
+    }
+}