Merge kroah.com:/home/linux/linux/BK/bleeding-2.5

into kroah.com:/home/linux/linux/BK/gregkh-2.5

86 files changed, 903 insertions, 832 deletions

diff --git a/Documentation/DocBook/writing_usb_driver.tmpl b/Documentation/DocBook/writing_usb_driver.tmpl
index 98d689b33529..8d971b0120fb 100644
--- a/Documentation/DocBook/writing_usb_driver.tmpl
+++ b/Documentation/DocBook/writing_usb_driver.tmpl
@@ -307,7 +307,7 @@ if (result) {
   </programlisting>
   <para>
      When the write urb is filled up with the proper information using the
-     FILL_BULK_URB function, we point the urb's completion callback to call our
+     usb_fill_bulk_urb function, we point the urb's completion callback to call our
      own skel_write_bulk_callback function. This function is called when the
      urb is finished by the USB subsystem. The callback function is called in
      interrupt context, so caution must be taken not to do very much processing
diff --git a/Documentation/usb/URB.txt b/Documentation/usb/URB.txt
index 5df880cb3ce3..d25d24614e36 100644
--- a/Documentation/usb/URB.txt
+++ b/Documentation/usb/URB.txt
@@ -109,7 +109,7 @@ Take a look at the some existing drivers to see how they're used.
 
 Flags:
 For ISO there are two startup behaviors: Specified start_frame or ASAP.
-For ASAP set USB_ISO_ASAP in transfer_flags.
+For ASAP set URB_ISO_ASAP in transfer_flags.
 
 If short packets should NOT be tolerated, set URB_SHORT_NOT_OK in 
 transfer_flags.
@@ -156,7 +156,7 @@ usb_unlink_urb() returns with that status code, you can free the URB
 with usb_free_urb().
 
 There is also an asynchronous unlink mode.  To use this, set the
-the USB_ASYNC_UNLINK flag in urb->transfer flags before calling
+the URB_ASYNC_UNLINK flag in urb->transfer flags before calling
 usb_unlink_urb().  When using async unlinking, the URB will not
 normally be unlinked when usb_unlink_urb() returns.  Instead, wait
 for the completion handler to be called.
diff --git a/drivers/bluetooth/hci_usb.c b/drivers/bluetooth/hci_usb.c
index ce6f9da59efc..90e92871dfe1 100644
--- a/drivers/bluetooth/hci_usb.c
+++ b/drivers/bluetooth/hci_usb.c
@@ -67,8 +67,8 @@
 #endif
 
 #ifndef CONFIG_BT_USB_ZERO_PACKET
-#undef  USB_ZERO_PACKET
-#define USB_ZERO_PACKET 0
+#undef  URB_ZERO_PACKET
+#define URB_ZERO_PACKET 0
 #endif
 
 static struct usb_driver hci_usb_driver; 
@@ -131,7 +131,7 @@ static int hci_usb_enable_intr(struct hci_usb *husb)
 	
         pipe = usb_rcvintpipe(husb->udev, husb->intr_ep);
         size = usb_maxpacket(husb->udev, pipe, usb_pipeout(pipe));
-	FILL_INT_URB(urb, husb->udev, pipe, buf, size, 
+	usb_fill_int_urb(urb, husb->udev, pipe, buf, size, 
 			hci_usb_interrupt, husb, husb->intr_interval);
 	
 	return usb_submit_urb(urb, GFP_KERNEL);
@@ -182,7 +182,7 @@ static int hci_usb_rx_submit(struct hci_usb *husb, struct urb *urb)
 
         pipe = usb_rcvbulkpipe(husb->udev, husb->bulk_in_ep);
 
-        FILL_BULK_URB(urb, husb->udev, pipe, skb->data, size, hci_usb_rx_complete, skb);
+        usb_fill_bulk_urb(urb, husb->udev, pipe, skb->data, size, hci_usb_rx_complete, skb);
 
 	skb_queue_tail(&husb->pending_q, skb);
 	err = usb_submit_urb(urb, GFP_ATOMIC);
@@ -299,7 +299,7 @@ static inline int hci_usb_send_ctrl(struct hci_usb *husb, struct sk_buff *skb)
 	cr->wValue   = 0;
 	cr->wLength  = __cpu_to_le16(skb->len);
 
-	FILL_CONTROL_URB(urb, husb->udev, pipe, (void *) cr,
+	usb_fill_control_urb(urb, husb->udev, pipe, (void *) cr,
 			skb->data, skb->len, hci_usb_tx_complete, skb);
 
 	BT_DBG("%s urb %p len %d", husb->hdev.name, urb, skb->len);
@@ -328,9 +328,9 @@ static inline int hci_usb_send_bulk(struct hci_usb *husb, struct sk_buff *skb)
 
 	pipe = usb_sndbulkpipe(husb->udev, husb->bulk_out_ep);
         
-	FILL_BULK_URB(urb, husb->udev, pipe, skb->data, skb->len,
+	usb_fill_bulk_urb(urb, husb->udev, pipe, skb->data, skb->len,
 	              hci_usb_tx_complete, skb);
-	urb->transfer_flags = USB_ZERO_PACKET;
+	urb->transfer_flags = URB_ZERO_PACKET;
 
 	BT_DBG("%s urb %p len %d", husb->hdev.name, urb, skb->len);
 
@@ -629,13 +629,13 @@ static void hci_usb_destruct(struct hci_dev *hdev)
 int hci_usb_probe(struct usb_interface *intf, const struct usb_device_id *id)
 {
 	struct usb_device *udev = interface_to_usbdev(intf);	
-	struct usb_endpoint_descriptor *bulk_out_ep[HCI_MAX_IFACE_NUM];
-	struct usb_endpoint_descriptor *isoc_out_ep[HCI_MAX_IFACE_NUM];
-	struct usb_endpoint_descriptor *bulk_in_ep[HCI_MAX_IFACE_NUM];
-	struct usb_endpoint_descriptor *isoc_in_ep[HCI_MAX_IFACE_NUM];
-	struct usb_endpoint_descriptor *intr_in_ep[HCI_MAX_IFACE_NUM];
-	struct usb_interface_descriptor *uif;
-	struct usb_endpoint_descriptor *ep;
+	struct usb_host_endpoint *bulk_out_ep[HCI_MAX_IFACE_NUM];
+	struct usb_host_endpoint *isoc_out_ep[HCI_MAX_IFACE_NUM];
+	struct usb_host_endpoint *bulk_in_ep[HCI_MAX_IFACE_NUM];
+	struct usb_host_endpoint *isoc_in_ep[HCI_MAX_IFACE_NUM];
+	struct usb_host_endpoint *intr_in_ep[HCI_MAX_IFACE_NUM];
+	struct usb_host_interface *uif;
+	struct usb_host_endpoint *ep;
 	struct usb_interface *iface, *isoc_iface;
 	struct hci_usb *husb;
 	struct hci_dev *hdev;
@@ -648,7 +648,7 @@ int hci_usb_probe(struct usb_interface *intf, const struct usb_device_id *id)
 		return -EIO;
 
 	/* Check number of endpoints */
-	if (intf->altsetting[0].bNumEndpoints < 3)
+	if (intf->altsetting[0].desc.bNumEndpoints < 3)
 		return -EIO;
 
 	memset(bulk_out_ep, 0, sizeof(bulk_out_ep));
@@ -663,37 +663,37 @@ int hci_usb_probe(struct usb_interface *intf, const struct usb_device_id *id)
 	
 	/* Find endpoints that we need */
 
-	ifn = min_t(unsigned int, udev->actconfig->bNumInterfaces, HCI_MAX_IFACE_NUM);
+	ifn = min_t(unsigned int, udev->actconfig->desc.bNumInterfaces, HCI_MAX_IFACE_NUM);
 	for (i = 0; i < ifn; i++) {
 		iface = &udev->actconfig->interface[i];
 		for (a = 0; a < iface->num_altsetting; a++) {
 			uif = &iface->altsetting[a];
-			for (e = 0; e < uif->bNumEndpoints; e++) {
+			for (e = 0; e < uif->desc.bNumEndpoints; e++) {
 				ep = &uif->endpoint[e];
 
-				switch (ep->bmAttributes & USB_ENDPOINT_XFERTYPE_MASK) {
+				switch (ep->desc.bmAttributes & USB_ENDPOINT_XFERTYPE_MASK) {
 				case USB_ENDPOINT_XFER_INT:
-					if (ep->bEndpointAddress & USB_DIR_IN)
+					if (ep->desc.bEndpointAddress & USB_DIR_IN)
 						intr_in_ep[i] = ep;
 					break;
 
 				case USB_ENDPOINT_XFER_BULK:
-					if (ep->bEndpointAddress & USB_DIR_IN)
+					if (ep->desc.bEndpointAddress & USB_DIR_IN)
 						bulk_in_ep[i]  = ep;
 					else
 						bulk_out_ep[i] = ep;
 					break;
 
 				case USB_ENDPOINT_XFER_ISOC:
-					if (ep->wMaxPacketSize < size)
+					if (ep->desc.wMaxPacketSize < size)
 						break;
-					size = ep->wMaxPacketSize;
+					size = ep->desc.wMaxPacketSize;
 
 					isoc_iface = iface;
 					isoc_alts  = a;
 					isoc_ifnum = i;
 
-					if (ep->bEndpointAddress & USB_DIR_IN)
+					if (ep->desc.bEndpointAddress & USB_DIR_IN)
 						isoc_in_ep[i]  = ep;
 					else
 						isoc_out_ep[i] = ep;
@@ -721,11 +721,11 @@ int hci_usb_probe(struct usb_interface *intf, const struct usb_device_id *id)
 	memset(husb, 0, sizeof(struct hci_usb));
 
 	husb->udev = udev;
-	husb->bulk_out_ep = bulk_out_ep[0]->bEndpointAddress;
-	husb->bulk_in_ep  = bulk_in_ep[0]->bEndpointAddress;
+	husb->bulk_out_ep = bulk_out_ep[0]->desc.bEndpointAddress;
+	husb->bulk_in_ep  = bulk_in_ep[0]->desc.bEndpointAddress;
 
-	husb->intr_ep = intr_in_ep[0]->bEndpointAddress;
-	husb->intr_interval = intr_in_ep[0]->bInterval;
+	husb->intr_ep = intr_in_ep[0]->desc.bEndpointAddress;
+	husb->intr_interval = intr_in_ep[0]->desc.bInterval;
 
 	if (isoc_iface) {
 		if (usb_set_interface(udev, isoc_ifnum, isoc_alts)) {
@@ -735,8 +735,8 @@ int hci_usb_probe(struct usb_interface *intf, const struct usb_device_id *id)
 		usb_driver_claim_interface(&hci_usb_driver, isoc_iface, husb);
 		husb->isoc_iface  = isoc_iface;
 
-		husb->isoc_in_ep  = isoc_in_ep[1]->bEndpointAddress;
-		husb->isoc_out_ep = isoc_in_ep[1]->bEndpointAddress;
+		husb->isoc_in_ep  = isoc_in_ep[1]->desc.bEndpointAddress;
+		husb->isoc_out_ep = isoc_in_ep[1]->desc.bEndpointAddress;
 	}
 
 	husb->completion_lock = RW_LOCK_UNLOCKED;
diff --git a/drivers/isdn/hisax/st5481_b.c b/drivers/isdn/hisax/st5481_b.c
index 22576dfd14f0..9cfe28e94293 100644
--- a/drivers/isdn/hisax/st5481_b.c
+++ b/drivers/isdn/hisax/st5481_b.c
@@ -253,8 +253,8 @@ static void st5481B_mode(struct st5481_bcs *bcs, int mode)
 static int __devinit st5481_setup_b_out(struct st5481_bcs *bcs)
 {
 	struct usb_device *dev = bcs->adapter->usb_dev;
-	struct usb_interface_descriptor *altsetting;
-	struct usb_endpoint_descriptor *endpoint;
+	struct usb_host_interface *altsetting;
+	struct usb_host_endpoint *endpoint;
   	struct st5481_b_out *b_out = &bcs->b_out;
 
 	DBG(4,"");
@@ -265,11 +265,11 @@ static int __devinit st5481_setup_b_out(struct st5481_bcs *bcs)
 	endpoint = &altsetting->endpoint[EP_B1_OUT - 1 + bcs->channel * 2];
 
 	DBG(4,"endpoint address=%02x,packet size=%d",
-	    endpoint->bEndpointAddress,endpoint->wMaxPacketSize);
+	    endpoint->desc.bEndpointAddress,endpoint->desc.wMaxPacketSize);
 
 	// Allocate memory for 8000bytes/sec + extra bytes if underrun
 	return st5481_setup_isocpipes(b_out->urb, dev, 
-				      usb_sndisocpipe(dev, endpoint->bEndpointAddress),
+				      usb_sndisocpipe(dev, endpoint->desc.bEndpointAddress),
 				      NUM_ISO_PACKETS_B, SIZE_ISO_PACKETS_B_OUT,
 				      NUM_ISO_PACKETS_B * SIZE_ISO_PACKETS_B_OUT + B_FLOW_ADJUST,
 				      usb_b_out_complete, bcs);
diff --git a/drivers/isdn/hisax/st5481_d.c b/drivers/isdn/hisax/st5481_d.c
index 17f670d864ee..02feec24fbb4 100644
--- a/drivers/isdn/hisax/st5481_d.c
+++ b/drivers/isdn/hisax/st5481_d.c
@@ -358,7 +358,7 @@ static void usb_d_out(struct st5481_adapter *adapter, int buf_nr)
 
 	if (usb_submit_urb(urb, GFP_KERNEL) < 0) {
 		// There is another URB queued up
-		urb->transfer_flags = USB_ISO_ASAP;
+		urb->transfer_flags = URB_ISO_ASAP;
 		SUBMIT_URB(urb, GFP_KERNEL);
 	}	
 }
@@ -447,7 +447,7 @@ static void dout_start_xmit(struct FsmInst *fsm, int event, void *arg)
 
 	// Prepare the URB
 	urb->dev = adapter->usb_dev;
-	urb->transfer_flags = USB_ISO_ASAP;
+	urb->transfer_flags = URB_ISO_ASAP;
 
 	DBG_ISO_PACKET(0x20,urb);
 	SUBMIT_URB(urb, GFP_KERNEL);
@@ -652,8 +652,8 @@ static void ph_disconnect(struct st5481_adapter *adapter)
 static int __devinit st5481_setup_d_out(struct st5481_adapter *adapter)
 {
 	struct usb_device *dev = adapter->usb_dev;
-	struct usb_interface_descriptor *altsetting;
-	struct usb_endpoint_descriptor *endpoint;
+	struct usb_host_interface *altsetting;
+	struct usb_host_endpoint *endpoint;
 	struct st5481_d_out *d_out = &adapter->d_out;
 
 	DBG(2,"");
@@ -664,10 +664,10 @@ static int __devinit st5481_setup_d_out(struct st5481_adapter *adapter)
 	endpoint = &altsetting->endpoint[EP_D_OUT-1];
 
 	DBG(2,"endpoint address=%02x,packet size=%d",
-	    endpoint->bEndpointAddress,endpoint->wMaxPacketSize);
+	    endpoint->desc.bEndpointAddress,endpoint->desc.wMaxPacketSize);
 
 	return st5481_setup_isocpipes(d_out->urb, dev, 
-				      usb_sndisocpipe(dev, endpoint->bEndpointAddress),
+				      usb_sndisocpipe(dev, endpoint->desc.bEndpointAddress),
 				      NUM_ISO_PACKETS_D, SIZE_ISO_PACKETS_D_OUT,
 				      NUM_ISO_PACKETS_D * SIZE_ISO_PACKETS_D_OUT,
 				      usb_d_out_complete, adapter);
diff --git a/drivers/isdn/hisax/st5481_usb.c b/drivers/isdn/hisax/st5481_usb.c
index be2d213318b8..d7a326f06199 100644
--- a/drivers/isdn/hisax/st5481_usb.c
+++ b/drivers/isdn/hisax/st5481_usb.c
@@ -244,15 +244,15 @@ int __devinit st5481_setup_usb(struct st5481_adapter *adapter)
 	struct usb_device *dev = adapter->usb_dev;
 	struct st5481_ctrl *ctrl = &adapter->ctrl;
 	struct st5481_intr *intr = &adapter->intr;
-	struct usb_interface_descriptor *altsetting;
-	struct usb_endpoint_descriptor *endpoint;
+	struct usb_host_interface *altsetting;
+	struct usb_host_endpoint *endpoint;
 	int status;
 	struct urb *urb;
 	u_char *buf;
 	
 	DBG(1,"");
 	
-	if ((status = usb_set_configuration (dev,dev->config[0].bConfigurationValue)) < 0) {
+	if ((status = usb_set_configuration (dev,dev->config[0].desc.bConfigurationValue)) < 0) {
 		WARN("set_configuration failed,status=%d",status);
 		return status;
 	}
@@ -261,14 +261,14 @@ int __devinit st5481_setup_usb(struct st5481_adapter *adapter)
 	altsetting = &(dev->config->interface[0].altsetting[3]);	
 
 	// Check if the config is sane
-	if ( altsetting->bNumEndpoints != 7 ) {
-		WARN("expecting 7 got %d endpoints!", altsetting->bNumEndpoints);
+	if ( altsetting->desc.bNumEndpoints != 7 ) {
+		WARN("expecting 7 got %d endpoints!", altsetting->desc.bNumEndpoints);
 		return -EINVAL;
 	}
 
 	// The descriptor is wrong for some early samples of the ST5481 chip
-	altsetting->endpoint[3].wMaxPacketSize = 32;
-	altsetting->endpoint[4].wMaxPacketSize = 32;
+	altsetting->endpoint[3].desc.wMaxPacketSize = 32;
+	altsetting->endpoint[4].desc.wMaxPacketSize = 32;
 
 	// Use alternative setting 3 on interface 0 to have 2B+D
 	if ((status = usb_set_interface (dev, 0, 3)) < 0) {
@@ -284,7 +284,7 @@ int __devinit st5481_setup_usb(struct st5481_adapter *adapter)
 	ctrl->urb = urb;
 	
 	// Fill the control URB
-	FILL_CONTROL_URB (urb, dev, 
+	usb_fill_control_urb (urb, dev, 
 			  usb_sndctrlpipe(dev, 0),
 			  NULL, NULL, 0, usb_ctrl_complete, adapter);
 
@@ -306,11 +306,11 @@ int __devinit st5481_setup_usb(struct st5481_adapter *adapter)
 	endpoint = &altsetting->endpoint[EP_INT-1];
 				
 	// Fill the interrupt URB
-	FILL_INT_URB(urb, dev,
-		     usb_rcvintpipe(dev, endpoint->bEndpointAddress),
+	usb_fill_int_urb(urb, dev,
+		     usb_rcvintpipe(dev, endpoint->desc.bEndpointAddress),
 		     buf, INT_PKT_SIZE,
 		     usb_int_complete, adapter,
-		     endpoint->bInterval);
+		     endpoint->desc.bInterval);
 		
 	return 0;
 }
@@ -409,7 +409,7 @@ fill_isoc_urb(struct urb *urb, struct usb_device *dev,
 	urb->actual_length = 0;
 	urb->complete=complete;
 	urb->context=context;
-	urb->transfer_flags=USB_ISO_ASAP;
+	urb->transfer_flags=URB_ISO_ASAP;
 	for (k = 0; k < num_packets; k++) {
 		urb->iso_frame_desc[k].offset = packet_size * k;
 		urb->iso_frame_desc[k].length = packet_size;
diff --git a/drivers/media/video/cpia_usb.c b/drivers/media/video/cpia_usb.c
index 3a68e91717de..d49f8d0fe742 100644
--- a/drivers/media/video/cpia_usb.c
+++ b/drivers/media/video/cpia_usb.c
@@ -220,7 +220,7 @@ static int cpia_usb_open(void *privdata)
 	urb->dev = ucpia->dev;
 	urb->context = ucpia;
 	urb->pipe = usb_rcvisocpipe(ucpia->dev, 1);
-	urb->transfer_flags = USB_ISO_ASAP;
+	urb->transfer_flags = URB_ISO_ASAP;
 	urb->transfer_buffer = ucpia->sbuf[0].data;
 	urb->complete = cpia_usb_complete;
 	urb->number_of_packets = FRAMES_PER_DESC;
@@ -242,7 +242,7 @@ static int cpia_usb_open(void *privdata)
 	urb->dev = ucpia->dev;
 	urb->context = ucpia;
 	urb->pipe = usb_rcvisocpipe(ucpia->dev, 1);
-	urb->transfer_flags = USB_ISO_ASAP;
+	urb->transfer_flags = URB_ISO_ASAP;
 	urb->transfer_buffer = ucpia->sbuf[1].data;
 	urb->complete = cpia_usb_complete;
 	urb->number_of_packets = FRAMES_PER_DESC;
diff --git a/drivers/net/irda/irda-usb.c b/drivers/net/irda/irda-usb.c
index cddfe9c33804..058f8024384b 100644
--- a/drivers/net/irda/irda-usb.c
+++ b/drivers/net/irda/irda-usb.c
@@ -41,7 +41,7 @@
  * This driver has NOT been tested with the following drivers :
  *	o ehci-hcd	(USB 2.0 controllers)
  *
- * Note that all HCD drivers do USB_ZERO_PACKET and timeout properly,
+ * Note that all HCD drivers do URB_ZERO_PACKET and timeout properly,
  * so we don't have to worry about that anymore.
  * One common problem is the failure to set the address on the dongle,
  * but this happens before the driver gets loaded...
@@ -265,12 +265,12 @@ static void irda_usb_change_speed_xbofs(struct irda_usb_cb *self)
 	irda_usb_build_header(self, frame, 1);
 
 	/* Submit the 0 length IrDA frame to trigger new speed settings */
-        FILL_BULK_URB(urb, self->usbdev,
+        usb_fill_bulk_urb(urb, self->usbdev,
 		      usb_sndbulkpipe(self->usbdev, self->bulk_out_ep),
                       frame, IRDA_USB_SPEED_MTU,
                       speed_bulk_callback, self);
 	urb->transfer_buffer_length = USB_IRDA_HEADER;
-	urb->transfer_flags = USB_ASYNC_UNLINK;
+	urb->transfer_flags = URB_ASYNC_UNLINK;
 	urb->timeout = MSECS_TO_JIFFIES(100);
 
 	/* Irq disabled -> GFP_ATOMIC */
@@ -400,20 +400,20 @@ static int irda_usb_hard_xmit(struct sk_buff *skb, struct net_device *netdev)
 	/* FIXME: Make macro out of this one */
 	((struct irda_skb_cb *)skb->cb)->context = self;
 
-        FILL_BULK_URB(urb, self->usbdev, 
+        usb_fill_bulk_urb(urb, self->usbdev, 
 		      usb_sndbulkpipe(self->usbdev, self->bulk_out_ep),
                       skb->data, IRDA_USB_MAX_MTU,
                       write_bulk_callback, skb);
 	urb->transfer_buffer_length = skb->len;
 	/* Note : unlink *must* be Asynchronous because of the code in 
 	 * irda_usb_net_timeout() -> call in irq - Jean II */
-	urb->transfer_flags = USB_ASYNC_UNLINK;
-	/* This flag (USB_ZERO_PACKET) indicates that what we send is not
+	urb->transfer_flags = URB_ASYNC_UNLINK;
+	/* This flag (URB_ZERO_PACKET) indicates that what we send is not
 	 * a continuous stream of data but separate packets.
 	 * In this case, the USB layer will insert an empty USB frame (TD)
 	 * after each of our packets that is exact multiple of the frame size.
 	 * This is how the dongle will detect the end of packet - Jean II */
-	urb->transfer_flags |= USB_ZERO_PACKET;
+	urb->transfer_flags |= URB_ZERO_PACKET;
 	/* Timeout need to be shorter than NET watchdog timer */
 	urb->timeout = MSECS_TO_JIFFIES(200);
 
@@ -634,7 +634,7 @@ static void irda_usb_net_timeout(struct net_device *netdev)
 			 * be -ENOENT. We will fix that at the next watchdog,
 			 * leaving more time to USB to recover...
 			 * Also, we are in interrupt, so we need to have
-			 * USB_ASYNC_UNLINK to work properly...
+			 * URB_ASYNC_UNLINK to work properly...
 			 * Jean II */
 			done = 1;
 			break;
@@ -729,7 +729,7 @@ static void irda_usb_submit(struct irda_usb_cb *self, struct sk_buff *skb, struc
 	cb->context = self;
 
 	/* Reinitialize URB */
-	FILL_BULK_URB(urb, self->usbdev, 
+	usb_fill_bulk_urb(urb, self->usbdev, 
 		      usb_rcvbulkpipe(self->usbdev, self->bulk_in_ep), 
 		      skb->data, skb->truesize,
                       irda_usb_receive, skb);
@@ -1016,9 +1016,9 @@ static int irda_usb_net_close(struct net_device *netdev)
 		}
 	}
 	/* Cancel Tx and speed URB - need to be synchronous to avoid races */
-	self->tx_urb->transfer_flags &= ~USB_ASYNC_UNLINK;
+	self->tx_urb->transfer_flags &= ~URB_ASYNC_UNLINK;
 	usb_unlink_urb(self->tx_urb);
-	self->speed_urb->transfer_flags &= ~USB_ASYNC_UNLINK;
+	self->speed_urb->transfer_flags &= ~URB_ASYNC_UNLINK;
 	usb_unlink_urb(self->speed_urb);
 
 	/* Stop and remove instance of IrLAP */
@@ -1258,7 +1258,7 @@ static inline int irda_usb_close(struct irda_usb_cb *self)
  * Most dongle have also an interrupt endpoint, that will be probably
  * documented in the next spec...
  */
-static inline int irda_usb_parse_endpoints(struct irda_usb_cb *self, struct usb_endpoint_descriptor *endpoint, int ennum)
+static inline int irda_usb_parse_endpoints(struct irda_usb_cb *self, struct usb_host_endpoint *endpoint, int ennum)
 {
 	int i;		/* Endpoint index in table */
 		
@@ -1277,10 +1277,10 @@ static inline int irda_usb_parse_endpoints(struct irda_usb_cb *self, struct usb_
 		__u16 psize;	/* Endpoint max packet size in bytes */
 
 		/* Get endpoint address, direction and attribute */
-		ep = endpoint[i].bEndpointAddress & USB_ENDPOINT_NUMBER_MASK;
-		dir = endpoint[i].bEndpointAddress & USB_ENDPOINT_DIR_MASK;
-		attr = endpoint[i].bmAttributes;
-		psize = endpoint[i].wMaxPacketSize;
+		ep = endpoint[i].desc.bEndpointAddress & USB_ENDPOINT_NUMBER_MASK;
+		dir = endpoint[i].desc.bEndpointAddress & USB_ENDPOINT_DIR_MASK;
+		attr = endpoint[i].desc.bmAttributes;
+		psize = endpoint[i].desc.wMaxPacketSize;
 
 		/* Is it a bulk endpoint ??? */
 		if(attr == USB_ENDPOINT_XFER_BULK) {
@@ -1366,7 +1366,7 @@ static inline struct irda_class_desc *irda_usb_find_class_desc(struct usb_interf
 	ret = usb_control_msg(dev, usb_rcvctrlpipe(dev,0),
 		IU_REQ_GET_CLASS_DESC,
 		USB_DIR_IN | USB_TYPE_CLASS | USB_RECIP_INTERFACE,
-		0, intf->altsetting->bInterfaceNumber, desc,
+		0, intf->altsetting->desc.bInterfaceNumber, desc,
 		sizeof(*desc), MSECS_TO_JIFFIES(500));
 	
 	IRDA_DEBUG(1, "%s(), ret=%d\n", __FUNCTION__, ret);
@@ -1407,7 +1407,7 @@ static int irda_usb_probe(struct usb_interface *intf,
 {
 	struct usb_device *dev = interface_to_usbdev(intf);
 	struct irda_usb_cb *self = NULL;
-	struct usb_interface_descriptor *interface;
+	struct usb_host_interface *interface;
 	struct irda_class_desc *irda_desc;
 	int ret;
 	int i;
@@ -1477,7 +1477,7 @@ static int irda_usb_probe(struct usb_interface *intf,
 	}
 
 	/* Is this really necessary? */
-	if (usb_set_configuration (dev, dev->config[0].bConfigurationValue) < 0) {
+	if (usb_set_configuration (dev, dev->config[0].desc.bConfigurationValue) < 0) {
 		err("set_configuration failed");
 		return -EIO;
 	}
@@ -1486,7 +1486,7 @@ static int irda_usb_probe(struct usb_interface *intf,
 	/* Note : some driver do hardcode the interface number, some others
 	 * specify an alternate, but very few driver do like this.
 	 * Jean II */
-	ret = usb_set_interface(dev, intf->altsetting->bInterfaceNumber, 0);
+	ret = usb_set_interface(dev, intf->altsetting->desc.bInterfaceNumber, 0);
 	IRDA_DEBUG(1, "usb-irda: set interface %d result %d\n", intf->altsetting->bInterfaceNumber, ret);
 	switch (ret) {
 		case 0:
@@ -1504,7 +1504,7 @@ static int irda_usb_probe(struct usb_interface *intf,
 	/* Find our endpoints */
 	interface = &intf->altsetting[0];
 	if(!irda_usb_parse_endpoints(self, interface->endpoint,
-				     interface->bNumEndpoints)) {
+				     interface->desc.bNumEndpoints)) {
 		ERROR("%s(), Bogus endpoints...\n", __FUNCTION__);
 		return -EIO;
 	}
@@ -1573,9 +1573,9 @@ static void irda_usb_disconnect(struct usb_interface *intf)
 			usb_unlink_urb(self->rx_urb[i]);
 		/* Cancel Tx and speed URB.
 		 * Toggle flags to make sure it's synchronous. */
-		self->tx_urb->transfer_flags &= ~USB_ASYNC_UNLINK;
+		self->tx_urb->transfer_flags &= ~URB_ASYNC_UNLINK;
 		usb_unlink_urb(self->tx_urb);
-		self->speed_urb->transfer_flags &= ~USB_ASYNC_UNLINK;
+		self->speed_urb->transfer_flags &= ~URB_ASYNC_UNLINK;
 		usb_unlink_urb(self->speed_urb);
 	}
 
diff --git a/drivers/usb/class/audio.c b/drivers/usb/class/audio.c
index 41b049b9bd10..4517d61f925d 100644
--- a/drivers/usb/class/audio.c
+++ b/drivers/usb/class/audio.c
@@ -1049,7 +1049,7 @@ static int usbin_start(struct usb_audiodev *as)
 		urb = u->durb[0].urb;
 		urb->dev = dev;
 		urb->pipe = u->datapipe;
-		urb->transfer_flags = USB_ISO_ASAP;
+		urb->transfer_flags = URB_ISO_ASAP;
 		urb->number_of_packets = DESCFRAMES;
 		urb->context = as;
 		urb->complete = usbin_completed;
@@ -1062,7 +1062,7 @@ static int usbin_start(struct usb_audiodev *as)
 		urb = u->durb[1].urb;
 		urb->dev = dev;
 		urb->pipe = u->datapipe;
-		urb->transfer_flags = USB_ISO_ASAP;
+		urb->transfer_flags = URB_ISO_ASAP;
 		urb->number_of_packets = DESCFRAMES;
 		urb->context = as;
 		urb->complete = usbin_completed;
@@ -1076,7 +1076,7 @@ static int usbin_start(struct usb_audiodev *as)
 			urb = u->surb[0].urb;
 			urb->dev = dev;
 			urb->pipe = u->syncpipe;
-			urb->transfer_flags = USB_ISO_ASAP;
+			urb->transfer_flags = URB_ISO_ASAP;
 			urb->number_of_packets = SYNCFRAMES;
 			urb->context = as;
 			urb->complete = usbin_sync_completed;
@@ -1090,7 +1090,7 @@ static int usbin_start(struct usb_audiodev *as)
 			urb = u->surb[1].urb;
 			urb->dev = dev;
 			urb->pipe = u->syncpipe;
-			urb->transfer_flags = USB_ISO_ASAP;
+			urb->transfer_flags = URB_ISO_ASAP;
 			urb->number_of_packets = SYNCFRAMES;
 			urb->context = as;
 			urb->complete = usbin_sync_completed;
@@ -1416,7 +1416,7 @@ static int usbout_start(struct usb_audiodev *as)
 		urb = u->durb[0].urb;
 		urb->dev = dev;
 		urb->pipe = u->datapipe;
-		urb->transfer_flags = USB_ISO_ASAP;
+		urb->transfer_flags = URB_ISO_ASAP;
 		urb->number_of_packets = DESCFRAMES;
 		urb->context = as;
 		urb->complete = usbout_completed;
@@ -1429,7 +1429,7 @@ static int usbout_start(struct usb_audiodev *as)
 		urb = u->durb[1].urb;
 		urb->dev = dev;
 		urb->pipe = u->datapipe;
-		urb->transfer_flags = USB_ISO_ASAP;
+		urb->transfer_flags = URB_ISO_ASAP;
 		urb->number_of_packets = DESCFRAMES;
 		urb->context = as;
 		urb->complete = usbout_completed;
@@ -1443,7 +1443,7 @@ static int usbout_start(struct usb_audiodev *as)
 			urb = u->surb[0].urb;
 			urb->dev = dev;
 			urb->pipe = u->syncpipe;
-			urb->transfer_flags = USB_ISO_ASAP;
+			urb->transfer_flags = URB_ISO_ASAP;
 			urb->number_of_packets = SYNCFRAMES;
 			urb->context = as;
 			urb->complete = usbout_sync_completed;
@@ -1457,7 +1457,7 @@ static int usbout_start(struct usb_audiodev *as)
 			urb = u->surb[1].urb;
 			urb->dev = dev;
 			urb->pipe = u->syncpipe;
-			urb->transfer_flags = USB_ISO_ASAP;
+			urb->transfer_flags = URB_ISO_ASAP;
 			urb->number_of_packets = SYNCFRAMES;
 			urb->context = as;
 			urb->complete = usbout_sync_completed;
@@ -1512,8 +1512,8 @@ static int find_format(struct audioformat *afp, unsigned int nr, unsigned int fm
 static int set_format_in(struct usb_audiodev *as)
 {
 	struct usb_device *dev = as->state->usbdev;
-	struct usb_config_descriptor *config = dev->actconfig;
-	struct usb_interface_descriptor *alts;
+	struct usb_host_config *config = dev->actconfig;
+	struct usb_host_interface *alts;
 	struct usb_interface *iface;
 	struct usbin *u = &as->usbin;
 	struct dmabuf *d = &u->dma;
@@ -1522,7 +1522,7 @@ static int set_format_in(struct usb_audiodev *as)
 	unsigned char data[3];
 	int fmtnr, ret;
 
-	if (u->interface < 0 || u->interface >= config->bNumInterfaces)
+	if (u->interface < 0 || u->interface >= config->desc.bNumInterfaces)
 		return 0;
 	iface = &config->interface[u->interface];
 
@@ -1535,26 +1535,26 @@ static int set_format_in(struct usb_audiodev *as)
 	fmt = as->fmtin + fmtnr;
 	alts = &iface->altsetting[fmt->altsetting];
 	u->format = fmt->format;
-	u->datapipe = usb_rcvisocpipe(dev, alts->endpoint[0].bEndpointAddress & 0xf);
+	u->datapipe = usb_rcvisocpipe(dev, alts->endpoint[0].desc.bEndpointAddress & 0xf);
 	u->syncpipe = u->syncinterval = 0;
-	if ((alts->endpoint[0].bmAttributes & 0x0c) == 0x08) {
-		if (alts->bNumEndpoints < 2 ||
-		    alts->endpoint[1].bmAttributes != 0x01 ||
-		    alts->endpoint[1].bSynchAddress != 0 ||
-		    alts->endpoint[1].bEndpointAddress != (alts->endpoint[0].bSynchAddress & 0x7f)) {
+	if ((alts->endpoint[0].desc.bmAttributes & 0x0c) == 0x08) {
+		if (alts->desc.bNumEndpoints < 2 ||
+		    alts->endpoint[1].desc.bmAttributes != 0x01 ||
+		    alts->endpoint[1].desc.bSynchAddress != 0 ||
+		    alts->endpoint[1].desc.bEndpointAddress != (alts->endpoint[0].desc.bSynchAddress & 0x7f)) {
 			printk(KERN_ERR "usbaudio: device %d interface %d altsetting %d invalid synch pipe\n",
 			       dev->devnum, u->interface, fmt->altsetting);
 			return -1;
 		}
-		u->syncpipe = usb_sndisocpipe(dev, alts->endpoint[1].bEndpointAddress & 0xf);
-		u->syncinterval = alts->endpoint[1].bRefresh;
+		u->syncpipe = usb_sndisocpipe(dev, alts->endpoint[1].desc.bEndpointAddress & 0xf);
+		u->syncinterval = alts->endpoint[1].desc.bRefresh;
 	}
 	if (d->srate < fmt->sratelo)
 		d->srate = fmt->sratelo;
 	if (d->srate > fmt->sratehi)
 		d->srate = fmt->sratehi;
-	dprintk((KERN_DEBUG "usbaudio: set_format_in: usb_set_interface %u %u\n", alts->bInterfaceNumber, fmt->altsetting));
-	if (usb_set_interface(dev, alts->bInterfaceNumber, fmt->altsetting) < 0) {
+	dprintk((KERN_DEBUG "usbaudio: set_format_in: usb_set_interface %u %u\n", alts->desc.bInterfaceNumber, fmt->altsetting));
+	if (usb_set_interface(dev, alts->desc.bInterfaceNumber, fmt->altsetting) < 0) {
 		printk(KERN_WARNING "usbaudio: usb_set_interface failed, device %d interface %d altsetting %d\n",
 		       dev->devnum, u->interface, fmt->altsetting);
 		return -1;
@@ -1600,8 +1600,8 @@ static int set_format_in(struct usb_audiodev *as)
 static int set_format_out(struct usb_audiodev *as)
 {
 	struct usb_device *dev = as->state->usbdev;
-	struct usb_config_descriptor *config = dev->actconfig;
-	struct usb_interface_descriptor *alts;
+	struct usb_host_config *config = dev->actconfig;
+	struct usb_host_interface *alts;
 	struct usb_interface *iface;	
 	struct usbout *u = &as->usbout;
 	struct dmabuf *d = &u->dma;
@@ -1610,7 +1610,7 @@ static int set_format_out(struct usb_audiodev *as)
 	unsigned char data[3];
 	int fmtnr, ret;
 
-	if (u->interface < 0 || u->interface >= config->bNumInterfaces)
+	if (u->interface < 0 || u->interface >= config->desc.bNumInterfaces)
 		return 0;
 	iface = &config->interface[u->interface];
 
@@ -1623,9 +1623,9 @@ static int set_format_out(struct usb_audiodev *as)
 	fmt = as->fmtout + fmtnr;
 	u->format = fmt->format;
 	alts = &iface->altsetting[fmt->altsetting];
-	u->datapipe = usb_sndisocpipe(dev, alts->endpoint[0].bEndpointAddress & 0xf);
+	u->datapipe = usb_sndisocpipe(dev, alts->endpoint[0].desc.bEndpointAddress & 0xf);
 	u->syncpipe = u->syncinterval = 0;
-	if ((alts->endpoint[0].bmAttributes & 0x0c) == 0x04) {
+	if ((alts->endpoint[0].desc.bmAttributes & 0x0c) == 0x04) {
 #if 0
 		printk(KERN_DEBUG "bNumEndpoints 0x%02x endpoint[1].bmAttributes 0x%02x\n"
 		       KERN_DEBUG "endpoint[1].bSynchAddress 0x%02x endpoint[1].bEndpointAddress 0x%02x\n"
@@ -1633,22 +1633,22 @@ static int set_format_out(struct usb_audiodev *as)
 		       alts->endpoint[1].bmAttributes, alts->endpoint[1].bSynchAddress,
 		       alts->endpoint[1].bEndpointAddress, alts->endpoint[0].bSynchAddress);
 #endif
-		if (alts->bNumEndpoints < 2 ||
-		    alts->endpoint[1].bmAttributes != 0x01 ||
-		    alts->endpoint[1].bSynchAddress != 0 ||
-		    alts->endpoint[1].bEndpointAddress != (alts->endpoint[0].bSynchAddress | 0x80)) {
+		if (alts->desc.bNumEndpoints < 2 ||
+		    alts->endpoint[1].desc.bmAttributes != 0x01 ||
+		    alts->endpoint[1].desc.bSynchAddress != 0 ||
+		    alts->endpoint[1].desc.bEndpointAddress != (alts->endpoint[0].desc.bSynchAddress | 0x80)) {
 			printk(KERN_ERR "usbaudio: device %d interface %d altsetting %d invalid synch pipe\n",
 			       dev->devnum, u->interface, fmt->altsetting);
 			return -1;
 		}
-		u->syncpipe = usb_rcvisocpipe(dev, alts->endpoint[1].bEndpointAddress & 0xf);
-		u->syncinterval = alts->endpoint[1].bRefresh;
+		u->syncpipe = usb_rcvisocpipe(dev, alts->endpoint[1].desc.bEndpointAddress & 0xf);
+		u->syncinterval = alts->endpoint[1].desc.bRefresh;
 	}
 	if (d->srate < fmt->sratelo)
 		d->srate = fmt->sratelo;
 	if (d->srate > fmt->sratehi)
 		d->srate = fmt->sratehi;
-	dprintk((KERN_DEBUG "usbaudio: set_format_out: usb_set_interface %u %u\n", alts->bInterfaceNumber, fmt->altsetting));
+	dprintk((KERN_DEBUG "usbaudio: set_format_out: usb_set_interface %u %u\n", alts->desc.bInterfaceNumber, fmt->altsetting));
 	if (usb_set_interface(dev, u->interface, fmt->altsetting) < 0) {
 		printk(KERN_WARNING "usbaudio: usb_set_interface failed, device %d interface %d altsetting %d\n",
 		       dev->devnum, u->interface, fmt->altsetting);
@@ -2705,7 +2705,7 @@ static int usb_audio_release(struct inode *inode, struct file *file)
 		usbout_stop(as);
 		if (dev && as->usbout.interface >= 0) {
 			iface = &dev->actconfig->interface[as->usbout.interface];
-			usb_set_interface(dev, iface->altsetting->bInterfaceNumber, 0);
+			usb_set_interface(dev, iface->altsetting->desc.bInterfaceNumber, 0);
 		}
 		dmabuf_release(&as->usbout.dma);
 		usbout_release(as);
@@ -2714,7 +2714,7 @@ static int usb_audio_release(struct inode *inode, struct file *file)
 		usbin_stop(as);
 		if (dev && as->usbin.interface >= 0) {
 			iface = &dev->actconfig->interface[as->usbin.interface];
-			usb_set_interface(dev, iface->altsetting->bInterfaceNumber, 0);
+			usb_set_interface(dev, iface->altsetting->desc.bInterfaceNumber, 0);
 		}
 		dmabuf_release(&as->usbin.dma);
 		usbin_release(as);
@@ -2819,8 +2819,8 @@ static void usb_audio_parsestreaming(struct usb_audio_state *s, unsigned char *b
 {
 	struct usb_device *dev = s->usbdev;
 	struct usb_audiodev *as;
-	struct usb_config_descriptor *config = dev->actconfig;
-	struct usb_interface_descriptor *alts;
+	struct usb_host_config *config = dev->actconfig;
+	struct usb_host_interface *alts;
 	struct usb_interface *iface;
 	struct audioformat *fp;
 	unsigned char *fmt, *csep;
@@ -2868,17 +2868,17 @@ static void usb_audio_parsestreaming(struct usb_audio_state *s, unsigned char *b
 		iface = &config->interface[asifin];
 		for (i = 0; i < iface->num_altsetting; i++) {
 			alts = &iface->altsetting[i];
-			if (alts->bInterfaceClass != USB_CLASS_AUDIO || alts->bInterfaceSubClass != 2)
+			if (alts->desc.bInterfaceClass != USB_CLASS_AUDIO || alts->desc.bInterfaceSubClass != 2)
 				continue;
-			if (alts->bNumEndpoints < 1) {
+			if (alts->desc.bNumEndpoints < 1) {
 				if (i != 0) {  /* altsetting 0 has no endpoints (Section B.3.4.1) */
 					printk(KERN_ERR "usbaudio: device %u interface %u altsetting %u does not have an endpoint\n", 
 					       dev->devnum, asifin, i);
 				}
 				continue;
 			}
-			if ((alts->endpoint[0].bmAttributes & 0x03) != 0x01 ||
-			    !(alts->endpoint[0].bEndpointAddress & 0x80)) {
+			if ((alts->endpoint[0].desc.bmAttributes & 0x03) != 0x01 ||
+			    !(alts->endpoint[0].desc.bEndpointAddress & 0x80)) {
 				printk(KERN_ERR "usbaudio: device %u interface %u altsetting %u first endpoint not isochronous in\n", 
 				       dev->devnum, asifin, i);
 				continue;
@@ -2949,15 +2949,15 @@ static void usb_audio_parsestreaming(struct usb_audio_state *s, unsigned char *b
 		iface = &config->interface[asifout];
 		for (i = 0; i < iface->num_altsetting; i++) {
 			alts = &iface->altsetting[i];
-			if (alts->bInterfaceClass != USB_CLASS_AUDIO || alts->bInterfaceSubClass != 2)
+			if (alts->desc.bInterfaceClass != USB_CLASS_AUDIO || alts->desc.bInterfaceSubClass != 2)
 				continue;
-			if (alts->bNumEndpoints < 1) {
+			if (alts->desc.bNumEndpoints < 1) {
 				printk(KERN_ERR "usbaudio: device %u interface %u altsetting %u does not have an endpoint\n", 
 				       dev->devnum, asifout, i);
 				continue;
 			}
-			if ((alts->endpoint[0].bmAttributes & 0x03) != 0x01 ||
-			    (alts->endpoint[0].bEndpointAddress & 0x80)) {
+			if ((alts->endpoint[0].desc.bmAttributes & 0x03) != 0x01 ||
+			    (alts->endpoint[0].desc.bEndpointAddress & 0x80)) {
 				printk(KERN_ERR "usbaudio: device %u interface %u altsetting %u first endpoint not isochronous out\n", 
 				       dev->devnum, asifout, i);
 				continue;
@@ -3642,10 +3642,13 @@ static void usb_audio_constructmixer(struct usb_audio_state *s, unsigned char *b
 	list_add_tail(&ms->list, &s->mixerlist);
 }
 
+/* arbitrary limit, we won't check more interfaces than this */
+#define USB_MAXINTERFACES	32
+
 static struct usb_audio_state *usb_audio_parsecontrol(struct usb_device *dev, unsigned char *buffer, unsigned int buflen, unsigned int ctrlif)
 {
 	struct usb_audio_state *s;
-	struct usb_config_descriptor *config = dev->actconfig;
+	struct usb_host_config *config = dev->actconfig;
 	struct usb_interface *iface;
 	unsigned char ifin[USB_MAXINTERFACES], ifout[USB_MAXINTERFACES];
 	unsigned char *p1;
@@ -3675,23 +3678,23 @@ static struct usb_audio_state *usb_audio_parsecontrol(struct usb_device *dev, un
 		       dev->devnum, ctrlif);
 	for (i = 0; i < p1[7]; i++) {
 		j = p1[8+i];
-		if (j >= config->bNumInterfaces) {
+		if (j >= config->desc.bNumInterfaces) {
 			printk(KERN_ERR "usbaudio: device %d audiocontrol interface %u interface %u does not exist\n",
 			       dev->devnum, ctrlif, j);
 			continue;
 		}
 		iface = &config->interface[j];
-		if (iface->altsetting[0].bInterfaceClass != USB_CLASS_AUDIO) {
+		if (iface->altsetting[0].desc.bInterfaceClass != USB_CLASS_AUDIO) {
 			printk(KERN_ERR "usbaudio: device %d audiocontrol interface %u interface %u is not an AudioClass interface\n",
 			       dev->devnum, ctrlif, j);
 			continue;
 		}
-		if (iface->altsetting[0].bInterfaceSubClass == 3) {
+		if (iface->altsetting[0].desc.bInterfaceSubClass == 3) {
 			printk(KERN_INFO "usbaudio: device %d audiocontrol interface %u interface %u MIDIStreaming not supported\n",
 			       dev->devnum, ctrlif, j);
 			continue;
 		}
-		if (iface->altsetting[0].bInterfaceSubClass != 2) {
+		if (iface->altsetting[0].desc.bInterfaceSubClass != 2) {
 			printk(KERN_ERR "usbaudio: device %d audiocontrol interface %u interface %u invalid AudioClass subtype\n",
 			       dev->devnum, ctrlif, j);
 			continue;
@@ -3704,25 +3707,25 @@ static struct usb_audio_state *usb_audio_parsecontrol(struct usb_device *dev, un
 			printk(KERN_ERR "usbaudio: device %d audiocontrol interface %u has only 1 altsetting.\n", dev->devnum, ctrlif);
 			continue;
 		}
-		if (iface->altsetting[0].bNumEndpoints > 0) {
+		if (iface->altsetting[0].desc.bNumEndpoints > 0) {
 			/* Check all endpoints; should they all have a bandwidth of 0 ? */
-			for (k = 0; k < iface->altsetting[0].bNumEndpoints; k++) {
-				if (iface->altsetting[0].endpoint[k].wMaxPacketSize > 0) {
+			for (k = 0; k < iface->altsetting[0].desc.bNumEndpoints; k++) {
+				if (iface->altsetting[0].endpoint[k].desc.wMaxPacketSize > 0) {
 					printk(KERN_ERR "usbaudio: device %d audiocontrol interface %u endpoint %d does not have 0 bandwidth at alt[0]\n", dev->devnum, ctrlif, k);
 					break;
 				}
 			}
-			if (k < iface->altsetting[0].bNumEndpoints)
+			if (k < iface->altsetting[0].desc.bNumEndpoints)
 				continue;
 		}
-		if (iface->altsetting[1].bNumEndpoints < 1) {
+		if (iface->altsetting[1].desc.bNumEndpoints < 1) {
 			printk(KERN_ERR "usbaudio: device %d audiocontrol interface %u interface %u has no endpoint\n",
 			       dev->devnum, ctrlif, j);
 			continue;
 		}
 		/* note: this requires the data endpoint to be ep0 and the optional sync
 		   ep to be ep1, which seems to be the case */
-		if (iface->altsetting[1].endpoint[0].bEndpointAddress & USB_DIR_IN) {
+		if (iface->altsetting[1].endpoint[0].desc.bEndpointAddress & USB_DIR_IN) {
 			if (numifin < USB_MAXINTERFACES) {
 				ifin[numifin++] = j;
 				usb_driver_claim_interface(&usb_audio_driver, iface, (void *)-1);
@@ -3769,7 +3772,7 @@ static int usb_audio_probe(struct usb_interface *intf,
 			   const struct usb_device_id *id)
 {
 	struct usb_device *dev = interface_to_usbdev (intf);
-	struct usb_config_descriptor *config = dev->actconfig;	
+	struct usb_host_config *config = dev->actconfig;	
 	struct usb_audio_state *s;
 	unsigned char *buffer;
 	unsigned char buf[8];
@@ -3778,8 +3781,8 @@ static int usb_audio_probe(struct usb_interface *intf,
 
 #if 0
 	printk(KERN_DEBUG "usbaudio: Probing if %i: IC %x, ISC %x\n", ifnum,
-	       config->interface[ifnum].altsetting[0].bInterfaceClass,
-	       config->interface[ifnum].altsetting[0].bInterfaceSubClass);
+	       config->interface[ifnum].altsetting[0].desc.bInterfaceClass,
+	       config->interface[ifnum].altsetting[0].desc.bInterfaceSubClass);
 #endif
 
 	/*
@@ -3788,8 +3791,8 @@ static int usb_audio_probe(struct usb_interface *intf,
 	 */
 	i = dev->actconfig - config;
 
-	if (usb_set_configuration(dev, config->bConfigurationValue) < 0) {
-		printk(KERN_ERR "usbaudio: set_configuration failed (ConfigValue 0x%x)\n", config->bConfigurationValue);
+	if (usb_set_configuration(dev, config->desc.bConfigurationValue) < 0) {
+		printk(KERN_ERR "usbaudio: set_configuration failed (ConfigValue 0x%x)\n", config->desc.bConfigurationValue);
 		return -EIO;
 	}
 	ret = usb_get_descriptor(dev, USB_DT_CONFIG, i, buf, 8);
@@ -3810,7 +3813,7 @@ static int usb_audio_probe(struct usb_interface *intf,
 		printk(KERN_ERR "usbaudio: cannot get config descriptor %d of device %d (error %d)\n", i, dev->devnum, ret);
 		return -EIO;
 	}
-	s = usb_audio_parsecontrol(dev, buffer, buflen, intf->altsetting->bInterfaceNumber);
+	s = usb_audio_parsecontrol(dev, buffer, buflen, intf->altsetting->desc.bInterfaceNumber);
 	if (s) {
 		dev_set_drvdata (&intf->dev, s);
 		return 0;
diff --git a/drivers/usb/class/bluetty.c b/drivers/usb/class/bluetty.c
index b78fcb009ea4..9f2c5bf28cd2 100644
--- a/drivers/usb/class/bluetty.c
+++ b/drivers/usb/class/bluetty.c
@@ -328,7 +328,7 @@ static int bluetooth_ctrl_msg (struct usb_bluetooth *bluetooth, int request, int
 	dr->wIndex = cpu_to_le16((u16) bluetooth->control_out_bInterfaceNum);
 	dr->wLength = cpu_to_le16((u16) len);
 	
-	FILL_CONTROL_URB (urb, bluetooth->dev, usb_sndctrlpipe(bluetooth->dev, 0),
+	usb_fill_control_urb (urb, bluetooth->dev, usb_sndctrlpipe(bluetooth->dev, 0),
 			  (unsigned char*)dr, urb->transfer_buffer, len, bluetooth_ctrl_callback, bluetooth);
 
 	/* send it down the pipe */
@@ -382,7 +382,7 @@ static int bluetooth_open (struct tty_struct *tty, struct file * filp)
 
 #ifndef BTBUGGYHARDWARE
 		/* Start reading from the device */
-		FILL_BULK_URB (bluetooth->read_urb, bluetooth->dev, 
+		usb_fill_bulk_urb (bluetooth->read_urb, bluetooth->dev, 
 			       usb_rcvbulkpipe(bluetooth->dev, bluetooth->bulk_in_endpointAddress),
 			       bluetooth->bulk_in_buffer,
 			       bluetooth->bulk_in_buffer_size,
@@ -391,7 +391,7 @@ static int bluetooth_open (struct tty_struct *tty, struct file * filp)
 		if (result)
 			dbg("%s - usb_submit_urb(read bulk) failed with status %d", __FUNCTION__, result);
 #endif
-		FILL_INT_URB (bluetooth->interrupt_in_urb, bluetooth->dev,
+		usb_fill_int_urb (bluetooth->interrupt_in_urb, bluetooth->dev,
 			      usb_rcvintpipe(bluetooth->dev, bluetooth->interrupt_in_endpointAddress),
 			      bluetooth->interrupt_in_buffer,
 			      bluetooth->interrupt_in_buffer_size,
@@ -535,7 +535,7 @@ static int bluetooth_write (struct tty_struct * tty, int from_user, const unsign
 				memcpy (urb->transfer_buffer, current_position, buffer_size);
 
 				/* build up our urb */
-				FILL_BULK_URB (urb, bluetooth->dev, usb_sndbulkpipe(bluetooth->dev, bluetooth->bulk_out_endpointAddress),
+				usb_fill_bulk_urb (urb, bluetooth->dev, usb_sndbulkpipe(bluetooth->dev, bluetooth->bulk_out_endpointAddress),
 						urb->transfer_buffer, buffer_size, bluetooth_write_bulk_callback, bluetooth);
 
 				/* send it down the pipe */
@@ -725,7 +725,7 @@ void btusb_enable_bulk_read(struct tty_struct *tty){
 	}
 
 	if (bluetooth->read_urb) {
-		FILL_BULK_URB(bluetooth->read_urb, bluetooth->dev, 
+		usb_fill_bulk_urb(bluetooth->read_urb, bluetooth->dev, 
 			      usb_rcvbulkpipe(bluetooth->dev, bluetooth->bulk_in_endpointAddress),
 			      bluetooth->bulk_in_buffer, bluetooth->bulk_in_buffer_size, 
 			      bluetooth_read_bulk_callback, bluetooth);
@@ -933,7 +933,7 @@ static void bluetooth_read_bulk_callback (struct urb *urb)
 	if ((count == 4) && (data[0] == 0x00) && (data[1] == 0x00)
 	    && (data[2] == 0x00) && (data[3] == 0x00)) {
 		urb->actual_length = 0;
-		FILL_BULK_URB(bluetooth->read_urb, bluetooth->dev, 
+		usb_fill_bulk_urb(bluetooth->read_urb, bluetooth->dev, 
 			      usb_rcvbulkpipe(bluetooth->dev, bluetooth->bulk_in_endpointAddress),
 			      bluetooth->bulk_in_buffer, bluetooth->bulk_in_buffer_size, 
 			      bluetooth_read_bulk_callback, bluetooth);
@@ -994,7 +994,7 @@ exit:
 	if (!bluetooth || !bluetooth->open_count)
 		return;
 
-	FILL_BULK_URB(bluetooth->read_urb, bluetooth->dev, 
+	usb_fill_bulk_urb(bluetooth->read_urb, bluetooth->dev, 
 		      usb_rcvbulkpipe(bluetooth->dev, bluetooth->bulk_in_endpointAddress),
 		      bluetooth->bulk_in_buffer, bluetooth->bulk_in_buffer_size, 
 		      bluetooth_read_bulk_callback, bluetooth);
@@ -1053,7 +1053,7 @@ static int usb_bluetooth_probe (struct usb_interface *intf,
 {
 	struct usb_device *dev = interface_to_usbdev (intf);
 	struct usb_bluetooth *bluetooth = NULL;
-	struct usb_interface_descriptor *interface;
+	struct usb_host_interface *interface;
 	struct usb_endpoint_descriptor *endpoint;
 	struct usb_endpoint_descriptor *interrupt_in_endpoint[8];
 	struct usb_endpoint_descriptor *bulk_in_endpoint[8];
@@ -1068,11 +1068,11 @@ static int usb_bluetooth_probe (struct usb_interface *intf,
 	int num_bulk_out = 0;
 
 	interface = &intf->altsetting[0];
-	control_out_endpoint = interface->bInterfaceNumber;
+	control_out_endpoint = interface->desc.bInterfaceNumber;
 
 	/* find the endpoints that we need */
-	for (i = 0; i < interface->bNumEndpoints; ++i) {
-		endpoint = &interface->endpoint[i];
+	for (i = 0; i < interface->desc.bNumEndpoints; ++i) {
+		endpoint = &interface->endpoint[i].desc;
 
 		if ((endpoint->bEndpointAddress & 0x80) &&
 		    ((endpoint->bmAttributes & 3) == 0x02)) {
@@ -1160,7 +1160,7 @@ static int usb_bluetooth_probe (struct usb_interface *intf,
 		err("Couldn't allocate bulk_in_buffer");
 		goto probe_error;
 	}
-	FILL_BULK_URB(bluetooth->read_urb, dev, usb_rcvbulkpipe(dev, endpoint->bEndpointAddress),
+	usb_fill_bulk_urb(bluetooth->read_urb, dev, usb_rcvbulkpipe(dev, endpoint->bEndpointAddress),
 		      bluetooth->bulk_in_buffer, buffer_size, bluetooth_read_bulk_callback, bluetooth);
 
 	endpoint = bulk_out_endpoint[0];
@@ -1196,7 +1196,7 @@ static int usb_bluetooth_probe (struct usb_interface *intf,
 		err("Couldn't allocate interrupt_in_buffer");
 		goto probe_error;
 	}
-	FILL_INT_URB(bluetooth->interrupt_in_urb, dev, usb_rcvintpipe(dev, endpoint->bEndpointAddress),
+	usb_fill_int_urb(bluetooth->interrupt_in_urb, dev, usb_rcvintpipe(dev, endpoint->bEndpointAddress),
 		     bluetooth->interrupt_in_buffer, buffer_size, bluetooth_int_callback,
 		     bluetooth, endpoint->bInterval);
 
diff --git a/drivers/usb/class/cdc-acm.c b/drivers/usb/class/cdc-acm.c
index bdc28ce6e3a4..16e189285585 100644
--- a/drivers/usb/class/cdc-acm.c
+++ b/drivers/usb/class/cdc-acm.c
@@ -166,7 +166,9 @@ static struct acm *acm_table[ACM_TTY_MINORS];
 static int acm_ctrl_msg(struct acm *acm, int request, int value, void *buf, int len)
 {
 	int retval = usb_control_msg(acm->dev, usb_sndctrlpipe(acm->dev, 0),
-		request, USB_RT_ACM, value, acm->iface[0].altsetting[0].bInterfaceNumber, buf, len, HZ * 5);
+		request, USB_RT_ACM, value,
+		acm->iface[0].altsetting[0].desc.bInterfaceNumber,
+		buf, len, HZ * 5);
 	dbg("acm_control_msg: rq: 0x%02x val: %#x len: %#x result: %d", request, value, len, retval);
 	return retval < 0 ? retval : 0;
 }
@@ -528,8 +530,8 @@ static int acm_probe (struct usb_interface *intf,
 {
 	struct usb_device *dev;
 	struct acm *acm;
-	struct usb_config_descriptor *cfacm;
-	struct usb_interface_descriptor *ifcom, *ifdata;
+	struct usb_host_config *cfacm;
+	struct usb_host_interface *ifcom, *ifdata;
 	struct usb_endpoint_descriptor *epctrl, *epread, *epwrite;
 	int readsize, ctrlsize, minor, i;
 	unsigned char *buf;
@@ -541,7 +543,7 @@ static int acm_probe (struct usb_interface *intf,
 
 		dbg("probing config %d", cfacm->bConfigurationValue);
 
-		if (cfacm->bNumInterfaces != 2 ||
+		if (cfacm->desc.bNumInterfaces != 2 ||
 		    usb_interface_claimed(cfacm->interface + 0) ||
 		    usb_interface_claimed(cfacm->interface + 1))
 			continue;
@@ -549,20 +551,20 @@ static int acm_probe (struct usb_interface *intf,
 		ifcom = cfacm->interface[0].altsetting + 0;
 		ifdata = cfacm->interface[1].altsetting + 0;
 
-		if (ifdata->bInterfaceClass != 10 || ifdata->bNumEndpoints < 2) {
+		if (ifdata->desc.bInterfaceClass != 10 || ifdata->desc.bNumEndpoints < 2) {
 			ifcom = cfacm->interface[1].altsetting + 0;
 			ifdata = cfacm->interface[0].altsetting + 0;
-			if (ifdata->bInterfaceClass != 10 || ifdata->bNumEndpoints < 2)
+			if (ifdata->desc.bInterfaceClass != 10 || ifdata->desc.bNumEndpoints < 2)
 				continue;
 		}
 
-		if (ifcom->bInterfaceClass != 2 || ifcom->bInterfaceSubClass != 2 ||
-		    ifcom->bInterfaceProtocol != 1 || ifcom->bNumEndpoints < 1)
+		if (ifcom->desc.bInterfaceClass != 2 || ifcom->desc.bInterfaceSubClass != 2 ||
+		    ifcom->desc.bInterfaceProtocol != 1 || ifcom->desc.bNumEndpoints < 1)
 			continue;
 
-		epctrl = ifcom->endpoint + 0;
-		epread = ifdata->endpoint + 0;
-		epwrite = ifdata->endpoint + 1;
+		epctrl = &ifcom->endpoint[0].desc;
+		epread = &ifdata->endpoint[0].desc;
+		epwrite = &ifdata->endpoint[1].desc;
 
 		if ((epctrl->bEndpointAddress & 0x80) != 0x80 || (epctrl->bmAttributes & 3) != 3 ||
 		   (epread->bmAttributes & 3) != 2 || (epwrite->bmAttributes & 3) != 2 ||
@@ -570,11 +572,11 @@ static int acm_probe (struct usb_interface *intf,
 			continue;
 
 		if ((epread->bEndpointAddress & 0x80) != 0x80) {
-			epread = ifdata->endpoint + 1;
-			epwrite = ifdata->endpoint + 0;
+			epread = &ifdata->endpoint[1].desc;
+			epwrite = &ifdata->endpoint[0].desc;
 		}
 
-		usb_set_configuration(dev, cfacm->bConfigurationValue);
+		usb_set_configuration(dev, cfacm->desc.bConfigurationValue);
 
 		for (minor = 0; minor < ACM_TTY_MINORS && acm_table[minor]; minor++);
 		if (acm_table[minor]) {
@@ -630,11 +632,11 @@ static int acm_probe (struct usb_interface *intf,
 
 		usb_fill_bulk_urb(acm->readurb, dev, usb_rcvbulkpipe(dev, epread->bEndpointAddress),
 			buf += ctrlsize, readsize, acm_read_bulk, acm);
-		acm->readurb->transfer_flags |= USB_NO_FSBR;
+		acm->readurb->transfer_flags |= URB_NO_FSBR;
 
 		usb_fill_bulk_urb(acm->writeurb, dev, usb_sndbulkpipe(dev, epwrite->bEndpointAddress),
 			buf += readsize, acm->writesize, acm_write_bulk, acm);
-		acm->writeurb->transfer_flags |= USB_NO_FSBR;
+		acm->writeurb->transfer_flags |= URB_NO_FSBR;
 
 		info("ttyACM%d: USB ACM device", minor);
 
diff --git a/drivers/usb/class/usb-midi.c b/drivers/usb/class/usb-midi.c
index 87d65953ed88..586808aa0f4d 100644
--- a/drivers/usb/class/usb-midi.c
+++ b/drivers/usb/class/usb-midi.c
@@ -330,7 +330,7 @@ static int usb_write( struct midi_out_endpoint *ep, unsigned char *buf, int len
 
 	d = ep->usbdev;
 	pipe = usb_sndbulkpipe(d, ep->endpoint);
-	FILL_BULK_URB( ep->urb, d, pipe, (unsigned char*)buf, len,
+	usb_fill_bulk_urb( ep->urb, d, pipe, (unsigned char*)buf, len,
 		       (usb_complete_t)usb_write_callback, ep );
 
 	status = usb_submit_urb(ep->urb, GFP_KERNEL);
@@ -1045,7 +1045,7 @@ static struct midi_in_endpoint *alloc_midi_in_endpoint( struct usb_device *d, in
 		kfree(ep);
 		return NULL;
 	}
-	FILL_BULK_URB( ep->urb, d, 
+	usb_fill_bulk_urb( ep->urb, d, 
 		       usb_rcvbulkpipe(d, endPoint),
 		       (unsigned char *)ep->recvBuf, bufSize,
 		       (usb_complete_t)usb_bulk_read, ep );
@@ -1519,7 +1519,7 @@ static int on_bits( unsigned short v )
 static int get_alt_setting( struct usb_device *d, int ifnum )
 {
 	int alts, alt=0;
-	struct usb_interface_descriptor *interface;
+	struct usb_host_interface *interface;
 	struct usb_endpoint_descriptor *ep;
 	int epin, epout;
 	int i;
@@ -1531,8 +1531,8 @@ static int get_alt_setting( struct usb_device *d, int ifnum )
 		epin = -1;
 		epout = -1;
 
-		for ( i=0 ; i<interface->bNumEndpoints ; i++ ) {
-			ep = &interface->endpoint[i];
+		for ( i=0 ; i<interface->desc.bNumEndpoints ; i++ ) {
+			ep = &interface->endpoint[i].desc;
 			if ( (ep->bmAttributes & USB_ENDPOINT_XFERTYPE_MASK) != USB_ENDPOINT_XFER_BULK ) {
 				continue;
 			}
@@ -1778,8 +1778,8 @@ static int alloc_usb_midi_device( struct usb_device *d, struct usb_midi_state *s
 
 static int detect_yamaha_device( struct usb_device *d, unsigned int ifnum, struct usb_midi_state *s)
 {
-	struct usb_config_descriptor    *c = d->actconfig;
-	struct usb_interface_descriptor *interface;
+	struct usb_host_config *c = d->actconfig;
+	struct usb_host_interface *interface;
 	struct usb_midi_device *u;
 	unsigned char buf[USB_DT_CONFIG_SIZE], *buffer;
 	int bufSize;
@@ -1794,8 +1794,8 @@ static int detect_yamaha_device( struct usb_device *d, unsigned int ifnum, struc
 	for ( i=0 ; i < c->interface[ifnum].num_altsetting; i++ ) {
 		interface = c->interface[ifnum].altsetting + i;
 
-		if ( interface->bInterfaceClass != 255 ||
-		     interface->bInterfaceSubClass != 0 )
+		if ( interface->desc.bInterfaceClass != 255 ||
+		     interface->desc.bInterfaceSubClass != 0 )
 			continue;
 		alts = i;
 	}
@@ -1817,7 +1817,7 @@ static int detect_yamaha_device( struct usb_device *d, unsigned int ifnum, struc
  configfound:
 
 	/* this may not be necessary. */
-	if ( usb_set_configuration( d, c->bConfigurationValue ) < 0 ) {
+	if ( usb_set_configuration( d, c->desc.bConfigurationValue ) < 0 ) {
 		printk(KERN_INFO "usb-midi: Could not set config.\n");
 		return -EINVAL;
 	}
@@ -1892,8 +1892,8 @@ static int detect_vendor_specific_device( struct usb_device *d, unsigned int ifn
  **/
 static int detect_midi_subclass(struct usb_device *d, unsigned int ifnum, struct usb_midi_state *s)
 {
-	struct usb_config_descriptor    *c = d->actconfig;
-	struct usb_interface_descriptor *interface;
+	struct usb_host_config *c = d->actconfig;
+	struct usb_host_interface *interface;
 	struct usb_midi_device *u;
 	unsigned char buf[USB_DT_CONFIG_SIZE], *buffer;
 	int bufSize;
@@ -1904,8 +1904,8 @@ static int detect_midi_subclass(struct usb_device *d, unsigned int ifnum, struct
 	for ( i=0 ; i < c->interface[ifnum].num_altsetting; i++ ) {
 		interface = c->interface[ifnum].altsetting + i;
 
-		if ( interface->bInterfaceClass != USB_CLASS_AUDIO ||
-		     interface->bInterfaceSubClass != USB_SUBCLASS_MIDISTREAMING )
+		if ( interface->desc.bInterfaceClass != USB_CLASS_AUDIO ||
+		     interface->desc.bInterfaceSubClass != USB_SUBCLASS_MIDISTREAMING )
 			continue;
 		alts = i;
 	}
@@ -1927,7 +1927,7 @@ static int detect_midi_subclass(struct usb_device *d, unsigned int ifnum, struct
  configfound:
 
 	/* this may not be necessary. */
-	if ( usb_set_configuration( d, c->bConfigurationValue ) < 0 ) {
+	if ( usb_set_configuration( d, c->desc.bConfigurationValue ) < 0 ) {
 		printk(KERN_INFO "usb-midi: Could not set config.\n");
 		return -EINVAL;
 	}
@@ -2025,7 +2025,7 @@ static int usb_midi_probe(struct usb_interface *intf,
 {
 	struct usb_midi_state *s;
 	struct usb_device *dev = interface_to_usbdev(intf);
-	int ifnum = intf->altsetting->bInterfaceNumber;
+	int ifnum = intf->altsetting->desc.bInterfaceNumber;
 
 	s = (struct usb_midi_state *)kmalloc(sizeof(struct usb_midi_state), GFP_KERNEL);
 	if ( !s )
diff --git a/drivers/usb/class/usblp.c b/drivers/usb/class/usblp.c
index 0d9719dffe22..2fa6283fc107 100644
--- a/drivers/usb/class/usblp.c
+++ b/drivers/usb/class/usblp.c
@@ -814,7 +814,7 @@ static int usblp_probe(struct usb_interface *intf,
 	usblp->dev = dev;
 	init_MUTEX (&usblp->sem);
 	init_waitqueue_head(&usblp->wait);
-	usblp->ifnum = intf->altsetting->bInterfaceNumber;
+	usblp->ifnum = intf->altsetting->desc.bInterfaceNumber;
 
 	retval = usb_register_dev(&usblp_fops, USBLP_MINOR_BASE, 1, &usblp->minor);
 	if (retval) {
@@ -931,7 +931,7 @@ abort:
 static int usblp_select_alts(struct usblp *usblp)
 {
 	struct usb_interface *if_alt;
-	struct usb_interface_descriptor *ifd;
+	struct usb_host_interface *ifd;
 	struct usb_endpoint_descriptor *epd, *epwrite, *epread;
 	int p, i, e;
 
@@ -944,17 +944,17 @@ static int usblp_select_alts(struct usblp *usblp)
 	for (i = 0; i < if_alt->num_altsetting; i++) {
 		ifd = &if_alt->altsetting[i];
 
-		if (ifd->bInterfaceClass != 7 || ifd->bInterfaceSubClass != 1)
+		if (ifd->desc.bInterfaceClass != 7 || ifd->desc.bInterfaceSubClass != 1)
 			continue;
 
-		if (ifd->bInterfaceProtocol < USBLP_FIRST_PROTOCOL ||
-		    ifd->bInterfaceProtocol > USBLP_LAST_PROTOCOL)
+		if (ifd->desc.bInterfaceProtocol < USBLP_FIRST_PROTOCOL ||
+		    ifd->desc.bInterfaceProtocol > USBLP_LAST_PROTOCOL)
 			continue;
 
 		/* Look for bulk OUT and IN endpoints. */
 		epwrite = epread = 0;
-		for (e = 0; e < ifd->bNumEndpoints; e++) {
-			epd = &ifd->endpoint[e];
+		for (e = 0; e < ifd->desc.bNumEndpoints; e++) {
+			epd = &ifd->endpoint[e].desc;
 
 			if ((epd->bmAttributes&USB_ENDPOINT_XFERTYPE_MASK)!=
 			    USB_ENDPOINT_XFER_BULK)
@@ -969,12 +969,12 @@ static int usblp_select_alts(struct usblp *usblp)
 		}
 
 		/* Ignore buggy hardware without the right endpoints. */
-		if (!epwrite || (ifd->bInterfaceProtocol > 1 && !epread))
+		if (!epwrite || (ifd->desc.bInterfaceProtocol > 1 && !epread))
 			continue;
 
 		/* Turn off reads for 7/1/1 (unidirectional) interfaces
 		 * and buggy bidirectional printers. */
-		if (ifd->bInterfaceProtocol == 1) {
+		if (ifd->desc.bInterfaceProtocol == 1) {
 			epread = NULL;
 		} else if (usblp->quirks & USBLP_QUIRK_BIDIR) {
 			info("Disabling reads from problem bidirectional "
@@ -982,9 +982,9 @@ static int usblp_select_alts(struct usblp *usblp)
 			epread = NULL;
 		}
 
-		usblp->protocol[ifd->bInterfaceProtocol].alt_setting = i;
-		usblp->protocol[ifd->bInterfaceProtocol].epwrite = epwrite;
-		usblp->protocol[ifd->bInterfaceProtocol].epread = epread;
+		usblp->protocol[ifd->desc.bInterfaceProtocol].alt_setting = i;
+		usblp->protocol[ifd->desc.bInterfaceProtocol].epwrite = epwrite;
+		usblp->protocol[ifd->desc.bInterfaceProtocol].epread = epread;
 	}
 
 	/* If our requested protocol is supported, then use it. */
@@ -1018,7 +1018,7 @@ static int usblp_set_protocol(struct usblp *usblp, int protocol)
 		return r;
 	}
 
-	FILL_BULK_URB(usblp->writeurb, usblp->dev,
+	usb_fill_bulk_urb(usblp->writeurb, usblp->dev,
 		usb_sndbulkpipe(usblp->dev,
 		 usblp->protocol[protocol].epwrite->bEndpointAddress),
 		usblp->buf, 0,
@@ -1026,7 +1026,7 @@ static int usblp_set_protocol(struct usblp *usblp, int protocol)
 
 	usblp->bidir = (usblp->protocol[protocol].epread != 0);
 	if (usblp->bidir)
-		FILL_BULK_URB(usblp->readurb, usblp->dev,
+		usb_fill_bulk_urb(usblp->readurb, usblp->dev,
 			usb_rcvbulkpipe(usblp->dev,
 			 usblp->protocol[protocol].epread->bEndpointAddress),
 			usblp->buf + USBLP_BUF_SIZE, USBLP_BUF_SIZE,
diff --git a/drivers/usb/core/config.c b/drivers/usb/core/config.c
index 2598edc8d9c1..cdc0c665c63a 100644
--- a/drivers/usb/core/config.c
+++ b/drivers/usb/core/config.c
@@ -4,7 +4,16 @@
 #include <linux/slab.h>
 #include <asm/byteorder.h>
 
-static int usb_parse_endpoint(struct usb_endpoint_descriptor *endpoint, unsigned char *buffer, int size)
+
+#define USB_MAXALTSETTING		128	/* Hard limit */
+#define USB_MAXENDPOINTS		30	/* Hard limit */
+
+/* these maximums are arbitrary */
+#define USB_MAXCONFIG			8
+#define USB_ALTSETTINGALLOC		4
+#define USB_MAXINTERFACES		32
+
+static int usb_parse_endpoint(struct usb_host_endpoint *endpoint, unsigned char *buffer, int size)
 {
 	struct usb_descriptor_header *header;
 	unsigned char *begin;
@@ -20,17 +29,17 @@ static int usb_parse_endpoint(struct usb_endpoint_descriptor *endpoint, unsigned
 	}
 		
 	if (header->bDescriptorType != USB_DT_ENDPOINT) {
-		warn("unexpected descriptor 0x%X, expecting endpoint descriptor, type 0x%X",
-			endpoint->bDescriptorType, USB_DT_ENDPOINT);
+		warn("unexpected descriptor 0x%X, expecting endpoint, 0x%X",
+			header->bDescriptorType, USB_DT_ENDPOINT);
 		return parsed;
 	}
 
 	if (header->bLength == USB_DT_ENDPOINT_AUDIO_SIZE)
-		memcpy(endpoint, buffer, USB_DT_ENDPOINT_AUDIO_SIZE);
+		memcpy(&endpoint->desc, buffer, USB_DT_ENDPOINT_AUDIO_SIZE);
 	else
-		memcpy(endpoint, buffer, USB_DT_ENDPOINT_SIZE);
+		memcpy(&endpoint->desc, buffer, USB_DT_ENDPOINT_SIZE);
 	
-	le16_to_cpus(&endpoint->wMaxPacketSize);
+	le16_to_cpus(&endpoint->desc.wMaxPacketSize);
 
 	buffer += header->bLength;
 	size -= header->bLength;
@@ -93,7 +102,7 @@ static int usb_parse_interface(struct usb_interface *interface, unsigned char *b
 {
 	int i, len, numskipped, retval, parsed = 0;
 	struct usb_descriptor_header *header;
-	struct usb_interface_descriptor *ifp;
+	struct usb_host_interface *ifp;
 	unsigned char *begin;
 
 	interface->act_altsetting = 0;
@@ -108,6 +117,8 @@ static int usb_parse_interface(struct usb_interface *interface, unsigned char *b
 	}
 
 	while (size > 0) {
+		struct usb_interface_descriptor	*d;
+
 		if (interface->num_altsetting >= interface->max_altsetting) {
 			void *ptr;
 			int oldmas;
@@ -141,9 +152,9 @@ static int usb_parse_interface(struct usb_interface *interface, unsigned char *b
 		memcpy(ifp, buffer, USB_DT_INTERFACE_SIZE);
 
 		/* Skip over the interface */
-		buffer += ifp->bLength;
-		parsed += ifp->bLength;
-		size -= ifp->bLength;
+		buffer += ifp->desc.bLength;
+		parsed += ifp->desc.bLength;
+		size -= ifp->desc.bLength;
 
 		begin = buffer;
 		numskipped = 0;
@@ -196,23 +207,23 @@ static int usb_parse_interface(struct usb_interface *interface, unsigned char *b
 		     (header->bDescriptorType == USB_DT_DEVICE)))
 			return parsed;
 
-		if (ifp->bNumEndpoints > USB_MAXENDPOINTS) {
+		if (ifp->desc.bNumEndpoints > USB_MAXENDPOINTS) {
 			warn("too many endpoints");
 			return -1;
 		}
 
-		ifp->endpoint = (struct usb_endpoint_descriptor *)
-			kmalloc(ifp->bNumEndpoints *
-			sizeof(struct usb_endpoint_descriptor), GFP_KERNEL);
+		ifp->endpoint = (struct usb_host_endpoint *)
+			kmalloc(ifp->desc.bNumEndpoints *
+			sizeof(struct usb_host_endpoint), GFP_KERNEL);
 		if (!ifp->endpoint) {
 			err("out of memory");
 			return -1;	
 		}
 
-		memset(ifp->endpoint, 0, ifp->bNumEndpoints *
-			sizeof(struct usb_endpoint_descriptor));
+		memset(ifp->endpoint, 0, ifp->desc.bNumEndpoints *
+			sizeof(struct usb_host_endpoint));
 	
-		for (i = 0; i < ifp->bNumEndpoints; i++) {
+		for (i = 0; i < ifp->desc.bNumEndpoints; i++) {
 			header = (struct usb_descriptor_header *)buffer;
 
 			if (header->bLength > size) {
@@ -230,49 +241,49 @@ static int usb_parse_interface(struct usb_interface *interface, unsigned char *b
 		}
 
 		/* We check to see if it's an alternate to this one */
-		ifp = (struct usb_interface_descriptor *)buffer;
-		if (size < USB_DT_INTERFACE_SIZE ||
-		    ifp->bDescriptorType != USB_DT_INTERFACE ||
-		    !ifp->bAlternateSetting)
+		d = (struct usb_interface_descriptor *)buffer;
+		if (size < USB_DT_INTERFACE_SIZE
+				|| d->bDescriptorType != USB_DT_INTERFACE
+				|| !d->bAlternateSetting)
 			return parsed;
 	}
 
 	return parsed;
 }
 
-int usb_parse_configuration(struct usb_config_descriptor *config, char *buffer)
+int usb_parse_configuration(struct usb_host_config *config, char *buffer)
 {
 	int i, retval, size;
 	struct usb_descriptor_header *header;
 
-	memcpy(config, buffer, USB_DT_CONFIG_SIZE);
-	le16_to_cpus(&config->wTotalLength);
-	size = config->wTotalLength;
+	memcpy(&config->desc, buffer, USB_DT_CONFIG_SIZE);
+	le16_to_cpus(&config->desc.wTotalLength);
+	size = config->desc.wTotalLength;
 
-	if (config->bNumInterfaces > USB_MAXINTERFACES) {
+	if (config->desc.bNumInterfaces > USB_MAXINTERFACES) {
 		warn("too many interfaces");
 		return -1;
 	}
 
 	config->interface = (struct usb_interface *)
-		kmalloc(config->bNumInterfaces *
+		kmalloc(config->desc.bNumInterfaces *
 		sizeof(struct usb_interface), GFP_KERNEL);
-	dbg("kmalloc IF %p, numif %i", config->interface, config->bNumInterfaces);
+	dbg("kmalloc IF %p, numif %i", config->interface, config->desc.bNumInterfaces);
 	if (!config->interface) {
 		err("out of memory");
 		return -1;	
 	}
 
 	memset(config->interface, 0,
-	       config->bNumInterfaces * sizeof(struct usb_interface));
+	       config->desc.bNumInterfaces * sizeof(struct usb_interface));
 
-	buffer += config->bLength;
-	size -= config->bLength;
+	buffer += config->desc.bLength;
+	size -= config->desc.bLength;
 	
 	config->extra = NULL;
 	config->extralen = 0;
 
-	for (i = 0; i < config->bNumInterfaces; i++) {
+	for (i = 0; i < config->desc.bNumInterfaces; i++) {
 		int numskipped, len;
 		char *begin;
 
@@ -351,12 +362,12 @@ void usb_destroy_configuration(struct usb_device *dev)
 	}
 
 	for (c = 0; c < dev->descriptor.bNumConfigurations; c++) {
-		struct usb_config_descriptor *cf = &dev->config[c];
+		struct usb_host_config *cf = &dev->config[c];
 
 		if (!cf->interface)
 			break;
 
-		for (i = 0; i < cf->bNumInterfaces; i++) {
+		for (i = 0; i < cf->desc.bNumInterfaces; i++) {
 			struct usb_interface *ifp =
 				&cf->interface[i];
 				
@@ -364,7 +375,7 @@ void usb_destroy_configuration(struct usb_device *dev)
 				break;
 
 			for (j = 0; j < ifp->num_altsetting; j++) {
-				struct usb_interface_descriptor *as =
+				struct usb_host_interface *as =
 					&ifp->altsetting[j];
 					
 				if(as->extra) {
@@ -374,7 +385,7 @@ void usb_destroy_configuration(struct usb_device *dev)
 				if (!as->endpoint)
 					break;
 					
-				for(k = 0; k < as->bNumEndpoints; k++) {
+				for(k = 0; k < as->desc.bNumEndpoints; k++) {
 					if(as->endpoint[k].extra) {
 						kfree(as->endpoint[k].extra);
 					}
@@ -410,15 +421,15 @@ int usb_get_configuration(struct usb_device *dev)
 		return -EINVAL;
 	}
 
-	dev->config = (struct usb_config_descriptor *)
+	dev->config = (struct usb_host_config *)
 		kmalloc(dev->descriptor.bNumConfigurations *
-		sizeof(struct usb_config_descriptor), GFP_KERNEL);
+		sizeof(struct usb_host_config), GFP_KERNEL);
 	if (!dev->config) {
 		err("out of memory");
 		return -ENOMEM;	
 	}
 	memset(dev->config, 0, dev->descriptor.bNumConfigurations *
-		sizeof(struct usb_config_descriptor));
+		sizeof(struct usb_host_config));
 
 	dev->rawdescriptors = (char **)kmalloc(sizeof(char *) *
 		dev->descriptor.bNumConfigurations, GFP_KERNEL);
diff --git a/drivers/usb/core/devices.c b/drivers/usb/core/devices.c
index 1e819db95786..3d4c29b579b4 100644
--- a/drivers/usb/core/devices.c
+++ b/drivers/usb/core/devices.c
@@ -234,7 +234,7 @@ static char *usb_dump_endpoint_descriptor (
 
 static char *usb_dump_interface_descriptor(char *start, char *end, const struct usb_interface *iface, int setno)
 {
-	struct usb_interface_descriptor *desc = &iface->altsetting[setno];
+	struct usb_interface_descriptor *desc = &iface->altsetting[setno].desc;
 
 	if (start > end)
 		return start;
@@ -259,15 +259,15 @@ static char *usb_dump_interface(
 	const struct usb_interface *iface,
 	int setno
 ) {
-	struct usb_interface_descriptor *desc = &iface->altsetting[setno];
+	struct usb_host_interface *desc = &iface->altsetting[setno];
 	int i;
 
 	start = usb_dump_interface_descriptor(start, end, iface, setno);
-	for (i = 0; i < desc->bNumEndpoints; i++) {
+	for (i = 0; i < desc->desc.bNumEndpoints; i++) {
 		if (start > end)
 			return start;
 		start = usb_dump_endpoint_descriptor(speed,
-				start, end, desc->endpoint + i);
+				start, end, &desc->endpoint[i].desc);
 	}
 	return start;
 }
@@ -288,7 +288,7 @@ static char *usb_dump_config_descriptor(char *start, char *end, const struct usb
 			 desc->bNumInterfaces,
 			 desc->bConfigurationValue,
 			 desc->bmAttributes,
-			 desc->MaxPower * 2);
+			 desc->bMaxPower * 2);
 	return start;
 }
 
@@ -296,7 +296,7 @@ static char *usb_dump_config (
 	int speed,
 	char *start,
 	char *end,
-	const struct usb_config_descriptor *config,
+	const struct usb_host_config *config,
 	int active
 )
 {
@@ -307,8 +307,8 @@ static char *usb_dump_config (
 		return start;
 	if (!config)		/* getting these some in 2.3.7; none in 2.3.6 */
 		return start + sprintf(start, "(null Cfg. desc.)\n");
-	start = usb_dump_config_descriptor(start, end, config, active);
-	for (i = 0; i < config->bNumInterfaces; i++) {
+	start = usb_dump_config_descriptor(start, end, &config->desc, active);
+	for (i = 0; i < config->desc.bNumInterfaces; i++) {
 		interface = config->interface + i;
 		if (!interface)
 			break;
diff --git a/drivers/usb/core/devio.c b/drivers/usb/core/devio.c
index 22596da570cd..3770a6a0d270 100644
--- a/drivers/usb/core/devio.c
+++ b/drivers/usb/core/devio.c
@@ -337,7 +337,8 @@ static int claimintf(struct dev_state *ps, unsigned int intf)
 	struct usb_interface *iface;
 	int err;
 
-	if (intf >= 8*sizeof(ps->ifclaimed) || !dev || intf >= dev->actconfig->bNumInterfaces)
+	if (intf >= 8*sizeof(ps->ifclaimed) || !dev
+			|| intf >= dev->actconfig->desc.bNumInterfaces)
 		return -EINVAL;
 	/* already claimed */
 	if (test_bit(intf, &ps->ifclaimed))
@@ -390,17 +391,17 @@ static int findintfep(struct usb_device *dev, unsigned int ep)
 {
 	unsigned int i, j, e;
         struct usb_interface *iface;
-	struct usb_interface_descriptor *alts;
+	struct usb_host_interface *alts;
 	struct usb_endpoint_descriptor *endpt;
 
 	if (ep & ~(USB_DIR_IN|0xf))
 		return -EINVAL;
-	for (i = 0; i < dev->actconfig->bNumInterfaces; i++) {
+	for (i = 0; i < dev->actconfig->desc.bNumInterfaces; i++) {
 		iface = &dev->actconfig->interface[i];
 		for (j = 0; j < iface->num_altsetting; j++) {
                         alts = &iface->altsetting[j];
-			for (e = 0; e < alts->bNumEndpoints; e++) {
-				endpt = &alts->endpoint[e];
+			for (e = 0; e < alts->desc.bNumEndpoints; e++) {
+				endpt = &alts->endpoint[e].desc;
 				if (endpt->bEndpointAddress == ep)
 					return i;
 			}
@@ -413,15 +414,15 @@ static int findintfif(struct usb_device *dev, unsigned int ifn)
 {
 	unsigned int i, j;
         struct usb_interface *iface;
-	struct usb_interface_descriptor *alts;
+	struct usb_host_interface *alts;
 
 	if (ifn & ~0xff)
 		return -EINVAL;
-	for (i = 0; i < dev->actconfig->bNumInterfaces; i++) {
+	for (i = 0; i < dev->actconfig->desc.bNumInterfaces; i++) {
 		iface = &dev->actconfig->interface[i];
 		for (j = 0; j < iface->num_altsetting; j++) {
                         alts = &iface->altsetting[j];
-			if (alts->bInterfaceNumber == ifn)
+			if (alts->desc.bInterfaceNumber == ifn)
 				return i;
 		}
 	}
@@ -693,7 +694,7 @@ static int proc_resetdevice(struct dev_state *ps)
 	if (ret < 0)
 		return ret;
 
-	for (i = 0; i < ps->dev->actconfig->bNumInterfaces; i++) {
+	for (i = 0; i < ps->dev->actconfig->desc.bNumInterfaces; i++) {
 		struct usb_interface *intf = &ps->dev->actconfig->interface[i];
 
 		/* Don't simulate interfaces we've claimed */
@@ -755,7 +756,7 @@ static int proc_submiturb(struct dev_state *ps, void *arg)
 	if (copy_from_user(&uurb, arg, sizeof(uurb)))
 		return -EFAULT;
 	if (uurb.flags & ~(USBDEVFS_URB_ISO_ASAP|USBDEVFS_URB_SHORT_NOT_OK|
-			   USB_NO_FSBR|USB_ZERO_PACKET))
+			   URB_NO_FSBR|URB_ZERO_PACKET))
 		return -EINVAL;
 	if (!uurb.buffer)
 		return -EINVAL;
diff --git a/drivers/usb/core/driverfs.c b/drivers/usb/core/driverfs.c
index 14b049f547fd..f0b821df7eea 100644
--- a/drivers/usb/core/driverfs.c
+++ b/drivers/usb/core/driverfs.c
@@ -33,14 +33,14 @@ show_##field (struct device *dev, char *buf, size_t count, loff_t off)	\
 		return 0;						\
 									\
 	udev = to_usb_device (dev);					\
-	return sprintf (buf, format_string, udev->actconfig->field);	\
+	return sprintf (buf, format_string, udev->actconfig->desc.field); \
 }									\
 static DEVICE_ATTR(field, S_IRUGO, show_##field, NULL);
 
 usb_actconfig_attr (bNumInterfaces, "%2d\n")
 usb_actconfig_attr (bConfigurationValue, "%2d\n")
 usb_actconfig_attr (bmAttributes, "%2x\n")
-usb_actconfig_attr (MaxPower, "%3dmA\n")
+usb_actconfig_attr (bMaxPower, "%3dmA\n")
 
 /* String fields */
 static ssize_t show_product (struct device *dev, char *buf, size_t count, loff_t off)
@@ -157,7 +157,7 @@ void usb_create_driverfs_dev_files (struct usb_device *udev)
 	device_create_file (dev, &dev_attr_bNumInterfaces);
 	device_create_file (dev, &dev_attr_bConfigurationValue);
 	device_create_file (dev, &dev_attr_bmAttributes);
-	device_create_file (dev, &dev_attr_MaxPower);
+	device_create_file (dev, &dev_attr_bMaxPower);
 	device_create_file (dev, &dev_attr_idVendor);
 	device_create_file (dev, &dev_attr_idProduct);
 	device_create_file (dev, &dev_attr_bcdDevice);
@@ -188,7 +188,7 @@ show_##field (struct device *dev, char *buf, size_t count, loff_t off)	\
 	intf = to_usb_interface (dev);					\
 	alt = intf->act_altsetting;					\
 									\
-	return sprintf (buf, format_string, intf->altsetting[alt].field);	\
+	return sprintf (buf, format_string, intf->altsetting[alt].desc.field); \
 }									\
 static DEVICE_ATTR(field, S_IRUGO, show_##field, NULL);
 
diff --git a/drivers/usb/core/hcd.c b/drivers/usb/core/hcd.c
index 4d48c311f1b0..bd3467543386 100644
--- a/drivers/usb/core/hcd.c
+++ b/drivers/usb/core/hcd.c
@@ -1110,7 +1110,7 @@ static int hcd_unlink_urb (struct urb *urb)
 	 */
 	spin_lock_irqsave (&urb->lock, flags);
 	spin_lock (&hcd_data_lock);
-	if (!urb->hcpriv || urb->transfer_flags & USB_TIMEOUT_KILLED) {
+	if (!urb->hcpriv || urb->transfer_flags & URB_TIMEOUT_KILLED) {
 		retval = -EINVAL;
 		goto done;
 	}
@@ -1150,9 +1150,9 @@ static int hcd_unlink_urb (struct urb *urb)
 	 * lower level hcd code is always async, locking on urb->status
 	 * updates; an intercepted completion unblocks us.
 	 */
-	if ((urb->transfer_flags & USB_TIMEOUT_KILLED))
+	if ((urb->transfer_flags & URB_TIMEOUT_KILLED))
 		urb->status = -ETIMEDOUT;
-	else if (!(urb->transfer_flags & USB_ASYNC_UNLINK)) {
+	else if (!(urb->transfer_flags & URB_ASYNC_UNLINK)) {
 		if (in_interrupt ()) {
 			dbg ("non-async unlink in_interrupt");
 			retval = -EWOULDBLOCK;
@@ -1182,13 +1182,13 @@ if (retval && urb->status == -ENOENT) err ("whoa! retval %d", retval);
 	}
 
     	/* block till giveback, if needed */
-	if (!(urb->transfer_flags & (USB_ASYNC_UNLINK|USB_TIMEOUT_KILLED))
+	if (!(urb->transfer_flags & (URB_ASYNC_UNLINK|URB_TIMEOUT_KILLED))
 			&& HCD_IS_RUNNING (hcd->state)
 			&& !retval) {
 		dbg ("%s: wait for giveback urb %p",
 			hcd->self.bus_name, urb);
 		wait_for_completion (&splice.done);
-	} else if ((urb->transfer_flags & USB_ASYNC_UNLINK) && retval == 0) {
+	} else if ((urb->transfer_flags & URB_ASYNC_UNLINK) && retval == 0) {
 		return -EINPROGRESS;
 	}
 	goto bye;
diff --git a/drivers/usb/core/hub.c b/drivers/usb/core/hub.c
index 28712be6a473..cf4e9236724c 100644
--- a/drivers/usb/core/hub.c
+++ b/drivers/usb/core/hub.c
@@ -418,7 +418,7 @@ static int usb_hub_configure(struct usb_hub *hub,
 		return -1;
 	}
 
-	FILL_INT_URB(hub->urb, dev, pipe, hub->buffer, maxp, hub_irq,
+	usb_fill_int_urb(hub->urb, dev, pipe, hub->buffer, maxp, hub_irq,
 		hub, endpoint->bInterval);
 	ret = usb_submit_urb(hub->urb, GFP_KERNEL);
 	if (ret) {
@@ -478,7 +478,7 @@ static void hub_disconnect(struct usb_interface *intf)
 
 static int hub_probe(struct usb_interface *intf, const struct usb_device_id *id)
 {
-	struct usb_interface_descriptor *desc;
+	struct usb_host_interface *desc;
 	struct usb_endpoint_descriptor *endpoint;
 	struct usb_device *dev;
 	struct usb_hub *hub;
@@ -489,21 +489,21 @@ static int hub_probe(struct usb_interface *intf, const struct usb_device_id *id)
 
 	/* Some hubs have a subclass of 1, which AFAICT according to the */
 	/*  specs is not defined, but it works */
-	if ((desc->bInterfaceSubClass != 0) &&
-	    (desc->bInterfaceSubClass != 1)) {
+	if ((desc->desc.bInterfaceSubClass != 0) &&
+	    (desc->desc.bInterfaceSubClass != 1)) {
 		err("invalid subclass (%d) for USB hub device #%d",
-			desc->bInterfaceSubClass, dev->devnum);
+			desc->desc.bInterfaceSubClass, dev->devnum);
 		return -EIO;
 	}
 
 	/* Multiple endpoints? What kind of mutant ninja-hub is this? */
-	if (desc->bNumEndpoints != 1) {
+	if (desc->desc.bNumEndpoints != 1) {
 		err("invalid bNumEndpoints (%d) for USB hub device #%d",
-			desc->bNumEndpoints, dev->devnum);
+			desc->desc.bNumEndpoints, dev->devnum);
 		return -EIO;
 	}
 
-	endpoint = &desc->endpoint[0];
+	endpoint = &desc->endpoint[0].desc;
 
 	/* Output endpoint? Curiousier and curiousier.. */
 	if (!(endpoint->bEndpointAddress & USB_DIR_IN)) {
@@ -1244,18 +1244,18 @@ int usb_reset_device(struct usb_device *dev)
 		return 1;
 	}
 
-	ret = usb_set_configuration(dev, dev->actconfig->bConfigurationValue);
+	ret = usb_set_configuration(dev, dev->actconfig->desc.bConfigurationValue);
 	if (ret < 0) {
 		err("failed to set dev %s active configuration (error=%d)",
 			dev->devpath, ret);
 		return ret;
 	}
 
-	for (i = 0; i < dev->actconfig->bNumInterfaces; i++) {
+	for (i = 0; i < dev->actconfig->desc.bNumInterfaces; i++) {
 		struct usb_interface *intf = &dev->actconfig->interface[i];
 		struct usb_interface_descriptor *as;
 
-		as = &intf->altsetting[intf->act_altsetting];
+		as = &intf->altsetting[intf->act_altsetting].desc;
 		ret = usb_set_interface(dev, as->bInterfaceNumber,
 			as->bAlternateSetting);
 		if (ret < 0) {
diff --git a/drivers/usb/core/message.c b/drivers/usb/core/message.c
index 16e3e8b43f2b..18a0c6493483 100644
--- a/drivers/usb/core/message.c
+++ b/drivers/usb/core/message.c
@@ -92,7 +92,7 @@ int usb_internal_control_msg(struct usb_device *usb_dev, unsigned int pipe,
 	if (!urb)
 		return -ENOMEM;
   
-	FILL_CONTROL_URB(urb, usb_dev, pipe, (unsigned char*)cmd, data, len,
+	usb_fill_control_urb(urb, usb_dev, pipe, (unsigned char*)cmd, data, len,
 		   usb_api_blocking_completion, 0);
 
 	retv = usb_start_wait_urb(urb, timeout, &length);
@@ -190,7 +190,7 @@ int usb_bulk_msg(struct usb_device *usb_dev, unsigned int pipe,
 	if (!urb)
 		return -ENOMEM;
 
-	FILL_BULK_URB(urb, usb_dev, pipe, data, len,
+	usb_fill_bulk_urb(urb, usb_dev, pipe, data, len,
 		    usb_api_blocking_completion, 0);
 
 	return usb_start_wait_urb(urb,timeout,actual_length);
@@ -324,7 +324,7 @@ int usb_sg_init (
 	if (!io->urbs)
 		goto nomem;
 
-	urb_flags = USB_ASYNC_UNLINK | URB_NO_DMA_MAP | URB_NO_INTERRUPT;
+	urb_flags = URB_ASYNC_UNLINK | URB_NO_DMA_MAP | URB_NO_INTERRUPT;
 	if (usb_pipein (pipe))
 		urb_flags |= URB_SHORT_NOT_OK;
 
@@ -640,31 +640,33 @@ int usb_get_status(struct usb_device *dev, int type, int target, void *data)
 
 
 // hub-only!! ... and only exported for reset/reinit path.
-// otherwise used internally, for config/altsetting reconfig.
+// otherwise used internally, when setting up a config
 void usb_set_maxpacket(struct usb_device *dev)
 {
 	int i, b;
 
-	for (i=0; i<dev->actconfig->bNumInterfaces; i++) {
+	for (i=0; i<dev->actconfig->desc.bNumInterfaces; i++) {
 		struct usb_interface *ifp = dev->actconfig->interface + i;
-		struct usb_interface_descriptor *as = ifp->altsetting + ifp->act_altsetting;
-		struct usb_endpoint_descriptor *ep = as->endpoint;
+		struct usb_host_interface *as = ifp->altsetting + ifp->act_altsetting;
+		struct usb_host_endpoint *ep = as->endpoint;
 		int e;
 
-		for (e=0; e<as->bNumEndpoints; e++) {
-			b = ep[e].bEndpointAddress & USB_ENDPOINT_NUMBER_MASK;
-			if ((ep[e].bmAttributes & USB_ENDPOINT_XFERTYPE_MASK) ==
+		for (e=0; e<as->desc.bNumEndpoints; e++) {
+			struct usb_endpoint_descriptor	*d;
+			d = &ep [e].desc;
+			b = d->bEndpointAddress & USB_ENDPOINT_NUMBER_MASK;
+			if ((d->bmAttributes & USB_ENDPOINT_XFERTYPE_MASK) ==
 				USB_ENDPOINT_XFER_CONTROL) {	/* Control => bidirectional */
-				dev->epmaxpacketout[b] = ep[e].wMaxPacketSize;
-				dev->epmaxpacketin [b] = ep[e].wMaxPacketSize;
+				dev->epmaxpacketout[b] = d->wMaxPacketSize;
+				dev->epmaxpacketin [b] = d->wMaxPacketSize;
 				}
-			else if (usb_endpoint_out(ep[e].bEndpointAddress)) {
-				if (ep[e].wMaxPacketSize > dev->epmaxpacketout[b])
-					dev->epmaxpacketout[b] = ep[e].wMaxPacketSize;
+			else if (usb_endpoint_out(d->bEndpointAddress)) {
+				if (d->wMaxPacketSize > dev->epmaxpacketout[b])
+					dev->epmaxpacketout[b] = d->wMaxPacketSize;
 			}
 			else {
-				if (ep[e].wMaxPacketSize > dev->epmaxpacketin [b])
-					dev->epmaxpacketin [b] = ep[e].wMaxPacketSize;
+				if (d->wMaxPacketSize > dev->epmaxpacketin [b])
+					dev->epmaxpacketin [b] = d->wMaxPacketSize;
 			}
 		}
 	}
@@ -764,7 +766,7 @@ int usb_clear_halt(struct usb_device *dev, int pipe)
 int usb_set_interface(struct usb_device *dev, int interface, int alternate)
 {
 	struct usb_interface *iface;
-	struct usb_interface_descriptor *iface_as;
+	struct usb_host_interface *iface_as;
 	int i, ret;
 
 	iface = usb_ifnum_to_if(dev, interface);
@@ -786,7 +788,8 @@ int usb_set_interface(struct usb_device *dev, int interface, int alternate)
 
 	if ((ret = usb_control_msg(dev, usb_sndctrlpipe(dev, 0),
 				   USB_REQ_SET_INTERFACE, USB_RECIP_INTERFACE,
-				   iface->altsetting[alternate].bAlternateSetting,
+				   iface->altsetting[alternate]
+				   	.desc.bAlternateSetting,
 				   interface, NULL, 0, HZ * 5)) < 0)
 		return ret;
 
@@ -798,8 +801,8 @@ int usb_set_interface(struct usb_device *dev, int interface, int alternate)
 
 	/* prevent submissions using previous endpoint settings */
 	iface_as = iface->altsetting + iface->act_altsetting;
-	for (i = 0; i < iface_as->bNumEndpoints; i++) {
-		u8	ep = iface_as->endpoint [i].bEndpointAddress;
+	for (i = 0; i < iface_as->desc.bNumEndpoints; i++) {
+		u8	ep = iface_as->endpoint [i].desc.bEndpointAddress;
 		int	out = !(ep & USB_DIR_IN);
 
 		ep &= USB_ENDPOINT_NUMBER_MASK;
@@ -821,14 +824,14 @@ int usb_set_interface(struct usb_device *dev, int interface, int alternate)
 	 */
 
 	iface_as = &iface->altsetting[alternate];
-	for (i = 0; i < iface_as->bNumEndpoints; i++) {
-		u8	ep = iface_as->endpoint[i].bEndpointAddress;
+	for (i = 0; i < iface_as->desc.bNumEndpoints; i++) {
+		u8	ep = iface_as->endpoint[i].desc.bEndpointAddress;
 		int	out = !(ep & USB_DIR_IN);
 
 		ep &= USB_ENDPOINT_NUMBER_MASK;
 		usb_settoggle (dev, ep, out, 0);
 		(out ? dev->epmaxpacketout : dev->epmaxpacketin) [ep]
-			= iface_as->endpoint [i].wMaxPacketSize;
+			= iface_as->endpoint [i].desc.wMaxPacketSize;
 	}
 
 	return 0;
@@ -867,10 +870,10 @@ int usb_set_interface(struct usb_device *dev, int interface, int alternate)
 int usb_set_configuration(struct usb_device *dev, int configuration)
 {
 	int i, ret;
-	struct usb_config_descriptor *cp = NULL;
+	struct usb_host_config *cp = NULL;
 	
 	for (i=0; i<dev->descriptor.bNumConfigurations; i++) {
-		if (dev->config[i].bConfigurationValue == configuration) {
+		if (dev->config[i].desc.bConfigurationValue == configuration) {
 			cp = &dev->config[i];
 			break;
 		}
diff --git a/drivers/usb/core/urb.c b/drivers/usb/core/urb.c
index 929fc66270ff..dd125b117124 100644
--- a/drivers/usb/core/urb.c
+++ b/drivers/usb/core/urb.c
@@ -272,23 +272,23 @@ int usb_submit_urb(struct urb *urb, int mem_flags)
 	unsigned int	allowed;
 
 	/* enforce simple/standard policy */
-	allowed = USB_ASYNC_UNLINK;	// affects later unlinks
+	allowed = URB_ASYNC_UNLINK;	// affects later unlinks
 	allowed |= URB_NO_DMA_MAP;
 	allowed |= URB_NO_INTERRUPT;
 	switch (temp) {
 	case PIPE_BULK:
 		if (is_out)
-			allowed |= USB_ZERO_PACKET;
+			allowed |= URB_ZERO_PACKET;
 		/* FALLTHROUGH */
 	case PIPE_CONTROL:
-		allowed |= USB_NO_FSBR;	/* only affects UHCI */
+		allowed |= URB_NO_FSBR;	/* only affects UHCI */
 		/* FALLTHROUGH */
 	default:			/* all non-iso endpoints */
 		if (!is_out)
 			allowed |= URB_SHORT_NOT_OK;
 		break;
 	case PIPE_ISOCHRONOUS:
-		allowed |= USB_ISO_ASAP;
+		allowed |= URB_ISO_ASAP;
 		break;
 	}
 	urb->transfer_flags &= allowed;
@@ -360,7 +360,7 @@ int usb_submit_urb(struct urb *urb, int mem_flags)
  * that the request has been canceled, and that control of the URB
  * has been returned to that device driver.
  *
- * When the USB_ASYNC_UNLINK transfer flag for the URB is clear, this
+ * When the URB_ASYNC_UNLINK transfer flag for the URB is clear, this
  * request is synchronous.  Success is indicated by returning zero,
  * at which time the urb will have been unlinked,
  * and the completion function will see status -ENOENT.  Failure is
@@ -368,7 +368,7 @@ int usb_submit_urb(struct urb *urb, int mem_flags)
  * when unlinking an urb from an interrupt context, such as a bottom
  * half or a completion handler,
  *
- * When the USB_ASYNC_UNLINK transfer flag for the URB is set, this
+ * When the URB_ASYNC_UNLINK transfer flag for the URB is set, this
  * request is asynchronous.  Success is indicated by returning -EINPROGRESS,
  * at which time the urb will normally not have been unlinked,
  * and the completion function will see status -ECONNRESET.  Failure is
diff --git a/drivers/usb/core/usb-debug.c b/drivers/usb/core/usb-debug.c
index a29393e06dcb..c3e29a37665e 100644
--- a/drivers/usb/core/usb-debug.c
+++ b/drivers/usb/core/usb-debug.c
@@ -16,28 +16,28 @@
 #endif
 #include <linux/usb.h>
 
-static void usb_show_endpoint(struct usb_endpoint_descriptor *endpoint)
+static void usb_show_endpoint(struct usb_host_endpoint *endpoint)
 {
-	usb_show_endpoint_descriptor(endpoint);
+	usb_show_endpoint_descriptor(&endpoint->desc);
 }
 
-static void usb_show_interface(struct usb_interface_descriptor *altsetting)
+static void usb_show_interface(struct usb_host_interface *altsetting)
 {
 	int i;
 
-	usb_show_interface_descriptor(altsetting);
+	usb_show_interface_descriptor(&altsetting->desc);
 
-	for (i = 0; i < altsetting->bNumEndpoints; i++)
+	for (i = 0; i < altsetting->desc.bNumEndpoints; i++)
 		usb_show_endpoint(altsetting->endpoint + i);
 }
 
-static void usb_show_config(struct usb_config_descriptor *config)
+static void usb_show_config(struct usb_host_config *config)
 {
 	int i, j;
 	struct usb_interface *ifp;
 
-	usb_show_config_descriptor(config);
-	for (i = 0; i < config->bNumInterfaces; i++) {
+	usb_show_config_descriptor(&config->desc);
+	for (i = 0; i < config->desc.bNumInterfaces; i++) {
 		ifp = config->interface + i;
 
 		if (!ifp)
@@ -124,7 +124,7 @@ void usb_show_config_descriptor(struct usb_config_descriptor *desc)
 	printk("  bConfigurationValue =   %02x\n", desc->bConfigurationValue);
 	printk("  iConfiguration      =   %02x\n", desc->iConfiguration);
 	printk("  bmAttributes        =   %02x\n", desc->bmAttributes);
-	printk("  MaxPower            = %4dmA\n", desc->MaxPower * 2);
+	printk("  bMaxPower            = %4dmA\n", desc->bMaxPower * 2);
 }
 
 void usb_show_interface_descriptor(struct usb_interface_descriptor *desc)
diff --git a/drivers/usb/core/usb.c b/drivers/usb/core/usb.c
index b217ba001e45..eb00740a20de 100644
--- a/drivers/usb/core/usb.c
+++ b/drivers/usb/core/usb.c
@@ -233,8 +233,9 @@ struct usb_interface *usb_ifnum_to_if(struct usb_device *dev, unsigned ifnum)
 {
 	int i;
 
-	for (i = 0; i < dev->actconfig->bNumInterfaces; i++)
-		if (dev->actconfig->interface[i].altsetting[0].bInterfaceNumber == ifnum)
+	for (i = 0; i < dev->actconfig->desc.bNumInterfaces; i++)
+		if (dev->actconfig->interface[i].altsetting[0]
+				.desc.bInterfaceNumber == ifnum)
 			return &dev->actconfig->interface[i];
 
 	return NULL;
@@ -254,15 +255,21 @@ struct usb_interface *usb_ifnum_to_if(struct usb_device *dev, unsigned ifnum)
  * the first endpoint in that descriptor corresponds to interface zero.
  * This routine helps device drivers avoid such mistakes.
  */
-struct usb_endpoint_descriptor *usb_epnum_to_ep_desc(struct usb_device *dev, unsigned epnum)
+struct usb_endpoint_descriptor *
+usb_epnum_to_ep_desc(struct usb_device *dev, unsigned epnum)
 {
 	int i, j, k;
 
-	for (i = 0; i < dev->actconfig->bNumInterfaces; i++)
+	for (i = 0; i < dev->actconfig->desc.bNumInterfaces; i++)
 		for (j = 0; j < dev->actconfig->interface[i].num_altsetting; j++)
-			for (k = 0; k < dev->actconfig->interface[i].altsetting[j].bNumEndpoints; k++)
-				if (epnum == dev->actconfig->interface[i].altsetting[j].endpoint[k].bEndpointAddress)
-					return &dev->actconfig->interface[i].altsetting[j].endpoint[k];
+			for (k = 0; k < dev->actconfig->interface[i]
+				.altsetting[j].desc.bNumEndpoints; k++)
+				if (epnum == dev->actconfig->interface[i]
+						.altsetting[j].endpoint[k]
+						.desc.bEndpointAddress)
+					return &dev->actconfig->interface[i]
+						.altsetting[j].endpoint[k]
+						.desc;
 
 	return NULL;
 }
@@ -408,7 +415,7 @@ void usb_driver_release_interface(struct usb_driver *driver, struct usb_interfac
 const struct usb_device_id *
 usb_match_id(struct usb_interface *interface, const struct usb_device_id *id)
 {
-	struct usb_interface_descriptor *intf;
+	struct usb_host_interface *intf;
 	struct usb_device *dev;
 
 	/* proc_connectinfo in devio.c may call us with id == NULL. */
@@ -457,15 +464,15 @@ usb_match_id(struct usb_interface *interface, const struct usb_device_id *id)
 			continue;
 
 		if ((id->match_flags & USB_DEVICE_ID_MATCH_INT_CLASS) &&
-		    (id->bInterfaceClass != intf->bInterfaceClass))
+		    (id->bInterfaceClass != intf->desc.bInterfaceClass))
 			continue;
 
 		if ((id->match_flags & USB_DEVICE_ID_MATCH_INT_SUBCLASS) &&
-		    (id->bInterfaceSubClass != intf->bInterfaceSubClass))
+		    (id->bInterfaceSubClass != intf->desc.bInterfaceSubClass))
 			continue;
 
 		if ((id->match_flags & USB_DEVICE_ID_MATCH_INT_PROTOCOL) &&
-		    (id->bInterfaceProtocol != intf->bInterfaceProtocol))
+		    (id->bInterfaceProtocol != intf->desc.bInterfaceProtocol))
 			continue;
 
 		return id;
@@ -604,10 +611,10 @@ static int usb_hotplug (struct device *dev, char **envp, int num_envp,
 		 */
 		envp [i++] = scratch;
 		length += snprintf (scratch, buffer_size - length,
-				    "INTERFACE=%d/%d/%d",
-				    intf->altsetting[alt].bInterfaceClass,
-				    intf->altsetting[alt].bInterfaceSubClass,
-				    intf->altsetting[alt].bInterfaceProtocol);
+			    "INTERFACE=%d/%d/%d",
+			    intf->altsetting[alt].desc.bInterfaceClass,
+			    intf->altsetting[alt].desc.bInterfaceSubClass,
+			    intf->altsetting[alt].desc.bInterfaceProtocol);
 		if ((buffer_size - length <= 0) || (i >= num_envp))
 			return -ENOMEM;
 		++length;
@@ -792,7 +799,7 @@ void usb_disconnect(struct usb_device **pdev)
 
 	dbg ("unregistering interfaces on device %d", dev->devnum);
 	if (dev->actconfig) {
-		for (i = 0; i < dev->actconfig->bNumInterfaces; i++) {
+		for (i = 0; i < dev->actconfig->desc.bNumInterfaces; i++) {
 			struct usb_interface *interface = &dev->actconfig->interface[i];
 
 			/* remove this interface */
@@ -1026,7 +1033,7 @@ int usb_new_device(struct usb_device *dev, struct device *parent)
 	}
 
 	/* we set the default configuration here */
-	err = usb_set_configuration(dev, dev->config[0].bConfigurationValue);
+	err = usb_set_configuration(dev, dev->config[0].desc.bConfigurationValue);
 	if (err) {
 		err("failed to set device %d default configuration (error=%d)",
 			dev->devnum, err);
@@ -1065,16 +1072,17 @@ int usb_new_device(struct usb_device *dev, struct device *parent)
 
 	/* Register all of the interfaces for this device with the driver core.
 	 * Remember, interfaces get bound to drivers, not devices. */
-	for (i = 0; i < dev->actconfig->bNumInterfaces; i++) {
+	for (i = 0; i < dev->actconfig->desc.bNumInterfaces; i++) {
 		struct usb_interface *interface = &dev->actconfig->interface[i];
-		struct usb_interface_descriptor *desc = interface->altsetting;
+		struct usb_interface_descriptor *desc;
 
+		desc = &interface->altsetting [interface->act_altsetting].desc;
 		interface->dev.parent = &dev->dev;
 		interface->dev.driver = NULL;
 		interface->dev.bus = &usb_bus_type;
 		sprintf (&interface->dev.bus_id[0], "%d-%s:%d",
 			 dev->bus->busnum, dev->devpath,
-			 interface->altsetting->bInterfaceNumber);
+			 desc->bInterfaceNumber);
 		if (!desc->iInterface
 				|| usb_string (dev, desc->iInterface,
 					interface->dev.name,
@@ -1087,7 +1095,7 @@ int usb_new_device(struct usb_device *dev, struct device *parent)
 			sprintf (&interface->dev.name[0],
 				"usb-%s-%s interface %d",
 				dev->bus->bus_name, dev->devpath,
-				interface->altsetting->bInterfaceNumber);
+				desc->bInterfaceNumber);
 		}
 		dbg ("%s - registering %s", __FUNCTION__, interface->dev.bus_id);
 		device_register (&interface->dev);
diff --git a/drivers/usb/host/ehci-q.c b/drivers/usb/host/ehci-q.c
index 514b628c68f9..6f0d36dd2cae 100644
--- a/drivers/usb/host/ehci-q.c
+++ b/drivers/usb/host/ehci-q.c
@@ -463,7 +463,7 @@ qh_urb_transaction (
 			token ^= 0x0100;	/* "in" <--> "out"  */
 			token |= QTD_TOGGLE;	/* force DATA1 */
 		} else if (usb_pipebulk (urb->pipe)
-				&& (urb->transfer_flags & USB_ZERO_PACKET)
+				&& (urb->transfer_flags & URB_ZERO_PACKET)
 				&& !(urb->transfer_buffer_length % maxpacket)) {
 			one_more = 1;
 		}
diff --git a/drivers/usb/host/ehci-sched.c b/drivers/usb/host/ehci-sched.c
index d1d6346fe54f..62abde4c9908 100644
--- a/drivers/usb/host/ehci-sched.c
+++ b/drivers/usb/host/ehci-sched.c
@@ -738,7 +738,7 @@ static int get_iso_range (
 	}
 
 	/* explicit start frame? */
-	if (!(urb->transfer_flags & USB_ISO_ASAP)) {
+	if (!(urb->transfer_flags & URB_ISO_ASAP)) {
 		unsigned	temp;
 
 		/* sanity check: must be in range */
diff --git a/drivers/usb/host/hc_simple.c b/drivers/usb/host/hc_simple.c
index 570267835101..ce06daad48b8 100644
--- a/drivers/usb/host/hc_simple.c
+++ b/drivers/usb/host/hc_simple.c
@@ -219,7 +219,7 @@ static int hci_unlink_urb (struct urb * urb)
 	if (!list_empty (&urb->urb_list) && urb->status == -EINPROGRESS) {
 		/* URB active? */
 
-		if (urb->transfer_flags & (USB_ASYNC_UNLINK | USB_TIMEOUT_KILLED)) {
+		if (urb->transfer_flags & (URB_ASYNC_UNLINK | URB_TIMEOUT_KILLED)) {
 			/* asynchronous with callback */
 			/* relink the urb to the del list */
 			list_move (&urb->urb_list, &hci->del_list);
@@ -251,7 +251,7 @@ static int hci_unlink_urb (struct urb * urb)
 		/* hcd does not own URB but we keep the driver happy anyway */
 		spin_unlock_irqrestore (&usb_urb_lock, flags);
 
-		if (urb->complete && (urb->transfer_flags & USB_ASYNC_UNLINK)) {
+		if (urb->complete && (urb->transfer_flags & URB_ASYNC_UNLINK)) {
 			urb->status = -ENOENT;
 			urb->actual_length = 0;
 			urb->complete (urb);
@@ -388,7 +388,7 @@ static void qu_urb_timeout (unsigned long lurb)
 	struct urb *urb = (struct urb *) lurb;
 
 	DBGFUNC ("enter qu_urb_timeout\n");
-	urb->transfer_flags |= USB_TIMEOUT_KILLED;
+	urb->transfer_flags |= URB_TIMEOUT_KILLED;
 	hci_unlink_urb (urb);
 }
 #endif
@@ -472,7 +472,7 @@ static inline void qu_queue_active_urb (hci_t * hci, struct urb * urb, epd_t * e
 
 	case PIPE_BULK:
 		list_add (&urb->urb_list, &hci->bulk_list);
-		if ((urb->transfer_flags & USB_ZERO_PACKET)
+		if ((urb->transfer_flags & URB_ZERO_PACKET)
 		    && urb->transfer_buffer_length > 0
 		    &&
 		    ((urb->transfer_buffer_length %
@@ -523,7 +523,7 @@ static int qu_queue_urb (hci_t * hci, struct urb * urb)
 
 	/* for ISOC transfers calculate start frame index */
 
-	if (usb_pipeisoc (urb->pipe) && urb->transfer_flags & USB_ISO_ASAP) {
+	if (usb_pipeisoc (urb->pipe) && urb->transfer_flags & URB_ISO_ASAP) {
 		urb->start_frame = ((ed->pipe_head) ? (ed->last_iso + 1) : hci_get_current_frame_number (urb-> dev) + 1) & 0xffff;
 	}
 
diff --git a/drivers/usb/host/hc_sl811_rh.c b/drivers/usb/host/hc_sl811_rh.c
index e2ce511ebdb6..da6d30214359 100644
--- a/drivers/usb/host/hc_sl811_rh.c
+++ b/drivers/usb/host/hc_sl811_rh.c
@@ -534,7 +534,7 @@ static int rh_unlink_urb (struct urb * urb)
 		urb->hcpriv = NULL;
 		usb_put_dev (urb->dev);
 		urb->dev = NULL;
-		if (urb->transfer_flags & USB_ASYNC_UNLINK) {
+		if (urb->transfer_flags & URB_ASYNC_UNLINK) {
 			urb->status = -ECONNRESET;
 			if (urb->complete) {
 				urb->complete (urb);
diff --git a/drivers/usb/host/ohci-hcd.c b/drivers/usb/host/ohci-hcd.c
index f3e21ed3ad80..c86ecea5fdc6 100644
--- a/drivers/usb/host/ohci-hcd.c
+++ b/drivers/usb/host/ohci-hcd.c
@@ -29,7 +29,7 @@
  *
  * 2001/10/18 merge pmac cleanup (Benjamin Herrenschmidt) and bugfixes
  *	from post-2.4.5 patches.
- * 2001/09/20 USB_ZERO_PACKET support; hcca_dma portability, OPTi warning
+ * 2001/09/20 URB_ZERO_PACKET support; hcca_dma portability, OPTi warning
  * 2001/09/07 match PCI PM changes, errnos from Linus' tree
  * 2001/05/05 fork 2.4.5 version into "hcd" framework, cleanup, simplify;
  *	pbook pci quirks gone (please fix pbook pci sw!) (db)
@@ -185,7 +185,7 @@ static int ohci_urb_enqueue (
 			/* ... and maybe a zero length packet to wrap it up */
 			if (size == 0)
 				size++;
-			else if ((urb->transfer_flags & USB_ZERO_PACKET) != 0
+			else if ((urb->transfer_flags & URB_ZERO_PACKET) != 0
 				&& (urb->transfer_buffer_length
 					% usb_maxpacket (urb->dev, pipe,
 						usb_pipeout (pipe))) == 0)
@@ -239,7 +239,7 @@ static int ohci_urb_enqueue (
 			frame |= ed->branch;
 			urb->start_frame = frame;
 
-			/* yes, only USB_ISO_ASAP is supported, and
+			/* yes, only URB_ISO_ASAP is supported, and
 			 * urb->start_frame is never used as input.
 			 */
 		}
diff --git a/drivers/usb/host/ohci-mem.c b/drivers/usb/host/ohci-mem.c
index 2415f9c26554..11d4bac4a19c 100644
--- a/drivers/usb/host/ohci-mem.c
+++ b/drivers/usb/host/ohci-mem.c
@@ -176,13 +176,6 @@ td_alloc (struct ohci_hcd *hc, int mem_flags)
 			pci_pool_free (hc->td_cache, td, dma);
 			return NULL;
 		}
-		// DEBUG ONLY want to see if these tds are really getting
-		// allocated.  the last one in a page shouldn't be getting
-		// allocated during these tests!
-		if ((dma & 0x0fff) == 0x0fc0) {
-			dbg ("td = %p", td);
-			dump_stack ();
-		}
 	}
 	return td;
 }
diff --git a/drivers/usb/host/ohci-q.c b/drivers/usb/host/ohci-q.c
index 46b056c879fb..621841baef5f 100644
--- a/drivers/usb/host/ohci-q.c
+++ b/drivers/usb/host/ohci-q.c
@@ -575,7 +575,7 @@ static void td_submit_urb (
 			info |= TD_R;
 		td_fill (info, data, data_len, urb, cnt);
 		cnt++;
-		if ((urb->transfer_flags & USB_ZERO_PACKET)
+		if ((urb->transfer_flags & URB_ZERO_PACKET)
 				&& cnt < urb_priv->length) {
 			td_fill (info, 0, 0, urb, cnt);
 			cnt++;
@@ -736,42 +736,39 @@ ed_halted (struct ohci_hcd *ohci, struct td *td, int cc, struct td *rev)
 	 */
 	ed->hwINFO |= ED_SKIP;
 	wmb ();
-	td->ed->hwHeadP &= ~ED_H; 
+	ed->hwHeadP &= ~ED_H; 
 
+	/* put any later tds from this urb onto the donelist, after 'td',
+	 * order won't matter here: no errors, and nothing was transferred.
+	 * also patch the ed so it looks as if those tds completed normally.
+	 */
 	while (tmp != &ed->td_list) {
 		struct td	*next;
+		u32		info;
 
 		next = list_entry (tmp, struct td, td_list);
 		tmp = next->td_list.next;
 
-		/* move other tds from this urb to the donelist, after 'td'.
-		 * order won't matter here: no errors, nothing transferred.
-		 *
-		 * NOTE: this "knows" short control reads won't need fixup:
-		 * hc went from the (one) data TD to the status td. that'll
-		 * change if multi-td control DATA segments are supported,
-		 * and we want to send the status packet.
+		if (next->urb != urb)
+			break;
+
+		/* NOTE: if multi-td control DATA segments get supported,
+		 * this urb had one of them, this td wasn't the last td
+		 * in that segment (TD_R clear), this ed halted because
+		 * of a short read, _and_ URB_SHORT_NOT_OK is clear ...
+		 * then we need to leave the control STATUS packet queued
+		 * and clear ED_SKIP.
 		 */
-		if (next->urb == urb) {
-			u32	info = next->hwINFO;
-
-			info |= cpu_to_le32 (TD_DONE);
-			info &= ~cpu_to_le32 (TD_CC);
-			next->hwINFO = info;
-			next->next_dl_td = rev;	
-			rev = next;
-			continue;
-		}
+		info = next->hwINFO;
+		info |= cpu_to_le32 (TD_DONE);
+		info &= ~cpu_to_le32 (TD_CC);
+		next->hwINFO = info;
 
-		/* restart ed with first td of this next urb */
-		ed->hwHeadP = cpu_to_le32 (next->td_dma) | toggle;
-		tmp = 0;
-		break;
-	}
+		next->next_dl_td = rev;	
+		rev = next;
 
-	/* no urbs queued? then ED is empty. */
-	if (tmp)
-		ed->hwHeadP = cpu_to_le32 (ed->dummy->td_dma) | toggle;
+		ed->hwHeadP = next->hwNextTD | toggle;
+	}
 
 	/* help for troubleshooting: */
 	dbg ("urb %p usb-%s-%s ep-%d-%s cc %d --> status %d",
diff --git a/drivers/usb/host/uhci-hcd.c b/drivers/usb/host/uhci-hcd.c
index f23a9cf91a9e..c5d574ea947c 100644
--- a/drivers/usb/host/uhci-hcd.c
+++ b/drivers/usb/host/uhci-hcd.c
@@ -739,7 +739,7 @@ static void uhci_inc_fsbr(struct uhci_hcd *uhci, struct urb *urb)
 
 	spin_lock_irqsave(&uhci->frame_list_lock, flags);
 
-	if ((!(urb->transfer_flags & USB_NO_FSBR)) && !urbp->fsbr) {
+	if ((!(urb->transfer_flags & URB_NO_FSBR)) && !urbp->fsbr) {
 		urbp->fsbr = 1;
 		if (!uhci->fsbr++ && !uhci->fsbrtimeout)
 			uhci->skel_term_qh->link = cpu_to_le32(uhci->skel_hs_control_qh->dma_handle) | UHCI_PTR_QH;
@@ -755,7 +755,7 @@ static void uhci_dec_fsbr(struct uhci_hcd *uhci, struct urb *urb)
 
 	spin_lock_irqsave(&uhci->frame_list_lock, flags);
 
-	if ((!(urb->transfer_flags & USB_NO_FSBR)) && urbp->fsbr) {
+	if ((!(urb->transfer_flags & URB_NO_FSBR)) && urbp->fsbr) {
 		urbp->fsbr = 0;
 		if (!--uhci->fsbr)
 			uhci->fsbrtimeout = jiffies + FSBR_DELAY;
@@ -1124,13 +1124,13 @@ static int uhci_submit_common(struct uhci_hcd *uhci, struct urb *urb, struct urb
 	} while (len > 0);
 
 	/*
-	 * USB_ZERO_PACKET means adding a 0-length packet, if direction
+	 * URB_ZERO_PACKET means adding a 0-length packet, if direction
 	 * is OUT and the transfer_length was an exact multiple of maxsze,
 	 * hence (len = transfer_length - N * maxsze) == 0
 	 * however, if transfer_length == 0, the zero packet was already
 	 * prepared above.
 	 */
-	if (usb_pipeout(urb->pipe) && (urb->transfer_flags & USB_ZERO_PACKET) &&
+	if (usb_pipeout(urb->pipe) && (urb->transfer_flags & URB_ZERO_PACKET) &&
 	    !len && urb->transfer_buffer_length) {
 		td = uhci_alloc_td(uhci, urb->dev);
 		if (!td)
@@ -1306,7 +1306,7 @@ static int isochronous_find_start(struct uhci_hcd *uhci, struct urb *urb)
 
 	limits = isochronous_find_limits(uhci, urb, &start, &end);
 
-	if (urb->transfer_flags & USB_ISO_ASAP) {
+	if (urb->transfer_flags & URB_ISO_ASAP) {
 		if (limits) {
 			int curframe;
 
@@ -1752,7 +1752,7 @@ static void stall_callback(unsigned long ptr)
 
 		tmp = tmp->next;
 
-		u->transfer_flags |= USB_TIMEOUT_KILLED;
+		u->transfer_flags |= URB_TIMEOUT_KILLED;
 		uhci_urb_dequeue(hcd, u);
 	}
 
diff --git a/drivers/usb/image/hpusbscsi.c b/drivers/usb/image/hpusbscsi.c
index 543120598118..00bb26a79802 100644
--- a/drivers/usb/image/hpusbscsi.c
+++ b/drivers/usb/image/hpusbscsi.c
@@ -35,14 +35,14 @@ hpusbscsi_usb_probe (struct usb_interface *intf,
 {
 	struct hpusbscsi *new;
 	struct usb_device *dev = interface_to_usbdev (intf);
-	struct usb_interface_descriptor *altsetting =
+	struct usb_host_interface *altsetting =
 		&(intf->altsetting[0]);
 
 	int i, result;
 
 	/* basic check */
 
-	if (altsetting->bNumEndpoints != 3) {
+	if (altsetting->desc.bNumEndpoints != 3) {
 		printk (KERN_ERR "Wrong number of endpoints\n");
 		return -ENODEV;
 	}
@@ -76,34 +76,34 @@ hpusbscsi_usb_probe (struct usb_interface *intf,
 
 	/* finding endpoints */
 
-	for (i = 0; i < altsetting->bNumEndpoints; i++) {
+	for (i = 0; i < altsetting->desc.bNumEndpoints; i++) {
 		if (
-		    (altsetting->endpoint[i].
+		    (altsetting->endpoint[i].desc.
 		     bmAttributes & USB_ENDPOINT_XFERTYPE_MASK) ==
 		    USB_ENDPOINT_XFER_BULK) {
-			if (altsetting->endpoint[i].
+			if (altsetting->endpoint[i].desc.
 			    bEndpointAddress & USB_DIR_IN) {
 				new->ep_in =
-					altsetting->endpoint[i].
+					altsetting->endpoint[i].desc.
 					bEndpointAddress &
 					USB_ENDPOINT_NUMBER_MASK;
 			} else {
 				new->ep_out =
-					altsetting->endpoint[i].
+					altsetting->endpoint[i].desc.
 					bEndpointAddress &
 					USB_ENDPOINT_NUMBER_MASK;
 			}
 		} else {
 			new->ep_int =
-				altsetting->endpoint[i].
+				altsetting->endpoint[i].desc.
 				bEndpointAddress & USB_ENDPOINT_NUMBER_MASK;
-			new->interrupt_interval= altsetting->endpoint[i].bInterval;
+			new->interrupt_interval= altsetting->endpoint[i].desc.bInterval;
 		}
 	}
 
 	/* USB initialisation magic for the simple case */
 
-	result = usb_set_interface (dev, altsetting->bInterfaceNumber, 0);
+	result = usb_set_interface (dev, altsetting->desc.bInterfaceNumber, 0);
 
 	switch (result) {
 	case 0:		/* no error */
@@ -244,7 +244,7 @@ hpusbscsi_scsi_detect (struct SHT *sht)
 	sht->proc_dir = NULL;
 
 	/* build and submit an interrupt URB for status byte handling */
- 	FILL_INT_URB(desc->controlurb,
+ 	usb_fill_int_urb(desc->controlurb,
 			desc->dev,
 			usb_rcvintpipe(desc->dev,desc->ep_int),
 			&desc->scsi_state_byte,
@@ -321,7 +321,7 @@ static int hpusbscsi_scsi_queuecommand (Scsi_Cmnd *srb, scsi_callback callback)
 	TRACE_STATE;
 
 	/* We prepare the urb for writing out the scsi command */
-	FILL_BULK_URB(
+	usb_fill_bulk_urb(
 		hpusbscsi->dataurb,
 		hpusbscsi->dev,
 		usb_sndbulkpipe(hpusbscsi->dev,hpusbscsi->ep_out),
@@ -477,7 +477,7 @@ static void scatter_gather_callback(struct urb *u)
 		hpusbscsi->state = HP_STATE_WORKING;
 	TRACE_STATE;
 
-        FILL_BULK_URB(
+        usb_fill_bulk_urb(
                 u,
                 hpusbscsi->dev,
                 hpusbscsi->current_data_pipe,
@@ -531,7 +531,7 @@ static void simple_payload_callback (struct urb *u)
 		return;
         }
 
-	FILL_BULK_URB(
+	usb_fill_bulk_urb(
 		u,
 		hpusbscsi->dev,
 		hpusbscsi->current_data_pipe,
@@ -562,7 +562,7 @@ static void request_sense_callback (struct urb *u)
 		return;
         }
 
-	FILL_BULK_URB(
+	usb_fill_bulk_urb(
 		u,
 		hpusbscsi->dev,
 		hpusbscsi->current_data_pipe,
@@ -582,7 +582,7 @@ static void request_sense_callback (struct urb *u)
 
 static void issue_request_sense (struct hpusbscsi *hpusbscsi)
 {
-	FILL_BULK_URB(
+	usb_fill_bulk_urb(
 		hpusbscsi->dataurb,
 		hpusbscsi->dev,
 		usb_sndbulkpipe(hpusbscsi->dev, hpusbscsi->ep_out),
diff --git a/drivers/usb/image/mdc800.c b/drivers/usb/image/mdc800.c
index 12aafe9b9eb7..571c72615cab 100644
--- a/drivers/usb/image/mdc800.c
+++ b/drivers/usb/image/mdc800.c
@@ -410,7 +410,7 @@ static int mdc800_usb_probe (struct usb_interface *intf,
 			       const struct usb_device_id *id)
 {
 	int i,j;
-	struct usb_interface_descriptor	*intf_desc;
+	struct usb_host_interface *intf_desc;
 	struct usb_device *dev = interface_to_usbdev (intf);
 	int irq_interval=0;
 	int retval;
@@ -432,10 +432,10 @@ static int mdc800_usb_probe (struct usb_interface *intf,
 	intf_desc = &intf->altsetting[0];
 
 	if (
-			( intf_desc->bInterfaceClass != 0xff )
-		||	( intf_desc->bInterfaceSubClass != 0 )
-		|| ( intf_desc->bInterfaceProtocol != 0 )
-		|| ( intf_desc->bNumEndpoints != 4)
+			( intf_desc->desc.bInterfaceClass != 0xff )
+		||	( intf_desc->desc.bInterfaceSubClass != 0 )
+		|| ( intf_desc->desc.bInterfaceProtocol != 0 )
+		|| ( intf_desc->desc.bNumEndpoints != 4)
 	)
 	{
 		err ("probe fails -> wrong Interface");
@@ -448,12 +448,12 @@ static int mdc800_usb_probe (struct usb_interface *intf,
 		mdc800->endpoint[i]=-1;
 		for (j=0; j<4; j++)
 		{
-			if (mdc800_endpoint_equals (&intf_desc->endpoint [j],&mdc800_ed [i]))
+			if (mdc800_endpoint_equals (&intf_desc->endpoint [j].desc,&mdc800_ed [i]))
 			{
-				mdc800->endpoint[i]=intf_desc->endpoint [j].bEndpointAddress ;
+				mdc800->endpoint[i]=intf_desc->endpoint [j].desc.bEndpointAddress ;
 				if (i==1)
 				{
-					irq_interval=intf_desc->endpoint [j].bInterval;
+					irq_interval=intf_desc->endpoint [j].desc.bInterval;
 				}
 
 				continue;
@@ -468,7 +468,7 @@ static int mdc800_usb_probe (struct usb_interface *intf,
 
 
 	usb_driver_claim_interface (&mdc800_usb_driver, intf, mdc800);
-	if (usb_set_interface (dev, intf_desc->bInterfaceNumber, 0) < 0)
+	if (usb_set_interface (dev, intf_desc->desc.bInterfaceNumber, 0) < 0)
 	{
 		err ("MDC800 Configuration fails.");
 		return -ENODEV;
@@ -488,7 +488,7 @@ static int mdc800_usb_probe (struct usb_interface *intf,
 	mdc800->open=0;
 
 	/* Setup URB Structs */
-	FILL_INT_URB (
+	usb_fill_int_urb (
 		mdc800->irq_urb,
 		mdc800->dev,
 		usb_rcvintpipe (mdc800->dev,mdc800->endpoint [1]),
@@ -499,7 +499,7 @@ static int mdc800_usb_probe (struct usb_interface *intf,
 		irq_interval
 	);
 
-	FILL_BULK_URB (
+	usb_fill_bulk_urb (
 		mdc800->write_urb,
 		mdc800->dev,
 		usb_sndbulkpipe (mdc800->dev, mdc800->endpoint[0]),
@@ -509,7 +509,7 @@ static int mdc800_usb_probe (struct usb_interface *intf,
 		mdc800
 	);
 
-	FILL_BULK_URB (
+	usb_fill_bulk_urb (
 		mdc800->download_urb,
 		mdc800->dev,
 		usb_rcvbulkpipe (mdc800->dev, mdc800->endpoint [3]),
diff --git a/drivers/usb/image/microtek.c b/drivers/usb/image/microtek.c
index b4c63efc381a..9d9cfe6f7f60 100644
--- a/drivers/usb/image/microtek.c
+++ b/drivers/usb/image/microtek.c
@@ -487,7 +487,7 @@ void mts_int_submit_urb (struct urb* transfer,
 
 	MTS_INT_INIT();
 
-	FILL_BULK_URB(transfer,
+	usb_fill_bulk_urb(transfer,
 		      context->instance->usb_dev,
 		      pipe,
 		      data,
@@ -715,7 +715,7 @@ int mts_scsi_queuecommand( Scsi_Cmnd *srb, mts_scsi_cmnd_callback callback )
 	}
 
 	
-	FILL_BULK_URB(desc->urb,
+	usb_fill_bulk_urb(desc->urb,
 		      desc->usb_dev,
 		      usb_sndbulkpipe(desc->usb_dev,desc->ep_out),
 		      srb->cmnd,
@@ -851,7 +851,7 @@ static int mts_usb_probe (struct usb_interface *intf,
 	struct usb_device *dev = interface_to_usbdev (intf);
 
 	/* the altsettting 0 on the interface we're probing */
-	struct usb_interface_descriptor *altsetting;
+	struct usb_host_interface *altsetting;
 
 	MTS_DEBUG_GOT_HERE();
 	MTS_DEBUG( "usb-device descriptor at %x\n", (int)dev );
@@ -877,23 +877,23 @@ static int mts_usb_probe (struct usb_interface *intf,
 
 	/* Check if the config is sane */
 
-	if ( altsetting->bNumEndpoints != MTS_EP_TOTAL ) {
+	if ( altsetting->desc.bNumEndpoints != MTS_EP_TOTAL ) {
 		MTS_WARNING( "expecting %d got %d endpoints! Bailing out.\n",
-			     (int)MTS_EP_TOTAL, (int)altsetting->bNumEndpoints );
+			     (int)MTS_EP_TOTAL, (int)altsetting->desc.bNumEndpoints );
 		return -ENODEV;
 	}
 
-	for( i = 0; i < altsetting->bNumEndpoints; i++ ) {
-		if ((altsetting->endpoint[i].bmAttributes &
+	for( i = 0; i < altsetting->desc.bNumEndpoints; i++ ) {
+		if ((altsetting->endpoint[i].desc.bmAttributes &
 		     USB_ENDPOINT_XFERTYPE_MASK) != USB_ENDPOINT_XFER_BULK) {
 
 			MTS_WARNING( "can only deal with bulk endpoints; endpoint %d is not bulk.\n",
-			     (int)altsetting->endpoint[i].bEndpointAddress );
+			     (int)altsetting->endpoint[i].desc.bEndpointAddress );
 		} else {
-			if (altsetting->endpoint[i].bEndpointAddress &
+			if (altsetting->endpoint[i].desc.bEndpointAddress &
 			    USB_DIR_IN)
 				*ep_in_current++
-					= altsetting->endpoint[i].bEndpointAddress &
+					= altsetting->endpoint[i].desc.bEndpointAddress &
 					USB_ENDPOINT_NUMBER_MASK;
 			else {
 				if ( ep_out != -1 ) {
@@ -901,7 +901,7 @@ static int mts_usb_probe (struct usb_interface *intf,
 					return -ENODEV;
 				}
 
-				ep_out = altsetting->endpoint[i].bEndpointAddress &
+				ep_out = altsetting->endpoint[i].desc.bEndpointAddress &
 					USB_ENDPOINT_NUMBER_MASK;
 			}
 		}
@@ -914,7 +914,7 @@ static int mts_usb_probe (struct usb_interface *intf,
 		return -ENODEV;
 	}
 
-	result = usb_set_interface(dev, altsetting->bInterfaceNumber, 0);
+	result = usb_set_interface(dev, altsetting->desc.bInterfaceNumber, 0);
 
 	MTS_DEBUG("usb_set_interface returned %d.\n",result);
 	switch( result )
diff --git a/drivers/usb/image/scanner.c b/drivers/usb/image/scanner.c
index 0e0ae383acd5..bc7affeedff6 100644
--- a/drivers/usb/image/scanner.c
+++ b/drivers/usb/image/scanner.c
@@ -839,7 +839,7 @@ probe_scanner(struct usb_interface *intf,
 {
 	struct usb_device *dev = interface_to_usbdev (intf);
 	struct scn_usb_data *scn;
-	struct usb_interface_descriptor *interface;
+	struct usb_host_interface *interface;
 	struct usb_endpoint_descriptor *endpoint;
 
 	int ep_cnt;
@@ -905,13 +905,13 @@ probe_scanner(struct usb_interface *intf,
 		return -ENODEV;
 	}
 
-	if (dev->config[0].bNumInterfaces != 1) {
+	if (dev->config[0].desc.bNumInterfaces != 1) {
 		info("probe_scanner: Only one device interface is supported.");
 		return -ENODEV;
 	}
 
 	interface = intf->altsetting;
-	endpoint = interface->endpoint;
+	endpoint = &interface->endpoint[0].desc;
 
 /*
  * Start checking for two bulk endpoints OR two bulk endpoints *and* one
@@ -919,16 +919,16 @@ probe_scanner(struct usb_interface *intf,
  * setup the handler. FIXME: This is a future enhancement...
  */
 
-	dbg("probe_scanner: Number of Endpoints:%d", (int) interface->bNumEndpoints);
+	dbg("probe_scanner: Number of Endpoints:%d", (int) interface->desc.bNumEndpoints);
 
-	if ((interface->bNumEndpoints != 2) && (interface->bNumEndpoints != 3)) {
+	if ((interface->desc.bNumEndpoints != 2) && (interface->desc.bNumEndpoints != 3)) {
 		info("probe_scanner: Only two or three endpoints supported.");
 		return -ENODEV;
 	}
 
 	ep_cnt = have_bulk_in = have_bulk_out = have_intr = 0;
 
-	while (ep_cnt < interface->bNumEndpoints) {
+	while (ep_cnt < interface->desc.bNumEndpoints) {
 
 		if (!have_bulk_in && IS_EP_BULK_IN(endpoint[ep_cnt])) {
 			ep_cnt++;
@@ -960,7 +960,7 @@ probe_scanner(struct usb_interface *intf,
  * should have.
  */
 
-	switch(interface->bNumEndpoints) {
+	switch(interface->desc.bNumEndpoints) {
 	case 2:
 		if (!have_bulk_in || !have_bulk_out) {
 			info("probe_scanner: Two bulk endpoints required.");
@@ -1024,7 +1024,7 @@ probe_scanner(struct usb_interface *intf,
 /* Ok, if we detected an interrupt EP, setup a handler for it */
 	if (have_intr) {
 		dbg("probe_scanner(%d): Configuring IRQ handler for intr EP:%d", scn_minor, have_intr);
-		FILL_INT_URB(scn->scn_irq, dev,
+		usb_fill_int_urb(scn->scn_irq, dev,
 			     usb_rcvintpipe(dev, have_intr),
 			     &scn->button, 1, irq_scanner, scn,
 			     // endpoint[(int)have_intr].bInterval);
diff --git a/drivers/usb/input/aiptek.c b/drivers/usb/input/aiptek.c
index e558134bae9d..fe5ccf692f2b 100644
--- a/drivers/usb/input/aiptek.c
+++ b/drivers/usb/input/aiptek.c
@@ -313,7 +313,7 @@ aiptek_probe(struct usb_interface *intf,
 	aiptek->dev.id.version = dev->descriptor.bcdDevice;
 	aiptek->usbdev = dev;
 
-	endpoint = intf->altsetting[0].endpoint + 0;
+	endpoint = &intf->altsetting[0].endpoint[0].desc;
 
 	if (aiptek->features->pktlen > 10)
 		BUG();
diff --git a/drivers/usb/input/hid-core.c b/drivers/usb/input/hid-core.c
index 7331d93da09a..2fa6ce372ab2 100644
--- a/drivers/usb/input/hid-core.c
+++ b/drivers/usb/input/hid-core.c
@@ -1386,7 +1386,7 @@ static void hid_free_buffers(struct usb_device *dev, struct hid_device *hid)
 
 static struct hid_device *usb_hid_configure(struct usb_interface *intf)
 {
-	struct usb_interface_descriptor *interface = intf->altsetting + intf->act_altsetting;
+	struct usb_host_interface *interface = intf->altsetting + intf->act_altsetting;
 	struct usb_device *dev = interface_to_usbdev (intf);
 	struct hid_descriptor *hdesc;
 	struct hid_device *hid;
@@ -1402,7 +1402,7 @@ static struct hid_device *usb_hid_configure(struct usb_interface *intf)
 	if (quirks & HID_QUIRK_IGNORE)
 		return NULL;
 
-	if (usb_get_extra_descriptor(interface, HID_DT_HID, &hdesc) && ((!interface->bNumEndpoints) ||
+	if (usb_get_extra_descriptor(interface, HID_DT_HID, &hdesc) && ((!interface->desc.bNumEndpoints) ||
 		usb_get_extra_descriptor(&interface->endpoint[0], HID_DT_HID, &hdesc))) {
 			dbg("class descriptor not present\n");
 			return NULL;
@@ -1422,7 +1422,7 @@ static struct hid_device *usb_hid_configure(struct usb_interface *intf)
 		return NULL;
 	}
 
-	if ((n = hid_get_class_descriptor(dev, interface->bInterfaceNumber, HID_DT_REPORT, rdesc, rsize)) < 0) {
+	if ((n = hid_get_class_descriptor(dev, interface->desc.bInterfaceNumber, HID_DT_REPORT, rdesc, rsize)) < 0) {
 		dbg("reading report descriptor failed");
 		kfree(rdesc);
 		return NULL;
@@ -1449,11 +1449,12 @@ static struct hid_device *usb_hid_configure(struct usb_interface *intf)
 		goto fail;
 	}
 
-	for (n = 0; n < interface->bNumEndpoints; n++) {
+	for (n = 0; n < interface->desc.bNumEndpoints; n++) {
 
-		struct usb_endpoint_descriptor *endpoint = &interface->endpoint[n];
+		struct usb_endpoint_descriptor *endpoint;
 		int pipe;
 
+		endpoint = &interface->endpoint[n].desc;
 		if ((endpoint->bmAttributes & 3) != 3)		/* Not an interrupt endpoint */
 			continue;
 
@@ -1493,7 +1494,7 @@ static struct hid_device *usb_hid_configure(struct usb_interface *intf)
 	hid->version = le16_to_cpu(hdesc->bcdHID);
 	hid->country = hdesc->bCountryCode;
 	hid->dev = dev;
-	hid->ifnum = interface->bInterfaceNumber;
+	hid->ifnum = interface->desc.bInterfaceNumber;
 
 	hid->name[0] = 0;
 
@@ -1510,7 +1511,8 @@ static struct hid_device *usb_hid_configure(struct usb_interface *intf)
 		snprintf(hid->name, 128, "%04x:%04x", dev->descriptor.idVendor, dev->descriptor.idProduct);
 
 	usb_make_path(dev, buf, 64);
-	snprintf(hid->phys, 64, "%s/input%d", buf, intf->altsetting[0].bInterfaceNumber);
+	snprintf(hid->phys, 64, "%s/input%d", buf,
+			intf->altsetting[0].desc.bInterfaceNumber);
 
 	if (usb_string(dev, dev->descriptor.iSerialNumber, hid->uniq, 64) <= 0)
 		hid->uniq[0] = 0;
diff --git a/drivers/usb/input/powermate.c b/drivers/usb/input/powermate.c
index 47fb5fd3c852..6e0c7557678d 100644
--- a/drivers/usb/input/powermate.c
+++ b/drivers/usb/input/powermate.c
@@ -290,14 +290,14 @@ static void powermate_free_buffers(struct usb_device *udev, struct powermate_dev
 static int powermate_probe(struct usb_interface *intf, const struct usb_device_id *id)
 {
 	struct usb_device *udev = interface_to_usbdev (intf);
-	struct usb_interface_descriptor *interface;
+	struct usb_host_interface *interface;
 	struct usb_endpoint_descriptor *endpoint;
 	struct powermate_device *pm;
 	int pipe, maxp;
 	char path[64];
 
 	interface = intf->altsetting + 0;
-	endpoint = interface->endpoint + 0;
+	endpoint = &interface->endpoint[0].desc;
 	if (!(endpoint->bEndpointAddress & 0x80))
 		return -EIO;
 	if ((endpoint->bmAttributes & 3) != 3)
@@ -305,7 +305,7 @@ static int powermate_probe(struct usb_interface *intf, const struct usb_device_i
 
 	usb_control_msg(udev, usb_sndctrlpipe(udev, 0),
 		0x0a, USB_TYPE_CLASS | USB_RECIP_INTERFACE,
-		0, interface->bInterfaceNumber, NULL, 0,
+		0, interface->desc.bInterfaceNumber, NULL, 0,
 		HZ * USB_CTRL_SET_TIMEOUT);
 
 	if (!(pm = kmalloc(sizeof(struct powermate_device), GFP_KERNEL)))
diff --git a/drivers/usb/input/usbkbd.c b/drivers/usb/input/usbkbd.c
index a92742d3fa5e..2b5ebb8c4a3f 100644
--- a/drivers/usb/input/usbkbd.c
+++ b/drivers/usb/input/usbkbd.c
@@ -228,7 +228,7 @@ static int usb_kbd_probe(struct usb_interface *iface,
 			 const struct usb_device_id *id)
 {
 	struct usb_device * dev = interface_to_usbdev(iface);
-	struct usb_interface_descriptor *interface;
+	struct usb_host_interface *interface;
 	struct usb_endpoint_descriptor *endpoint;
 	struct usb_kbd *kbd;
 	int i, pipe, maxp;
@@ -237,10 +237,10 @@ static int usb_kbd_probe(struct usb_interface *iface,
 
 	interface = &iface->altsetting[iface->act_altsetting];
 
-	if (interface->bNumEndpoints != 1)
+	if (interface->desc.bNumEndpoints != 1)
 		return -ENODEV;
 
-	endpoint = interface->endpoint + 0;
+	endpoint = &interface->endpoint[0].desc;
 	if (!(endpoint->bEndpointAddress & 0x80))
 		return -ENODEV;
 	if ((endpoint->bmAttributes & 3) != 3)
@@ -282,7 +282,7 @@ static int usb_kbd_probe(struct usb_interface *iface,
 	kbd->cr->bRequestType = USB_TYPE_CLASS | USB_RECIP_INTERFACE;
 	kbd->cr->bRequest = 0x09;
 	kbd->cr->wValue = cpu_to_le16(0x200);
-	kbd->cr->wIndex = cpu_to_le16(interface->bInterfaceNumber);
+	kbd->cr->wIndex = cpu_to_le16(interface->desc.bInterfaceNumber);
 	kbd->cr->wLength = cpu_to_le16(1);
 
 	usb_make_path(dev, path, 64);
diff --git a/drivers/usb/input/usbmouse.c b/drivers/usb/input/usbmouse.c
index 5728136ca14d..15a88e2e11e5 100644
--- a/drivers/usb/input/usbmouse.c
+++ b/drivers/usb/input/usbmouse.c
@@ -121,7 +121,7 @@ static void usb_mouse_close(struct input_dev *dev)
 static int usb_mouse_probe(struct usb_interface * intf, const struct usb_device_id * id)
 {
 	struct usb_device * dev = interface_to_usbdev(intf);
-	struct usb_interface_descriptor *interface;
+	struct usb_host_interface *interface;
 	struct usb_endpoint_descriptor *endpoint;
 	struct usb_mouse *mouse;
 	int pipe, maxp;
@@ -130,10 +130,10 @@ static int usb_mouse_probe(struct usb_interface * intf, const struct usb_device_
 
 	interface = &intf->altsetting[intf->act_altsetting];
 
-	if (interface->bNumEndpoints != 1) 
+	if (interface->desc.bNumEndpoints != 1) 
 		return -ENODEV;
 
-	endpoint = interface->endpoint + 0;
+	endpoint = &interface->endpoint[0].desc;
 	if (!(endpoint->bEndpointAddress & 0x80)) 
 		return -ENODEV;
 	if ((endpoint->bmAttributes & 3) != 3) 
diff --git a/drivers/usb/input/wacom.c b/drivers/usb/input/wacom.c
index 2f5ef39b4630..5efae4d7b0ab 100644
--- a/drivers/usb/input/wacom.c
+++ b/drivers/usb/input/wacom.c
@@ -561,7 +561,7 @@ static int wacom_probe(struct usb_interface *intf, const struct usb_device_id *i
 	wacom->dev.id.version = dev->descriptor.bcdDevice;
 	wacom->usbdev = dev;
 
-	endpoint = intf->altsetting[0].endpoint + 0;
+	endpoint = &intf->altsetting[0].endpoint[0].desc;
 
 	if (wacom->features->pktlen > 10)
 		BUG();
diff --git a/drivers/usb/input/xpad.c b/drivers/usb/input/xpad.c
index e3eab2783fd9..1f41067695fe 100644
--- a/drivers/usb/input/xpad.c
+++ b/drivers/usb/input/xpad.c
@@ -249,7 +249,7 @@ static int xpad_probe(struct usb_interface *intf, const struct usb_device_id *id
 		return -ENOMEM;
         }
 	
-	ep_irq_in = intf->altsetting[0].endpoint + 0;
+	ep_irq_in = &intf->altsetting[0].endpoint[0].desc;
 	
 	usb_fill_int_urb(xpad->irq_in, udev,
 			 usb_rcvintpipe(udev, ep_irq_in->bEndpointAddress),
diff --git a/drivers/usb/media/dabusb.c b/drivers/usb/media/dabusb.c
index eaa447b2cfaf..ad0c2e2c86a5 100644
--- a/drivers/usb/media/dabusb.c
+++ b/drivers/usb/media/dabusb.c
@@ -251,7 +251,7 @@ static int dabusb_alloc_buffers (pdabusb_t s)
 		b->purb->context = b;
 		b->purb->dev = s->usbdev;
 		b->purb->pipe = pipe;
-		b->purb->transfer_flags = USB_ISO_ASAP;
+		b->purb->transfer_flags = URB_ISO_ASAP;
 
 		for (i = 0; i < packets; i++) {
 			b->purb->iso_frame_desc[i].offset = i * pipesize;
@@ -728,7 +728,7 @@ static int dabusb_probe (struct usb_interface *intf,
 	if (usbdev->descriptor.bNumConfigurations != 1)
 		return -ENODEV;
 
-	if (intf->altsetting->bInterfaceNumber != _DABUSB_IF && usbdev->descriptor.idProduct == 0x9999)
+	if (intf->altsetting->desc.bInterfaceNumber != _DABUSB_IF && usbdev->descriptor.idProduct == 0x9999)
 		return -ENODEV;
 
 	retval = usb_register_dev (&dabusb_fops, DABUSB_MINOR, 1, &devnum);
@@ -742,7 +742,7 @@ static int dabusb_probe (struct usb_interface *intf,
 	s->usbdev = usbdev;
 	s->devnum = devnum;
 
-	if (usb_set_configuration (usbdev, usbdev->config[0].bConfigurationValue) < 0) {
+	if (usb_set_configuration (usbdev, usbdev->config[0].desc.bConfigurationValue) < 0) {
 		err("set_configuration failed");
 		goto reject;
 	}
diff --git a/drivers/usb/media/ibmcam.c b/drivers/usb/media/ibmcam.c
index 74b1c5303374..1630ba673fde 100644
--- a/drivers/usb/media/ibmcam.c
+++ b/drivers/usb/media/ibmcam.c
@@ -3662,7 +3662,7 @@ static int ibmcam_probe(struct usb_interface *intf, const struct usb_device_id *
 	struct uvd *uvd = NULL;
 	int i, nas, model=0, canvasX=0, canvasY=0;
 	int actInterface=-1, inactInterface=-1, maxPS=0;
-	__u8 ifnum = intf->altsetting->bInterfaceNumber;
+	__u8 ifnum = intf->altsetting->desc.bInterfaceNumber;
 	unsigned char video_ep = 0;
 
 	if (debug >= 1)
@@ -3740,16 +3740,16 @@ static int ibmcam_probe(struct usb_interface *intf, const struct usb_device_id *
 	}
 	/* Validate all alternate settings */
 	for (i=0; i < nas; i++) {
-		const struct usb_interface_descriptor *interface;
+		const struct usb_host_interface *interface;
 		const struct usb_endpoint_descriptor *endpoint;
 
 		interface = &dev->actconfig->interface[ifnum].altsetting[i];
-		if (interface->bNumEndpoints != 1) {
+		if (interface->desc.bNumEndpoints != 1) {
 			err("Interface %d. has %u. endpoints!",
-			    ifnum, (unsigned)(interface->bNumEndpoints));
+			    ifnum, (unsigned)(interface->desc.bNumEndpoints));
 			return -ENODEV;
 		}
-		endpoint = &interface->endpoint[0];
+		endpoint = &interface->endpoint[0].desc;
 		if (video_ep == 0)
 			video_ep = endpoint->bEndpointAddress;
 		else if (video_ep != endpoint->bEndpointAddress) {
diff --git a/drivers/usb/media/konicawc.c b/drivers/usb/media/konicawc.c
index 89825b4ff9f7..190743d30b2f 100644
--- a/drivers/usb/media/konicawc.c
+++ b/drivers/usb/media/konicawc.c
@@ -381,10 +381,10 @@ static int konicawc_start_data(struct uvd *uvd)
 	int i, errFlag;
 	struct konicawc *cam = (struct konicawc *)uvd->user_data;
 	int pktsz;
-	struct usb_interface_descriptor *interface;
+	struct usb_host_interface *interface;
 
 	interface = &dev->actconfig->interface[uvd->iface].altsetting[spd_to_iface[cam->speed]];
-	pktsz = interface->endpoint[1].wMaxPacketSize;
+	pktsz = interface->endpoint[1].desc.wMaxPacketSize;
 	DEBUG(1, "pktsz = %d", pktsz);
 	if (!CAMERA_IS_OPERATIONAL(uvd)) {
 		err("Camera is not operational");
@@ -408,7 +408,7 @@ static int konicawc_start_data(struct uvd *uvd)
 		urb->context = uvd;
 		urb->pipe = usb_rcvisocpipe(dev, uvd->video_endp);
 		urb->interval = 1;
-		urb->transfer_flags = USB_ISO_ASAP;
+		urb->transfer_flags = URB_ISO_ASAP;
 		urb->transfer_buffer = uvd->sbuf[i].data;
 		urb->complete = konicawc_isoc_irq;
 		urb->number_of_packets = FRAMES_PER_DESC;
@@ -423,7 +423,7 @@ static int konicawc_start_data(struct uvd *uvd)
 		urb->context = uvd;
 		urb->pipe = usb_rcvisocpipe(dev, uvd->video_endp-1);
 		urb->interval = 1;
-		urb->transfer_flags = USB_ISO_ASAP;
+		urb->transfer_flags = URB_ISO_ASAP;
 		urb->transfer_buffer = cam->sts_buf[i];
 		urb->complete = konicawc_isoc_irq;
 		urb->number_of_packets = FRAMES_PER_DESC;
@@ -742,17 +742,17 @@ static int konicawc_probe(struct usb_interface *intf, const struct usb_device_id
 	}
 	/* Validate all alternate settings */
 	for (i=0; i < nas; i++) {
-		const struct usb_interface_descriptor *interface;
+		const struct usb_host_interface *interface;
 		const struct usb_endpoint_descriptor *endpoint;
 
 		interface = &intf->altsetting[i];
-		if (interface->bNumEndpoints != 2) {
+		if (interface->desc.bNumEndpoints != 2) {
 			err("Interface %d. has %u. endpoints!",
-			    interface->bInterfaceNumber,
-			    (unsigned)(interface->bNumEndpoints));
+			    interface->desc.bInterfaceNumber,
+			    (unsigned)(interface->desc.bNumEndpoints));
 			return -ENODEV;
 		}
-		endpoint = &interface->endpoint[1];
+		endpoint = &interface->endpoint[1].desc;
 		DEBUG(1, "found endpoint: addr: 0x%2.2x maxps = 0x%4.4x",
 		    endpoint->bEndpointAddress, endpoint->wMaxPacketSize);
 		if (video_ep == 0)
@@ -763,12 +763,12 @@ static int konicawc_probe(struct usb_interface *intf, const struct usb_device_id
 		}
 		if ((endpoint->bmAttributes & 0x03) != 0x01) {
 			err("Interface %d. has non-ISO endpoint!",
-			    interface->bInterfaceNumber);
+			    interface->desc.bInterfaceNumber);
 			return -ENODEV;
 		}
 		if ((endpoint->bEndpointAddress & 0x80) == 0) {
 			err("Interface %d. has ISO OUT endpoint!",
-			    interface->bInterfaceNumber);
+			    interface->desc.bInterfaceNumber);
 			return -ENODEV;
 		}
 		if (endpoint->wMaxPacketSize == 0) {
@@ -819,7 +819,7 @@ static int konicawc_probe(struct usb_interface *intf, const struct usb_device_id
 		uvd->flags = 0;
 		uvd->debug = debug;
 		uvd->dev = dev;
-		uvd->iface = intf->altsetting->bInterfaceNumber;
+		uvd->iface = intf->altsetting->desc.bInterfaceNumber;
 		uvd->ifaceAltInactive = inactInterface;
 		uvd->ifaceAltActive = actInterface;
 		uvd->video_endp = video_ep;
diff --git a/drivers/usb/media/ov511.c b/drivers/usb/media/ov511.c
index f968afc3d5c6..0f8f81143f61 100644
--- a/drivers/usb/media/ov511.c
+++ b/drivers/usb/media/ov511.c
@@ -3949,7 +3949,7 @@ ov51x_init_isoc(struct usb_ov511 *ov)
 		urb->dev = ov->dev;
 		urb->context = &ov->sbuf[n];
 		urb->pipe = usb_rcvisocpipe(ov->dev, OV511_ENDPOINT_ADDRESS);
-		urb->transfer_flags = USB_ISO_ASAP;
+		urb->transfer_flags = URB_ISO_ASAP;
 		urb->transfer_buffer = ov->sbuf[n].data;
 		urb->complete = ov51x_isoc_irq;
 		urb->number_of_packets = FRAMES_PER_DESC;
@@ -5988,7 +5988,7 @@ ov518_configure(struct usb_ov511 *ov)
 	if (ov->bridge == BRG_OV518)
 	{
 		struct usb_interface *ifp = &ov->dev->config[0].interface[0];
-		__u16 mxps = ifp->altsetting[7].endpoint[0].wMaxPacketSize;
+		__u16 mxps = ifp->altsetting[7].endpoint[0].desc.wMaxPacketSize;
 
 		/* Some OV518s have packet numbering by default, some don't */
 		if (mxps == 897)
@@ -6083,7 +6083,7 @@ ov51x_probe(struct usb_interface *intf,
 	if (dev->descriptor.bNumConfigurations != 1)
 		return -ENODEV;
 
-	interface = &intf->altsetting[0];
+	interface = &intf->altsetting[0].desc;
 
 	/* Checking vendor/product should be enough, but what the hell */
 	if (interface->bInterfaceClass != 0xFF)
diff --git a/drivers/usb/media/pwc-if.c b/drivers/usb/media/pwc-if.c
index 3f871469997e..f630ff649fd4 100644
--- a/drivers/usb/media/pwc-if.c
+++ b/drivers/usb/media/pwc-if.c
@@ -761,7 +761,7 @@ static int pwc_isoc_init(struct pwc_device *pdev)
 	struct urb *urb;
 	int i, j, ret;
 
-	struct usb_interface_descriptor *idesc;
+	struct usb_host_interface *idesc;
 	int cur_alt;
 
 	if (pdev == NULL)
@@ -781,9 +781,9 @@ static int pwc_isoc_init(struct pwc_device *pdev)
 
 	/* Search video endpoint */
 	pdev->vmax_packet_size = -1;
-	for (i = 0; i < idesc->bNumEndpoints; i++)
-		if ((idesc->endpoint[i].bEndpointAddress & 0xF) == pdev->vendpoint) {
-			pdev->vmax_packet_size = idesc->endpoint[i].wMaxPacketSize;
+	for (i = 0; i < idesc->desc.bNumEndpoints; i++)
+		if ((idesc->endpoint[i].desc.bEndpointAddress & 0xF) == pdev->vendpoint) {
+			pdev->vmax_packet_size = idesc->endpoint[i].desc.wMaxPacketSize;
 			break;
 		}
 	
@@ -821,7 +821,7 @@ static int pwc_isoc_init(struct pwc_device *pdev)
 		urb->interval = 1; // devik
 		urb->dev = udev;
 	        urb->pipe = usb_rcvisocpipe(udev, pdev->vendpoint);
-		urb->transfer_flags = USB_ISO_ASAP;
+		urb->transfer_flags = URB_ISO_ASAP;
 	        urb->transfer_buffer = pdev->sbuf[i].data;
 	        urb->transfer_buffer_length = ISO_BUFFER_SIZE;
 	        urb->complete = pwc_isoc_handler;
@@ -1552,13 +1552,15 @@ static int usb_pwc_probe(struct usb_interface *intf, const struct usb_device_id
 	free_mem_leak();
 	
 	/* Check if we can handle this device */
-	Trace(TRACE_PROBE, "probe() called [%04X %04X], if %d\n", udev->descriptor.idVendor, udev->descriptor.idProduct, intf->altsetting->bInterfaceNumber);
+	Trace(TRACE_PROBE, "probe() called [%04X %04X], if %d\n",
+			udev->descriptor.idVendor, udev->descriptor.idProduct,
+			intf->altsetting->desc.bInterfaceNumber);
 
 	/* the interfaces are probed one by one. We are only interested in the
 	   video interface (0) now.
 	   Interface 1 is the Audio Control, and interface 2 Audio itself.
 	 */
-	if (intf->altsetting->bInterfaceNumber > 0)
+	if (intf->altsetting->desc.bInterfaceNumber > 0)
 		return -ENODEV;
 
 	vendor_id = udev->descriptor.idVendor;
diff --git a/drivers/usb/media/se401.c b/drivers/usb/media/se401.c
index 87029897b56d..fd090f2fd147 100644
--- a/drivers/usb/media/se401.c
+++ b/drivers/usb/media/se401.c
@@ -609,7 +609,7 @@ static int se401_start_stream(struct usb_se401 *se401)
 		if(!urb)
 			return -ENOMEM;
 
-		FILL_BULK_URB(urb, se401->dev,
+		usb_fill_bulk_urb(urb, se401->dev,
 			usb_rcvbulkpipe(se401->dev, SE401_VIDEO_ENDPOINT),
 			se401->sbuf[i].data, SE401_PACKETSIZE,
 			se401_video_irq,
@@ -1420,7 +1420,7 @@ static int se401_init(struct usb_se401 *se401, int button)
 			info("Allocation of inturb failed");
 			return 1;
 		}
-		FILL_INT_URB(se401->inturb, se401->dev,
+		usb_fill_int_urb(se401->inturb, se401->dev,
 		    usb_rcvintpipe(se401->dev, SE401_BUTTON_ENDPOINT),
 		    &se401->button, sizeof(se401->button),
 		    se401_button_irq,
@@ -1456,7 +1456,7 @@ static int se401_probe(struct usb_interface *intf,
         if (dev->descriptor.bNumConfigurations != 1)
                 return -ENODEV;
 
-        interface = &intf->altsetting[0];
+        interface = &intf->altsetting[0].desc;
 
         /* Is it an se401? */
         if (dev->descriptor.idVendor == 0x03e8 &&
diff --git a/drivers/usb/media/stv680.c b/drivers/usb/media/stv680.c
index 3b048bd3152a..4e341c3b94cb 100644
--- a/drivers/usb/media/stv680.c
+++ b/drivers/usb/media/stv680.c
@@ -1451,7 +1451,7 @@ static struct video_device stv680_template = {
 static int stv680_probe (struct usb_interface *intf, const struct usb_device_id *id)
 {
 	struct usb_device *dev = interface_to_usbdev(intf);
-	struct usb_interface_descriptor *interface;
+	struct usb_host_interface *interface;
 	struct usb_stv *stv680;
 	char *camera_name = NULL;
 
diff --git a/drivers/usb/media/ultracam.c b/drivers/usb/media/ultracam.c
index 75fe954716be..f0f3a8e9d60a 100644
--- a/drivers/usb/media/ultracam.c
+++ b/drivers/usb/media/ultracam.c
@@ -569,17 +569,17 @@ static int ultracam_probe(struct usb_interface *intf, const struct usb_device_id
 	}
 	/* Validate all alternate settings */
 	for (i=0; i < nas; i++) {
-		const struct usb_interface_descriptor *interface;
+		const struct usb_host_interface *interface;
 		const struct usb_endpoint_descriptor *endpoint;
 
 		interface = &intf->altsetting[i];
-		if (interface->bNumEndpoints != 1) {
+		if (interface->desc.bNumEndpoints != 1) {
 			err("Interface %d. has %u. endpoints!",
-			    interface->bInterfaceNumber,
-			    (unsigned)(interface->bNumEndpoints));
+			    interface->desc.bInterfaceNumber,
+			    (unsigned)(interface->desc.bNumEndpoints));
 			return -ENODEV;
 		}
-		endpoint = &interface->endpoint[0];
+		endpoint = &interface->endpoint[0].desc;
 		if (video_ep == 0)
 			video_ep = endpoint->bEndpointAddress;
 		else if (video_ep != endpoint->bEndpointAddress) {
@@ -588,12 +588,12 @@ static int ultracam_probe(struct usb_interface *intf, const struct usb_device_id
 		}
 		if ((endpoint->bmAttributes & 0x03) != 0x01) {
 			err("Interface %d. has non-ISO endpoint!",
-			    interface->bInterfaceNumber);
+			    interface->desc.bInterfaceNumber);
 			return -ENODEV;
 		}
 		if ((endpoint->bEndpointAddress & 0x80) == 0) {
 			err("Interface %d. has ISO OUT endpoint!",
-			    interface->bInterfaceNumber);
+			    interface->desc.bInterfaceNumber);
 			return -ENODEV;
 		}
 		if (endpoint->wMaxPacketSize == 0) {
@@ -636,7 +636,7 @@ static int ultracam_probe(struct usb_interface *intf, const struct usb_device_id
 		uvd->flags = flags;
 		uvd->debug = debug;
 		uvd->dev = dev;
-		uvd->iface = intf->altsetting->bInterfaceNumber;
+		uvd->iface = intf->altsetting->desc.bInterfaceNumber;
 		uvd->ifaceAltInactive = inactInterface;
 		uvd->ifaceAltActive = actInterface;
 		uvd->video_endp = video_ep;
diff --git a/drivers/usb/media/usbvideo.c b/drivers/usb/media/usbvideo.c
index 4f5061d1a657..9aeffc958b04 100644
--- a/drivers/usb/media/usbvideo.c
+++ b/drivers/usb/media/usbvideo.c
@@ -1914,7 +1914,7 @@ static int usbvideo_StartDataPump(struct uvd *uvd)
 		urb->context = uvd;
 		urb->pipe = usb_rcvisocpipe(dev, uvd->video_endp);
 		urb->interval = 1;
-		urb->transfer_flags = USB_ISO_ASAP;
+		urb->transfer_flags = URB_ISO_ASAP;
 		urb->transfer_buffer = uvd->sbuf[i].data;
 		urb->complete = usbvideo_IsocIrq;
 		urb->number_of_packets = FRAMES_PER_DESC;
diff --git a/drivers/usb/media/vicam.c b/drivers/usb/media/vicam.c
index fa2ca5098877..178228860c7f 100644
--- a/drivers/usb/media/vicam.c
+++ b/drivers/usb/media/vicam.c
@@ -1253,7 +1253,7 @@ vicam_probe( struct usb_interface *intf, const struct usb_device_id *id)
 {
 	struct usb_device *dev = interface_to_usbdev(intf);
 	int bulkEndpoint = 0;
-	const struct usb_interface_descriptor *interface;
+	const struct usb_host_interface *interface;
 	const struct usb_endpoint_descriptor *endpoint;
 	struct vicam_camera *cam;
 	
@@ -1268,8 +1268,8 @@ vicam_probe( struct usb_interface *intf, const struct usb_device_id *id)
 	interface = &intf->altsetting[0];
 
 	DBG(KERN_DEBUG "Interface %d. has %u. endpoints!\n",
-	       ifnum, (unsigned) (interface->bNumEndpoints));
-	endpoint = &interface->endpoint[0];
+	       ifnum, (unsigned) (interface->desc.bNumEndpoints));
+	endpoint = &interface->endpoint[0].desc;
 
 	if ((endpoint->bEndpointAddress & 0x80) &&
 	    ((endpoint->bmAttributes & 3) == 0x02)) {
diff --git a/drivers/usb/misc/Config.help b/drivers/usb/misc/Config.help
index fadb396f6206..4ccdb4ff79fe 100644
--- a/drivers/usb/misc/Config.help
+++ b/drivers/usb/misc/Config.help
@@ -118,6 +118,9 @@ CONFIG_USB_TEST
   with specialized device firmware for regression and stress testing,
   to help prevent problems from cropping up with 'real" drivers.
 
+  See <http://www.linux-usb.org/usbtest> for more information,
+  including sample test device firmware and "how to use it".
+
 CONFIG_USB_LCD
   Say Y here if you want to connect an USBLCD to your computer's
   USB port. The USBLCD is a small USB interface board for
diff --git a/drivers/usb/misc/auerswald.c b/drivers/usb/misc/auerswald.c
index beac2aba435f..c245ee3d455c 100644
--- a/drivers/usb/misc/auerswald.c
+++ b/drivers/usb/misc/auerswald.c
@@ -445,7 +445,7 @@ static int auerchain_submit_urb (pauerchain_t acp, struct urb * urb)
 
 /* cancel an urb which is submitted to the chain
    the result is 0 if the urb is cancelled, or -EINPROGRESS if
-   USB_ASYNC_UNLINK is set and the function is successfully started.
+   URB_ASYNC_UNLINK is set and the function is successfully started.
 */
 static int auerchain_unlink_urb (pauerchain_t acp, struct urb * urb)
 {
@@ -534,7 +534,7 @@ static void auerchain_unlink_all (pauerchain_t acp)
         acep = acp->active;
         if (acep) {
                 urbp = acep->urbp;
-                urbp->transfer_flags &= ~USB_ASYNC_UNLINK;
+                urbp->transfer_flags &= ~URB_ASYNC_UNLINK;
                 dbg ("unlink active urb");
                 usb_unlink_urb (urbp);
         }
@@ -717,7 +717,7 @@ static int auerchain_control_msg (pauerchain_t acp, struct usb_device *dev, unsi
 	dr->wIndex  = cpu_to_le16 (index);
 	dr->wLength = cpu_to_le16 (size);
 
-	FILL_CONTROL_URB (urb, dev, pipe, (unsigned char*)dr, data, size,    /* build urb */
+	usb_fill_control_urb (urb, dev, pipe, (unsigned char*)dr, data, size,    /* build urb */
 		          (usb_complete_t)auerchain_blocking_completion,0);
 	ret = auerchain_start_wait_urb (acp, urb, timeout, &length);
 
@@ -919,7 +919,7 @@ static void auerswald_ctrlread_wretcomplete (struct urb * urb)
 	bp->dr->wLength      = bp->dr->wValue;	/* temporary stored */
 	bp->dr->wValue       = cpu_to_le16 (1);	/* Retry Flag */
 	/* bp->dr->index    = channel id;          remains */
-	FILL_CONTROL_URB (bp->urbp, cp->usbdev, usb_rcvctrlpipe (cp->usbdev, 0),
+	usb_fill_control_urb (bp->urbp, cp->usbdev, usb_rcvctrlpipe (cp->usbdev, 0),
                           (unsigned char*)bp->dr, bp->bufp, le16_to_cpu (bp->dr->wLength),
 		          (usb_complete_t)auerswald_ctrlread_complete,bp);
 
@@ -967,7 +967,7 @@ static void auerswald_ctrlread_complete (struct urb * urb)
 		bp->dr->wValue       = bp->dr->wLength; /* temporary storage */
 		// bp->dr->wIndex    channel ID remains
 		bp->dr->wLength      = cpu_to_le16 (32); /* >= 8 bytes */
-		FILL_CONTROL_URB (bp->urbp, cp->usbdev, usb_sndctrlpipe (cp->usbdev, 0),
+		usb_fill_control_urb (bp->urbp, cp->usbdev, usb_sndctrlpipe (cp->usbdev, 0),
   			(unsigned char*)bp->dr, bp->bufp, 32,
 	   		(usb_complete_t)auerswald_ctrlread_wretcomplete,bp);
 
@@ -1095,7 +1095,7 @@ static void auerswald_int_complete (struct urb * urb)
 	bp->dr->wValue       = cpu_to_le16 (0);
 	bp->dr->wIndex       = cpu_to_le16 (channelid | AUH_DIRECT | AUH_UNSPLIT);
 	bp->dr->wLength      = cpu_to_le16 (bytecount);
-	FILL_CONTROL_URB (bp->urbp, cp->usbdev, usb_rcvctrlpipe (cp->usbdev, 0),
+	usb_fill_control_urb (bp->urbp, cp->usbdev, usb_rcvctrlpipe (cp->usbdev, 0),
                           (unsigned char*)bp->dr, bp->bufp, bytecount,
 		          (usb_complete_t)auerswald_ctrlread_complete,bp);
 
@@ -1164,7 +1164,7 @@ static int auerswald_int_open (pauerswald_t cp)
                 }
         }
         /* setup urb */
-        FILL_INT_URB (cp->inturbp, cp->usbdev, usb_rcvintpipe (cp->usbdev,AU_IRQENDP), cp->intbufp, irqsize, auerswald_int_complete, cp, ep->bInterval);
+        usb_fill_int_urb (cp->inturbp, cp->usbdev, usb_rcvintpipe (cp->usbdev,AU_IRQENDP), cp->intbufp, irqsize, auerswald_int_complete, cp, ep->bInterval);
         /* start the urb */
 	cp->inturbp->status = 0;	/* needed! */
 	ret = usb_submit_urb (cp->inturbp, GFP_KERNEL);
@@ -1830,7 +1830,7 @@ write_again:
 	bp->dr->wValue       = cpu_to_le16 (0);
 	bp->dr->wIndex       = cpu_to_le16 (ccp->scontext.id | AUH_DIRECT | AUH_UNSPLIT);
 	bp->dr->wLength      = cpu_to_le16 (len+AUH_SIZE);
-	FILL_CONTROL_URB (bp->urbp, cp->usbdev, usb_sndctrlpipe (cp->usbdev, 0),
+	usb_fill_control_urb (bp->urbp, cp->usbdev, usb_sndctrlpipe (cp->usbdev, 0),
                    (unsigned char*)bp->dr, bp->bufp, len+AUH_SIZE,
 		    auerchar_ctrlwrite_complete, bp);
 	/* up we go */
@@ -1943,7 +1943,7 @@ static int auerswald_probe (struct usb_interface *intf,
 		return -ENODEV;
 
         /* we use only the first -and only- interface */
-        if (intf->altsetting->bInterfaceNumber != 0)
+        if (intf->altsetting->desc.bInterfaceNumber != 0)
 		return -ENODEV;
 
 	/* prevent module unloading while sleeping */
diff --git a/drivers/usb/misc/brlvger.c b/drivers/usb/misc/brlvger.c
index 88634bd49162..db226465bf9c 100644
--- a/drivers/usb/misc/brlvger.c
+++ b/drivers/usb/misc/brlvger.c
@@ -290,7 +290,7 @@ brlvger_probe (struct usb_interface *intf,
 	int i;
 	int retval;
 	struct usb_endpoint_descriptor *endpoint;
-	struct usb_interface_descriptor *actifsettings;
+	struct usb_host_interface *actifsettings;
 	/* protects against reentrance: once we've found a free slot
 	   we reserve it.*/
 	static DECLARE_MUTEX(reserve_sem);
@@ -299,13 +299,13 @@ brlvger_probe (struct usb_interface *intf,
 	actifsettings = dev->actconfig->interface->altsetting;
 
 	if( dev->descriptor.bNumConfigurations != 1
-			|| dev->config->bNumInterfaces != 1 
-			|| actifsettings->bNumEndpoints != 1 ) {
+			|| dev->config->desc.bNumInterfaces != 1 
+			|| actifsettings->desc.bNumEndpoints != 1 ) {
 		err ("Bogus braille display config info");
 		return -ENODEV;
 	}
 
-	endpoint = actifsettings->endpoint;
+	endpoint = &actifsettings->endpoint [0].desc;
 	if (!(endpoint->bEndpointAddress & 0x80) ||
 		((endpoint->bmAttributes & 3) != 0x03)) {
 		err ("Bogus braille display config info, wrong endpoints");
@@ -514,7 +514,7 @@ brlvger_open(struct inode *inode, struct file *file)
 		err("Unable to allocate URB");
 		goto error;
 	}
-	FILL_INT_URB( priv->intr_urb, priv->dev,
+	usb_fill_int_urb( priv->intr_urb, priv->dev,
 			usb_rcvintpipe(priv->dev,
 				       priv->in_interrupt->bEndpointAddress),
 			priv->intr_buff, sizeof(priv->intr_buff),
diff --git a/drivers/usb/misc/speedtouch.c b/drivers/usb/misc/speedtouch.c
index 45bdd24700b2..50118caa0e44 100644
--- a/drivers/usb/misc/speedtouch.c
+++ b/drivers/usb/misc/speedtouch.c
@@ -592,7 +592,7 @@ static void udsl_usb_send_data_complete (struct urb *urb)
 	ctx->skb = skb_dequeue (&(instance->sndqueue));
 	ctx->vcc = ((struct udsl_cb *) (ctx->skb->cb))->vcc;
 	spin_unlock_irqrestore (&instance->sndqlock, flags);
-	FILL_BULK_URB (urb,
+	usb_fill_bulk_urb (urb,
 		       instance->usb_dev,
 		       usb_sndbulkpipe (instance->usb_dev, UDSL_ENDPOINT_DATA_OUT),
 		       (unsigned char *) ctx->skb->data,
@@ -673,7 +673,7 @@ int udsl_usb_send_data (struct udsl_instance_data *instance, struct atm_vcc *vcc
 	spin_unlock_irqrestore (&instance->sndqlock, flags);
 
 	/* submit packet */
-	FILL_BULK_URB (urb,
+	usb_fill_bulk_urb (urb,
 		       instance->usb_dev,
 		       usb_sndbulkpipe (instance->usb_dev, UDSL_ENDPOINT_DATA_OUT),
 		       (unsigned char *) skb->data,
@@ -742,7 +742,7 @@ void udsl_usb_data_receive (struct urb *urb)
 		return;
 	}
 
-	FILL_BULK_URB (urb,
+	usb_fill_bulk_urb (urb,
 		       instance->usb_dev,
 		       usb_rcvbulkpipe (instance->usb_dev, UDSL_ENDPOINT_DATA_IN),
 		       (unsigned char *) ctx->skb->data,
@@ -790,7 +790,7 @@ int udsl_usb_data_init (struct udsl_instance_data *instance)
 			break;
 		};
 
-		FILL_BULK_URB (ctx->urb,
+		usb_fill_bulk_urb (ctx->urb,
 			       instance->usb_dev,
 			       usb_rcvbulkpipe (instance->usb_dev, UDSL_ENDPOINT_DATA_IN),
 			       (unsigned char *) ctx->skb->data,
@@ -917,7 +917,7 @@ static int udsl_usb_ioctl (struct usb_interface *intf, unsigned int code, void *
 static int udsl_usb_probe (struct usb_interface *intf, const struct usb_device_id *id)
 {
 	struct usb_device *dev = interface_to_usbdev(intf);
-	int ifnum = intf->altsetting->bInterfaceNumber;
+	int ifnum = intf->altsetting->desc.bInterfaceNumber;
 	int i;
 	unsigned char mac[6];
 	unsigned char mac_str[13];
diff --git a/drivers/usb/misc/tiglusb.c b/drivers/usb/misc/tiglusb.c
index 6dada5ddf6f4..c535d28da923 100644
--- a/drivers/usb/misc/tiglusb.c
+++ b/drivers/usb/misc/tiglusb.c
@@ -64,7 +64,7 @@ static devfs_handle_t devfs_handle;
 static inline int
 clear_device (struct usb_device *dev)
 {
-	if (usb_set_configuration (dev, dev->config[0].bConfigurationValue) < 0) {
+	if (usb_set_configuration (dev, dev->config[0].desc.bConfigurationValue) < 0) {
 		err ("clear_device failed");
 		return -1;
 	}
@@ -351,7 +351,7 @@ tiglusb_probe (struct usb_interface *intf,
 	    && (dev->descriptor.idVendor != 0x451))
 		return -ENODEV;
 
-	if (usb_set_configuration (dev, dev->config[0].bConfigurationValue) < 0) {
+	if (usb_set_configuration (dev, dev->config[0].desc.bConfigurationValue) < 0) {
 		err ("tiglusb_probe: set_configuration failed");
 		return -ENODEV;
 	}
diff --git a/drivers/usb/misc/usbtest.c b/drivers/usb/misc/usbtest.c
index 504be379b594..faa2ee6d40bb 100644
--- a/drivers/usb/misc/usbtest.c
+++ b/drivers/usb/misc/usbtest.c
@@ -290,7 +290,7 @@ static int get_altsetting (struct usbtest_dev *dev)
 
 	retval = usb_control_msg (udev, usb_rcvctrlpipe (udev, 0),
 			USB_REQ_GET_INTERFACE, USB_DIR_IN|USB_RECIP_INTERFACE,
-			0, iface->altsetting [0].bInterfaceNumber,
+			0, iface->altsetting [0].desc.bInterfaceNumber,
 			dev->buf, 1, HZ * USB_CTRL_GET_TIMEOUT);
 	switch (retval) {
 	case 1:
@@ -308,7 +308,7 @@ static int set_altsetting (struct usbtest_dev *dev, int alternate)
 {
 	struct usb_interface		*iface = dev->intf;
 	struct usb_device		*udev;
-	struct usb_interface_descriptor	*iface_as;
+	struct usb_host_interface	*iface_as;
 	int				i, ret;
 
 	if (alternate < 0 || alternate >= iface->num_altsetting)
@@ -317,8 +317,8 @@ static int set_altsetting (struct usbtest_dev *dev, int alternate)
 	udev = interface_to_usbdev (iface);
 	if ((ret = usb_control_msg (udev, usb_sndctrlpipe (udev, 0),
 			USB_REQ_SET_INTERFACE, USB_RECIP_INTERFACE,
-			iface->altsetting [alternate].bAlternateSetting,
-			iface->altsetting [alternate].bInterfaceNumber,
+			alternate,
+			iface->altsetting->desc.bInterfaceNumber,
 			NULL, 0, HZ * USB_CTRL_SET_TIMEOUT)) < 0)
 		return ret;
 
@@ -328,8 +328,8 @@ static int set_altsetting (struct usbtest_dev *dev, int alternate)
 
 	/* prevent requests using previous endpoint settings */
 	iface_as = iface->altsetting + iface->act_altsetting;
-	for (i = 0; i < iface_as->bNumEndpoints; i++) {
-		u8	ep = iface_as->endpoint [i].bEndpointAddress;
+	for (i = 0; i < iface_as->desc.bNumEndpoints; i++) {
+		u8	ep = iface_as->endpoint [i].desc.bEndpointAddress;
 		int	out = !(ep & USB_DIR_IN);
 
 		ep &= USB_ENDPOINT_NUMBER_MASK;
@@ -340,14 +340,14 @@ static int set_altsetting (struct usbtest_dev *dev, int alternate)
 
 	/* reset toggles and maxpacket for all endpoints affected */
 	iface_as = iface->altsetting + iface->act_altsetting;
-	for (i = 0; i < iface_as->bNumEndpoints; i++) {
-		u8	ep = iface_as->endpoint [i].bEndpointAddress;
+	for (i = 0; i < iface_as->desc.bNumEndpoints; i++) {
+		u8	ep = iface_as->endpoint [i].desc.bEndpointAddress;
 		int	out = !(ep & USB_DIR_IN);
 
 		ep &= USB_ENDPOINT_NUMBER_MASK;
 		usb_settoggle (udev, ep, out, 0);
 		(out ? udev->epmaxpacketout : udev->epmaxpacketin ) [ep]
-			= iface_as->endpoint [i].wMaxPacketSize;
+			= iface_as->endpoint [i].desc.wMaxPacketSize;
 	}
 
 	return 0;
@@ -415,10 +415,10 @@ static int ch9_postconfig (struct usbtest_dev *dev)
 		/* 9.2.3 constrains the range here, and Linux ensures
 		 * they're ordered meaningfully in this array
 		 */
-		if (iface->altsetting [i].bAlternateSetting != i) {
+		if (iface->altsetting [i].desc.bAlternateSetting != i) {
 			dbg ("%s, illegal alt [%d].bAltSetting = %d",
 					dev->id, i, 
-					iface->altsetting [i]
+					iface->altsetting [i].desc
 						.bAlternateSetting);
 			return -EDOM;
 		}
@@ -447,7 +447,7 @@ static int ch9_postconfig (struct usbtest_dev *dev)
 
 	/* [real world] get_config unimplemented if there's only one */
 	if (udev->descriptor.bNumConfigurations != 1) {
-		int	expected = udev->actconfig->bConfigurationValue;
+		int	expected = udev->actconfig->desc.bConfigurationValue;
 
 		/* [9.4.2] get_configuration always works
 		 * ... although some cheap devices (like one TI Hub I've got)
@@ -534,7 +534,7 @@ static int ch9_postconfig (struct usbtest_dev *dev)
 	// the device's remote wakeup feature ... if we can, test that here
 
 	retval = usb_get_status (udev, USB_RECIP_INTERFACE,
-			iface->altsetting [0].bInterfaceNumber, dev->buf);
+			iface->altsetting [0].desc.bInterfaceNumber, dev->buf);
 	if (retval != 2) {
 		dbg ("%s get interface status --> %d", dev->id, retval);
 		return (retval < 0) ? retval : -EDOM;
@@ -591,7 +591,7 @@ static int usbtest_ioctl (struct usb_interface *intf, unsigned int code, void *b
 	if (dev->info->alt >= 0) {
 	    	int	res;
 
-		if (intf->altsetting->bInterfaceNumber)
+		if (intf->altsetting->desc.bInterfaceNumber)
 			return -ENODEV;
 		res = set_altsetting (dev, dev->info->alt);
 		if (res) {
@@ -823,7 +823,7 @@ usbtest_probe (struct usb_interface *intf, const struct usb_device_id *id)
 	/* use the same kind of id the hid driver shows */
 	snprintf (dev->id, sizeof dev->id, "%s-%s:%d",
 			udev->bus->bus_name, udev->devpath,
-			intf->altsetting [0].bInterfaceNumber);
+			intf->altsetting [0].desc.bInterfaceNumber);
 	dev->intf = intf;
 
 	/* cacheline-aligned scratch for i/o */
diff --git a/drivers/usb/misc/uss720.c b/drivers/usb/misc/uss720.c
index 36efa886c9e0..3756af894c20 100644
--- a/drivers/usb/misc/uss720.c
+++ b/drivers/usb/misc/uss720.c
@@ -549,8 +549,8 @@ static int uss720_probe(struct usb_interface *intf,
 			const struct usb_device_id *id)
 {
 	struct usb_device *usbdev = interface_to_usbdev(intf);
-	struct usb_interface_descriptor *interface;
-	struct usb_endpoint_descriptor *endpoint;
+	struct usb_host_interface *interface;
+	struct usb_host_endpoint *endpoint;
 	struct parport_uss720_private *priv;
 	struct parport *pp;
 	int i;
@@ -562,7 +562,7 @@ static int uss720_probe(struct usb_interface *intf,
 	if (intf->num_altsetting != 3)
 		return -ENODEV;
 
-	i = usb_set_interface(usbdev, intf->altsetting->bInterfaceNumber, 2);
+	i = usb_set_interface(usbdev, intf->altsetting->desc.bInterfaceNumber, 2);
 	printk(KERN_DEBUG "uss720: set inteface result %d\n", i);
 
 	interface = &intf->altsetting[2];
@@ -593,7 +593,7 @@ static int uss720_probe(struct usb_interface *intf,
 	       priv->reg[0], priv->reg[1], priv->reg[2], priv->reg[3], priv->reg[4], priv->reg[5], priv->reg[6]);
 
 	endpoint = &interface->endpoint[2];
-	printk(KERN_DEBUG "uss720: epaddr %d interval %d\n", endpoint->bEndpointAddress, endpoint->bInterval);
+	printk(KERN_DEBUG "uss720: epaddr %d interval %d\n", endpoint->desc.bEndpointAddress, endpoint->desc.bInterval);
 #if 0
 	priv->irqpipe = usb_rcvctrlpipe(usbdev, endpoint->bEndpointAddress);
 	i = usb_request_irq(usbdev, priv->irqpipe,
diff --git a/drivers/usb/net/catc.c b/drivers/usb/net/catc.c
index 84cf473b7bed..57c249c3eb5e 100644
--- a/drivers/usb/net/catc.c
+++ b/drivers/usb/net/catc.c
@@ -381,7 +381,7 @@ static void catc_tx_done(struct urb *urb)
 
 	if (urb->status == -ECONNRESET) {
 		dbg("Tx Reset.");
-		urb->transfer_flags &= ~USB_ASYNC_UNLINK;
+		urb->transfer_flags &= ~URB_ASYNC_UNLINK;
 		urb->status = 0;
 		catc->netdev->trans_start = jiffies;
 		catc->stats.tx_errors++;
@@ -443,7 +443,7 @@ static void catc_tx_timeout(struct net_device *netdev)
 	struct catc *catc = netdev->priv;
 
 	warn("Transmit timed out.");
-	catc->tx_urb->transfer_flags |= USB_ASYNC_UNLINK;
+	catc->tx_urb->transfer_flags |= URB_ASYNC_UNLINK;
 	usb_unlink_urb(catc->tx_urb);
 }
 
@@ -783,7 +783,8 @@ static int catc_probe(struct usb_interface *intf, const struct usb_device_id *id
 	u8 broadcast[6];
 	int i, pktsz;
 
-	if (usb_set_interface(usbdev, intf->altsetting->bInterfaceNumber, 1)) {
+	if (usb_set_interface(usbdev,
+			intf->altsetting->desc.bInterfaceNumber, 1)) {
                 err("Can't set altsetting 1.");
 		return -EIO;
 	}
@@ -847,16 +848,16 @@ static int catc_probe(struct usb_interface *intf, const struct usb_device_id *id
 		pktsz = RX_MAX_BURST * (PKT_SZ + 2);
 	}
 	
-	FILL_CONTROL_URB(catc->ctrl_urb, usbdev, usb_sndctrlpipe(usbdev, 0),
+	usb_fill_control_urb(catc->ctrl_urb, usbdev, usb_sndctrlpipe(usbdev, 0),
 		NULL, NULL, 0, catc_ctrl_done, catc);
 
-	FILL_BULK_URB(catc->tx_urb, usbdev, usb_sndbulkpipe(usbdev, 1),
+	usb_fill_bulk_urb(catc->tx_urb, usbdev, usb_sndbulkpipe(usbdev, 1),
 		NULL, 0, catc_tx_done, catc);
 
-	FILL_BULK_URB(catc->rx_urb, usbdev, usb_rcvbulkpipe(usbdev, 1),
+	usb_fill_bulk_urb(catc->rx_urb, usbdev, usb_rcvbulkpipe(usbdev, 1),
 		catc->rx_buf, pktsz, catc_rx_done, catc);
 
-	FILL_INT_URB(catc->irq_urb, usbdev, usb_rcvintpipe(usbdev, 2),
+	usb_fill_int_urb(catc->irq_urb, usbdev, usb_rcvintpipe(usbdev, 2),
                 catc->irq_buf, 2, catc_irq_done, catc, 1);
 
 	if (!catc->is_f5u011) {
diff --git a/drivers/usb/net/cdc-ether.c b/drivers/usb/net/cdc-ether.c
index 513f83c9bda1..2b9626c44276 100644
--- a/drivers/usb/net/cdc-ether.c
+++ b/drivers/usb/net/cdc-ether.c
@@ -125,7 +125,7 @@ static void read_bulk_callback( struct urb *urb )
 
 goon:
 	// Prep the USB to wait for another frame
-	FILL_BULK_URB( ether_dev->rx_urb, ether_dev->usb,
+	usb_fill_bulk_urb( ether_dev->rx_urb, ether_dev->usb,
 			usb_rcvbulkpipe(ether_dev->usb, ether_dev->data_ep_in),
 			ether_dev->rx_buff, ether_dev->wMaxSegmentSize, 
 			read_bulk_callback, ether_dev );
@@ -259,7 +259,7 @@ static void CDCEther_tx_timeout( struct net_device *net )
 	warn("%s: Tx timed out.", net->name);
 	
 	// Tear the waiting frame off the list
-	ether_dev->tx_urb->transfer_flags |= USB_ASYNC_UNLINK;
+	ether_dev->tx_urb->transfer_flags |= URB_ASYNC_UNLINK;
 	usb_unlink_urb( ether_dev->tx_urb );
 	
 	// Update statistics
@@ -293,7 +293,7 @@ static int CDCEther_start_xmit( struct sk_buff *skb, struct net_device *net )
 	memcpy(ether_dev->tx_buff, skb->data, skb->len);
 
 	// Fill in the URB for shipping it out.
-	FILL_BULK_URB( ether_dev->tx_urb, ether_dev->usb,
+	usb_fill_bulk_urb( ether_dev->tx_urb, ether_dev->usb,
 			usb_sndbulkpipe(ether_dev->usb, ether_dev->data_ep_out),
 			ether_dev->tx_buff, ether_dev->wMaxSegmentSize, 
 			write_bulk_callback, ether_dev );
@@ -344,7 +344,7 @@ static int CDCEther_open(struct net_device *net)
 	}
 
 	// Prep a receive URB
-	FILL_BULK_URB( ether_dev->rx_urb, ether_dev->usb,
+	usb_fill_bulk_urb( ether_dev->rx_urb, ether_dev->usb,
 			usb_rcvbulkpipe(ether_dev->usb, ether_dev->data_ep_in),
 			ether_dev->rx_buff, ether_dev->wMaxSegmentSize, 
 			read_bulk_callback, ether_dev );
@@ -723,9 +723,9 @@ static int parse_ethernet_class_information( unsigned char *data, int length, et
 
 static int find_and_parse_ethernet_class_information( struct usb_device *device, ether_dev_t *ether_dev )
 {
-	struct usb_config_descriptor *conf = NULL;
+	struct usb_host_config *conf = NULL;
 	struct usb_interface *comm_intf_group = NULL;
-	struct usb_interface_descriptor *comm_intf = NULL;
+	struct usb_host_interface *comm_intf = NULL;
 	int rc = -1;
 	// The assumption here is that find_ethernet_comm_interface
 	// and find_valid_configuration 
@@ -760,9 +760,9 @@ static int find_and_parse_ethernet_class_information( struct usb_device *device,
 
 static int get_data_interface_endpoints( struct usb_device *device, ether_dev_t *ether_dev )
 {
-	struct usb_config_descriptor *conf = NULL;
+	struct usb_host_config *conf = NULL;
 	struct usb_interface *data_intf_group = NULL;
-	struct usb_interface_descriptor *data_intf = NULL;
+	struct usb_host_interface *data_intf = NULL;
 	
 	// Walk through and get to the data interface we are checking.
 	conf = &( device->config[ether_dev->configuration_num] );
@@ -774,30 +774,30 @@ static int get_data_interface_endpoints( struct usb_device *device, ether_dev_t
 	ether_dev->data_ep_out = 0;
 	
 	// If these are not BULK endpoints, we don't want them
-	if ( data_intf->endpoint[0].bmAttributes != 0x02 ) {
+	if ( data_intf->endpoint[0].desc.bmAttributes != 0x02 ) {
 		return -1;
-	} if ( data_intf->endpoint[1].bmAttributes != 0x02 ) {
+	} if ( data_intf->endpoint[1].desc.bmAttributes != 0x02 ) {
 		return -1;
 	}
 
 	// Check the first endpoint to see if it is IN or OUT
-	if ( data_intf->endpoint[0].bEndpointAddress & 0x80 ) {
+	if ( data_intf->endpoint[0].desc.bEndpointAddress & 0x80 ) {
 		// This endpoint is IN
-		ether_dev->data_ep_in = data_intf->endpoint[0].bEndpointAddress & 0x7F;
+		ether_dev->data_ep_in = data_intf->endpoint[0].desc.bEndpointAddress & 0x7F;
 	} else {
 		// This endpoint is OUT
-		ether_dev->data_ep_out = data_intf->endpoint[0].bEndpointAddress & 0x7F;
-		ether_dev->data_ep_out_size = data_intf->endpoint[0].wMaxPacketSize;
+		ether_dev->data_ep_out = data_intf->endpoint[0].desc.bEndpointAddress & 0x7F;
+		ether_dev->data_ep_out_size = data_intf->endpoint[0].desc.wMaxPacketSize;
 	}
 
 	// Check the second endpoint to see if it is IN or OUT
-	if ( data_intf->endpoint[1].bEndpointAddress & 0x80 ) {
+	if ( data_intf->endpoint[1].desc.bEndpointAddress & 0x80 ) {
 		// This endpoint is IN
-		ether_dev->data_ep_in = data_intf->endpoint[1].bEndpointAddress & 0x7F;
+		ether_dev->data_ep_in = data_intf->endpoint[1].desc.bEndpointAddress & 0x7F;
 	} else	{
 		// This endpoint is OUT
-		ether_dev->data_ep_out = data_intf->endpoint[1].bEndpointAddress & 0x7F;
-		ether_dev->data_ep_out_size = data_intf->endpoint[1].wMaxPacketSize;
+		ether_dev->data_ep_out = data_intf->endpoint[1].desc.bEndpointAddress & 0x7F;
+		ether_dev->data_ep_out_size = data_intf->endpoint[1].desc.wMaxPacketSize;
 	}
 	
 	// Now make sure we got both an IN and an OUT
@@ -811,7 +811,7 @@ static int get_data_interface_endpoints( struct usb_device *device, ether_dev_t
 
 static int verify_ethernet_data_interface( struct usb_device *device, ether_dev_t *ether_dev )
 {
-	struct usb_config_descriptor *conf = NULL;
+	struct usb_host_config *conf = NULL;
 	struct usb_interface *data_intf_group = NULL;
 	struct usb_interface_descriptor *data_intf = NULL;
 	int rc = -1;
@@ -834,7 +834,7 @@ static int verify_ethernet_data_interface( struct usb_device *device, ether_dev_
 	// Walk through every possible setting for this interface until
 	// we find what makes us happy.
 	for ( altset_num = 0; altset_num < data_intf_group->num_altsetting; altset_num++ ) {
-		data_intf = &( data_intf_group->altsetting[altset_num] );
+		data_intf = &( data_intf_group->altsetting[altset_num].desc );
 
 		// Is this a data interface we like?
 		if ( ( data_intf->bInterfaceClass == 0x0A )
@@ -875,7 +875,7 @@ static int verify_ethernet_data_interface( struct usb_device *device, ether_dev_
 
 static int find_ethernet_comm_interface( struct usb_device *device, ether_dev_t *ether_dev )
 {
-	struct usb_config_descriptor *conf = NULL;
+	struct usb_host_config *conf = NULL;
 	struct usb_interface *comm_intf_group = NULL;
 	struct usb_interface_descriptor *comm_intf = NULL;
 	int intf_num;
@@ -886,12 +886,12 @@ static int find_ethernet_comm_interface( struct usb_device *device, ether_dev_t
 
 	// We need to check and see if any of these interfaces are something we want.
 	// Walk through each interface one at a time
-	for ( intf_num = 0; intf_num < conf->bNumInterfaces; intf_num++ ) {
+	for ( intf_num = 0; intf_num < conf->desc.bNumInterfaces; intf_num++ ) {
 		comm_intf_group = &( conf->interface[intf_num] );
 		// Now for each of those interfaces, check every possible
 		// alternate setting.
 		for ( altset_num = 0; altset_num < comm_intf_group->num_altsetting; altset_num++ ) {
-			comm_intf = &( comm_intf_group->altsetting[altset_num] );
+			comm_intf = &( comm_intf_group->altsetting[altset_num].desc);
 
 			// Is this a communication class of interface of the
 			// ethernet subclass variety.
@@ -944,7 +944,7 @@ static int find_ethernet_comm_interface( struct usb_device *device, ether_dev_t
 
 static int find_valid_configuration( struct usb_device *device, ether_dev_t *ether_dev )
 {
-	struct usb_config_descriptor *conf = NULL;
+	struct usb_host_config *conf = NULL;
 	int conf_num;
 	int rc;
 
@@ -953,7 +953,7 @@ static int find_valid_configuration( struct usb_device *device, ether_dev_t *eth
 		conf = &( device->config[conf_num] );
 
 		// Our first requirement : 2 interfaces
-		if ( conf->bNumInterfaces != 2 ) {
+		if ( conf->desc.bNumInterfaces != 2 ) {
 			// I currently don't know how to handle devices with any number of interfaces
 			// other than 2.
 			continue;
@@ -962,7 +962,7 @@ static int find_valid_configuration( struct usb_device *device, ether_dev_t *eth
 		// This one passed our first check, fill in some 
 		// useful data
 		ether_dev->configuration_num = conf_num;
-		ether_dev->bConfigurationValue = conf->bConfigurationValue;
+		ether_dev->bConfigurationValue = conf->desc.bConfigurationValue;
 
 		// Now run it through the ringers and see what comes
 		// out the other side.
@@ -983,14 +983,14 @@ static int find_valid_configuration( struct usb_device *device, ether_dev_t *eth
 // has claimed any of the devices interfaces /////////////////////////////////
 //////////////////////////////////////////////////////////////////////////////
 
-static int check_for_claimed_interfaces( struct usb_config_descriptor *config )
+static int check_for_claimed_interfaces( struct usb_host_config *config )
 {
 	struct usb_interface *comm_intf_group;
 	int intf_num;
 
 	// Go through all the interfaces and make sure none are 
 	// claimed by anybody else.
-	for ( intf_num = 0; intf_num < config->bNumInterfaces; intf_num++ ) {
+	for ( intf_num = 0; intf_num < config->desc.bNumInterfaces; intf_num++ ) {
 		comm_intf_group = &( config->interface[intf_num] );
 		if ( usb_interface_claimed( comm_intf_group ) )	{
 			// Somebody has beat us to this guy.
diff --git a/drivers/usb/net/kaweth.c b/drivers/usb/net/kaweth.c
index cea07c41875b..32e669e81758 100644
--- a/drivers/usb/net/kaweth.c
+++ b/drivers/usb/net/kaweth.c
@@ -449,7 +449,7 @@ static int kaweth_reset(struct kaweth_device *kaweth)
 				usb_sndctrlpipe(kaweth->dev, 0),
 				USB_REQ_SET_CONFIGURATION,
 				0,
-				kaweth->dev->config[0].bConfigurationValue,
+				kaweth->dev->config[0].desc.bConfigurationValue,
 				0,
 				NULL,
 				0,
@@ -514,7 +514,7 @@ static int kaweth_resubmit_rx_urb(struct kaweth_device *kaweth,
 {
 	int result;
 
-	FILL_BULK_URB(kaweth->rx_urb,
+	usb_fill_bulk_urb(kaweth->rx_urb,
 		      kaweth->dev,
 		      usb_rcvbulkpipe(kaweth->dev, 1),
 		      kaweth->rx_buf,
@@ -620,7 +620,7 @@ static int kaweth_open(struct net_device *net)
 	if (res)
 		return -EIO;
 
-	FILL_INT_URB(
+	usb_fill_int_urb(
 		kaweth->irq_urb,
 		kaweth->dev,
 		usb_rcvintpipe(kaweth->dev, 3),
@@ -752,7 +752,7 @@ static int kaweth_start_xmit(struct sk_buff *skb, struct net_device *net)
 	*private_header = cpu_to_le16(skb->len);
 	kaweth->tx_skb = skb;
 
-	FILL_BULK_URB(kaweth->tx_urb,
+	usb_fill_bulk_urb(kaweth->tx_urb,
 		      kaweth->dev,
 		      usb_sndbulkpipe(kaweth->dev, 2),
 		      private_header,
@@ -760,7 +760,7 @@ static int kaweth_start_xmit(struct sk_buff *skb, struct net_device *net)
 		      kaweth_usb_transmit_complete,
 		      kaweth);
 	kaweth->end = 0;
-	kaweth->tx_urb->transfer_flags |= USB_ASYNC_UNLINK;
+	kaweth->tx_urb->transfer_flags |= URB_ASYNC_UNLINK;
 
 	if((res = usb_submit_urb(kaweth->tx_urb, GFP_ATOMIC)))
 	{
@@ -1207,7 +1207,7 @@ int kaweth_internal_control_msg(struct usb_device *usb_dev, unsigned int pipe,
         if (!urb)
                 return -ENOMEM;
 
-        FILL_CONTROL_URB(urb, usb_dev, pipe, (unsigned char*)cmd, data,
+        usb_fill_control_urb(urb, usb_dev, pipe, (unsigned char*)cmd, data,
 			 len, (usb_complete_t)usb_api_blocking_completion,0);
 
         retv = usb_start_wait_urb(urb, timeout, &length);
diff --git a/drivers/usb/net/pegasus.c b/drivers/usb/net/pegasus.c
index 19f3b82d54fc..34ed89241550 100644
--- a/drivers/usb/net/pegasus.c
+++ b/drivers/usb/net/pegasus.c
@@ -143,7 +143,7 @@ static int get_registers(pegasus_t * pegasus, __u16 indx, __u16 size,
 	pegasus->dr.wLength = cpu_to_le16p(&size);
 	pegasus->ctrl_urb->transfer_buffer_length = size;
 
-	FILL_CONTROL_URB(pegasus->ctrl_urb, pegasus->usb,
+	usb_fill_control_urb(pegasus->ctrl_urb, pegasus->usb,
 			 usb_rcvctrlpipe(pegasus->usb, 0),
 			 (char *) &pegasus->dr,
 			 buffer, size, ctrl_callback, pegasus);
@@ -194,7 +194,7 @@ static int set_registers(pegasus_t * pegasus, __u16 indx, __u16 size,
 	pegasus->dr.wLength = cpu_to_le16p(&size);
 	pegasus->ctrl_urb->transfer_buffer_length = size;
 
-	FILL_CONTROL_URB(pegasus->ctrl_urb, pegasus->usb,
+	usb_fill_control_urb(pegasus->ctrl_urb, pegasus->usb,
 			 usb_sndctrlpipe(pegasus->usb, 0),
 			 (char *) &pegasus->dr,
 			 buffer, size, ctrl_callback, pegasus);
@@ -243,7 +243,7 @@ static int set_register(pegasus_t * pegasus, __u16 indx, __u8 data)
 	pegasus->dr.wLength = cpu_to_le16(1);
 	pegasus->ctrl_urb->transfer_buffer_length = 1;
 
-	FILL_CONTROL_URB(pegasus->ctrl_urb, pegasus->usb,
+	usb_fill_control_urb(pegasus->ctrl_urb, pegasus->usb,
 			 usb_sndctrlpipe(pegasus->usb, 0),
 			 (char *) &pegasus->dr,
 			 buffer, 1, ctrl_callback, pegasus);
@@ -275,7 +275,7 @@ static int update_eth_regs_async(pegasus_t * pegasus)
 	pegasus->dr.wLength = cpu_to_le16(3);
 	pegasus->ctrl_urb->transfer_buffer_length = 3;
 
-	FILL_CONTROL_URB(pegasus->ctrl_urb, pegasus->usb,
+	usb_fill_control_urb(pegasus->ctrl_urb, pegasus->usb,
 			 usb_sndctrlpipe(pegasus->usb, 0),
 			 (char *) &pegasus->dr,
 			 pegasus->eth_regs, 3, ctrl_callback, pegasus);
@@ -596,7 +596,7 @@ static void read_bulk_callback(struct urb *urb)
 	if (pegasus->rx_skb == NULL)
 		goto tl_sched;
 goon:
-	FILL_BULK_URB(pegasus->rx_urb, pegasus->usb,
+	usb_fill_bulk_urb(pegasus->rx_urb, pegasus->usb,
 		      usb_rcvbulkpipe(pegasus->usb, 1),
 		      pegasus->rx_skb->data, PEGASUS_MTU + 8,
 		      read_bulk_callback, pegasus);
@@ -635,7 +635,7 @@ static void rx_fixup(unsigned long data)
 		tasklet_schedule(&pegasus->rx_tl);
 		return;
 	}
-	FILL_BULK_URB(pegasus->rx_urb, pegasus->usb,
+	usb_fill_bulk_urb(pegasus->rx_urb, pegasus->usb,
  	              usb_rcvbulkpipe(pegasus->usb, 1),
 	              pegasus->rx_skb->data, PEGASUS_MTU + 8,
 	              read_bulk_callback, pegasus);	
@@ -718,7 +718,7 @@ static void pegasus_tx_timeout(struct net_device *net)
 		return;
 
 	warn("%s: Tx timed out.", net->name);
-	pegasus->tx_urb->transfer_flags |= USB_ASYNC_UNLINK;
+	pegasus->tx_urb->transfer_flags |= URB_ASYNC_UNLINK;
 	usb_unlink_urb(pegasus->tx_urb);
 	pegasus->stats.tx_errors++;
 }
@@ -734,7 +734,7 @@ static int pegasus_start_xmit(struct sk_buff *skb, struct net_device *net)
 
 	((__u16 *) pegasus->tx_buff)[0] = cpu_to_le16(l16);
 	memcpy(pegasus->tx_buff + 2, skb->data, skb->len);
-	FILL_BULK_URB(pegasus->tx_urb, pegasus->usb,
+	usb_fill_bulk_urb(pegasus->tx_urb, pegasus->usb,
 		      usb_sndbulkpipe(pegasus->usb, 2),
 		      pegasus->tx_buff, count,
 		      write_bulk_callback, pegasus);
@@ -852,13 +852,13 @@ static int pegasus_open(struct net_device *net)
 		return -ENOMEM;
 
 	down(&pegasus->sem);
-	FILL_BULK_URB(pegasus->rx_urb, pegasus->usb,
+	usb_fill_bulk_urb(pegasus->rx_urb, pegasus->usb,
 		      usb_rcvbulkpipe(pegasus->usb, 1),
 		      pegasus->rx_skb->data, PEGASUS_MTU + 8,
 		      read_bulk_callback, pegasus);
 	if ((res = usb_submit_urb(pegasus->rx_urb, GFP_KERNEL)))
 		warn("%s: failed rx_urb %d", __FUNCTION__, res);
-	FILL_INT_URB(pegasus->intr_urb, pegasus->usb,
+	usb_fill_int_urb(pegasus->intr_urb, pegasus->usb,
 		     usb_rcvintpipe(pegasus->usb, 3),
 		     pegasus->intr_buff, sizeof(pegasus->intr_buff),
 		     intr_callback, pegasus, pegasus->intr_interval);
@@ -1061,7 +1061,7 @@ static int pegasus_probe(struct usb_interface *intf,
 	pegasus_t *pegasus;
 	int dev_index = id - pegasus_ids;
 
-	if (usb_set_configuration(dev, dev->config[0].bConfigurationValue)) {
+	if (usb_set_configuration(dev, dev->config[0].desc.bConfigurationValue)) {
 		err("usb_set_configuration() failed");
 		return -ENODEV;
 	}
diff --git a/drivers/usb/net/rtl8150.c b/drivers/usb/net/rtl8150.c
index 7517394ebb92..bb38b4caa353 100644
--- a/drivers/usb/net/rtl8150.c
+++ b/drivers/usb/net/rtl8150.c
@@ -174,7 +174,7 @@ static int async_set_registers(rtl8150_t * dev, u16 indx, u16 size, void *data)
 	dev->dr.wIndex = 0;
 	dev->dr.wLength = cpu_to_le16(size);
 	dev->ctrl_urb->transfer_buffer_length = size;
-	FILL_CONTROL_URB(dev->ctrl_urb, dev->udev,
+	usb_fill_control_urb(dev->ctrl_urb, dev->udev,
 			 usb_sndctrlpipe(dev->udev, 0), (char *) &dev->dr,
 			 &dev->rx_creg, size, ctrl_callback, dev);
 	if ((ret = usb_submit_urb(dev->ctrl_urb, GFP_ATOMIC)))
@@ -387,7 +387,7 @@ static void read_bulk_callback(struct urb *urb)
 
 	dev->rx_skb = skb;
 goon:
-	FILL_BULK_URB(dev->rx_urb, dev->udev, usb_rcvbulkpipe(dev->udev, 1),
+	usb_fill_bulk_urb(dev->rx_urb, dev->udev, usb_rcvbulkpipe(dev->udev, 1),
 		      dev->rx_skb->data, RTL8150_MTU, read_bulk_callback, dev);
 	if (usb_submit_urb(dev->rx_urb, GFP_ATOMIC)) {
 		set_bit(RX_URB_FAIL, &dev->flags);
@@ -420,7 +420,7 @@ static void rx_fixup(unsigned long data)
 	if (skb == NULL)
 		goto tlsched;
 	dev->rx_skb = skb;
-	FILL_BULK_URB(dev->rx_urb, dev->udev, usb_rcvbulkpipe(dev->udev, 1),
+	usb_fill_bulk_urb(dev->rx_urb, dev->udev, usb_rcvbulkpipe(dev->udev, 1),
 		      dev->rx_skb->data, RTL8150_MTU, read_bulk_callback, dev);
 try_again:
 	if (usb_submit_urb(dev->rx_urb, GFP_ATOMIC)) {
@@ -573,7 +573,7 @@ static void rtl8150_tx_timeout(struct net_device *netdev)
 	if (!dev)
 		return;
 	warn("%s: Tx timeout.", netdev->name);
-	dev->tx_urb->transfer_flags |= USB_ASYNC_UNLINK;
+	dev->tx_urb->transfer_flags |= URB_ASYNC_UNLINK;
 	usb_unlink_urb(dev->tx_urb);
 	dev->stats.tx_errors++;
 }
@@ -610,7 +610,7 @@ static int rtl8150_start_xmit(struct sk_buff *skb, struct net_device *netdev)
 	count = (skb->len < 60) ? 60 : skb->len;
 	count = (count & 0x3f) ? count : count + 1;
 	dev->tx_skb = skb;
-	FILL_BULK_URB(dev->tx_urb, dev->udev, usb_sndbulkpipe(dev->udev, 2),
+	usb_fill_bulk_urb(dev->tx_urb, dev->udev, usb_sndbulkpipe(dev->udev, 2),
 		      skb->data, count, write_bulk_callback, dev);
 	if ((res = usb_submit_urb(dev->tx_urb, GFP_ATOMIC))) {
 		warn("failed tx_urb %d\n", res);
@@ -640,11 +640,11 @@ static int rtl8150_open(struct net_device *netdev)
 		return -ENOMEM;
 
 	down(&dev->sem);
-	FILL_BULK_URB(dev->rx_urb, dev->udev, usb_rcvbulkpipe(dev->udev, 1),
+	usb_fill_bulk_urb(dev->rx_urb, dev->udev, usb_rcvbulkpipe(dev->udev, 1),
 		      dev->rx_skb->data, RTL8150_MTU, read_bulk_callback, dev);
 	if ((res = usb_submit_urb(dev->rx_urb, GFP_KERNEL)))
 		warn("%s: rx_urb submit failed: %d", __FUNCTION__, res);
-	FILL_INT_URB(dev->intr_urb, dev->udev, usb_rcvintpipe(dev->udev, 3),
+	usb_fill_int_urb(dev->intr_urb, dev->udev, usb_rcvintpipe(dev->udev, 3),
 		     dev->intr_buff, sizeof(dev->intr_buff), intr_callback,
 		     dev, dev->intr_interval);
 	if ((res = usb_submit_urb(dev->intr_urb, GFP_KERNEL)))
@@ -789,7 +789,7 @@ static int rtl8150_probe(struct usb_interface *intf,
 	rtl8150_t *dev;
 	struct net_device *netdev;
 
-	if (usb_set_configuration(udev, udev->config[0].bConfigurationValue)) {
+	if (usb_set_configuration(udev, udev->config[0].desc.bConfigurationValue)) {
 		err("usb_set_configuration() failed");
 		return -EIO;
 	}
diff --git a/drivers/usb/net/usbnet.c b/drivers/usb/net/usbnet.c
index 9c21bc806400..69a67505b02c 100644
--- a/drivers/usb/net/usbnet.c
+++ b/drivers/usb/net/usbnet.c
@@ -532,7 +532,7 @@ static int genelink_init (struct usbnet *dev)
 	}
 
 	// fill irq urb
-	FILL_INT_URB (priv->irq_urb, dev->udev,
+	usb_fill_int_urb (priv->irq_urb, dev->udev,
 		usb_rcvintpipe (dev->udev, GENELINK_INTERRUPT_PIPE),
 		priv->irq_buf, INTERRUPT_BUFSIZE,
 		gl_interrupt_complete, 0,
@@ -1472,14 +1472,14 @@ static void rx_submit (struct usbnet *dev, struct urb *urb, int flags)
 	entry->state = rx_start;
 	entry->length = 0;
 
-	FILL_BULK_URB (urb, dev->udev,
+	usb_fill_bulk_urb (urb, dev->udev,
 		usb_rcvbulkpipe (dev->udev, dev->driver_info->in),
 		skb->data, size, rx_complete, skb);
-	urb->transfer_flags |= USB_ASYNC_UNLINK;
+	urb->transfer_flags |= URB_ASYNC_UNLINK;
 #if 0
 	// Idle-but-posted reads with UHCI really chew up
 	// PCI bandwidth unless FSBR is disabled
-	urb->transfer_flags |= USB_NO_FSBR;
+	urb->transfer_flags |= URB_NO_FSBR;
 #endif
 
 	spin_lock_irqsave (&dev->rxq.lock, lockflags);
@@ -1954,10 +1954,10 @@ static int usbnet_start_xmit (struct sk_buff *skb, struct net_device *net)
 	if ((length % EP_SIZE (dev)) == 0)
 		skb->len++;
 
-	FILL_BULK_URB (urb, dev->udev,
+	usb_fill_bulk_urb (urb, dev->udev,
 			usb_sndbulkpipe (dev->udev, info->out),
 			skb->data, skb->len, tx_complete, skb);
-	urb->transfer_flags |= USB_ASYNC_UNLINK;
+	urb->transfer_flags |= URB_ASYNC_UNLINK;
 	// FIXME urb->timeout = ... jiffies ... ;
 
 	spin_lock_irqsave (&dev->txq.lock, flags);
@@ -2125,7 +2125,7 @@ usbnet_probe (struct usb_interface *udev, const struct usb_device_id *prod)
 {
 	struct usbnet			*dev;
 	struct net_device 		*net;
-	struct usb_interface_descriptor	*interface;
+	struct usb_host_interface	*interface;
 	struct driver_info		*info;
 	struct usb_device		*xdev;
 
@@ -2135,8 +2135,8 @@ usbnet_probe (struct usb_interface *udev, const struct usb_device_id *prod)
 	interface = &udev->altsetting [udev->act_altsetting];
 
 	if (!(info->flags & FLAG_NO_SETINT)) {
-		if (usb_set_interface (xdev, interface->bInterfaceNumber,
-				interface->bAlternateSetting) < 0) {
+		if (usb_set_interface (xdev, interface->desc.bInterfaceNumber,
+				interface->desc.bAlternateSetting) < 0) {
 			err ("set_interface failed");
 			return -EIO;
 		}
diff --git a/drivers/usb/serial/cyberjack.c b/drivers/usb/serial/cyberjack.c
index 5806d3e173b3..75d55155ba15 100644
--- a/drivers/usb/serial/cyberjack.c
+++ b/drivers/usb/serial/cyberjack.c
@@ -244,7 +244,7 @@ static int cyberjack_write (struct usb_serial_port *port, int from_user, const u
 		priv->wrsent=length;
 
 		/* set up our urb */
-		FILL_BULK_URB(port->write_urb, serial->dev, 
+		usb_fill_bulk_urb(port->write_urb, serial->dev, 
 			      usb_sndbulkpipe(serial->dev, port->bulk_out_endpointAddress),
 			      port->write_urb->transfer_buffer, length,
 			      ((serial->type->write_bulk_callback) ? 
@@ -422,7 +422,7 @@ static void cyberjack_write_bulk_callback (struct urb *urb)
 		priv->wrsent+=length;
 
 		/* set up our urb */
-		FILL_BULK_URB(port->write_urb, serial->dev, 
+		usb_fill_bulk_urb(port->write_urb, serial->dev, 
 			      usb_sndbulkpipe(serial->dev, port->bulk_out_endpointAddress),
 			      port->write_urb->transfer_buffer, length,
 			      ((serial->type->write_bulk_callback) ? 
diff --git a/drivers/usb/serial/empeg.c b/drivers/usb/serial/empeg.c
index ac3f11202cae..f006bab74df0 100644
--- a/drivers/usb/serial/empeg.c
+++ b/drivers/usb/serial/empeg.c
@@ -168,7 +168,7 @@ static int empeg_open (struct usb_serial_port *port, struct file *filp)
 	bytes_out = 0;
 
 	/* Start reading from the device */
-	FILL_BULK_URB(
+	usb_fill_bulk_urb(
 		port->read_urb,
 		serial->dev, 
 		usb_rcvbulkpipe(serial->dev,
@@ -265,7 +265,7 @@ static int empeg_write (struct usb_serial_port *port, int from_user, const unsig
 		}
 
 		/* build up our urb */
-		FILL_BULK_URB (
+		usb_fill_bulk_urb (
 			urb,
 			serial->dev,
 			usb_sndbulkpipe(serial->dev,
@@ -413,7 +413,7 @@ static void empeg_read_bulk_callback (struct urb *urb)
 	}
 
 	/* Continue trying to always read  */
-	FILL_BULK_URB(
+	usb_fill_bulk_urb(
 		port->read_urb,
 		serial->dev, 
 		usb_rcvbulkpipe(serial->dev,
diff --git a/drivers/usb/serial/ftdi_sio.c b/drivers/usb/serial/ftdi_sio.c
index 2df1a6ca0f66..fe4a96240096 100644
--- a/drivers/usb/serial/ftdi_sio.c
+++ b/drivers/usb/serial/ftdi_sio.c
@@ -346,7 +346,7 @@ static int  ftdi_sio_open (struct usb_serial_port *port, struct file *filp)
 	}
 
 	/* Start reading from the device */
-	FILL_BULK_URB(port->read_urb, serial->dev, 
+	usb_fill_bulk_urb(port->read_urb, serial->dev, 
 		      usb_rcvbulkpipe(serial->dev, port->bulk_in_endpointAddress),
 		      port->read_urb->transfer_buffer, port->read_urb->transfer_buffer_length,
 		      ftdi_sio_read_bulk_callback, port);
@@ -449,7 +449,7 @@ static int ftdi_sio_write (struct usb_serial_port *port, int from_user,
 	usb_serial_debug_data (__FILE__, __FUNCTION__, count, first_byte);
 		
 	/* send the data out the bulk port */
-	FILL_BULK_URB(port->write_urb, serial->dev, 
+	usb_fill_bulk_urb(port->write_urb, serial->dev, 
 		      usb_sndbulkpipe(serial->dev, port->bulk_out_endpointAddress),
 		      port->write_urb->transfer_buffer, count,
 		      ftdi_sio_write_bulk_callback, port);
@@ -608,7 +608,7 @@ static void ftdi_sio_read_bulk_callback (struct urb *urb)
 #endif
 
 	/* Continue trying to always read  */
-	FILL_BULK_URB(port->read_urb, serial->dev, 
+	usb_fill_bulk_urb(port->read_urb, serial->dev, 
 		      usb_rcvbulkpipe(serial->dev, port->bulk_in_endpointAddress),
 		      port->read_urb->transfer_buffer, port->read_urb->transfer_buffer_length,
 		      ftdi_sio_read_bulk_callback, port);
diff --git a/drivers/usb/serial/io_edgeport.c b/drivers/usb/serial/io_edgeport.c
index 88d2eae8a915..f777c14abe34 100644
--- a/drivers/usb/serial/io_edgeport.c
+++ b/drivers/usb/serial/io_edgeport.c
@@ -1479,7 +1479,7 @@ static void send_more_port_data(struct edgeport_serial *edge_serial, struct edge
 	}
 
 	/* fill up the urb with all of our data and submit it */
-	FILL_BULK_URB (urb, edge_serial->serial->dev, 
+	usb_fill_bulk_urb (urb, edge_serial->serial->dev, 
 		       usb_sndbulkpipe(edge_serial->serial->dev, edge_serial->bulk_out_endpoint),
 		       buffer, count+2, edge_bulk_out_data_callback, edge_port);
 
@@ -2504,7 +2504,7 @@ static int write_cmd_usb (struct edgeport_port *edge_port, unsigned char *buffer
 	CmdUrbs++;
 	dbg("%s - ALLOCATE URB %p (outstanding %d)", __FUNCTION__, urb, CmdUrbs);
 
-	FILL_BULK_URB (urb, edge_serial->serial->dev, 
+	usb_fill_bulk_urb (urb, edge_serial->serial->dev, 
 		       usb_sndbulkpipe(edge_serial->serial->dev, edge_serial->bulk_out_endpoint),
 		       buffer, length, edge_bulk_out_cmd_callback, edge_port);
 
diff --git a/drivers/usb/serial/io_ti.c b/drivers/usb/serial/io_ti.c
index df4b5ff95a7b..4ac6d31bfd38 100644
--- a/drivers/usb/serial/io_ti.c
+++ b/drivers/usb/serial/io_ti.c
@@ -588,10 +588,10 @@ static int TIChooseConfiguration (struct usb_device *dev)
 	// we want. However, we just support one config at this point,
 	// configuration # 1, which is Config Descriptor 0.
 
-	dbg ("%s - Number of Interfaces = %d", __FUNCTION__, dev->config->bNumInterfaces);
-	dbg ("%s - MAX Power            = %d", __FUNCTION__, dev->config->MaxPower*2);
+	dbg ("%s - Number of Interfaces = %d", __FUNCTION__, dev->config->desc.bNumInterfaces);
+	dbg ("%s - MAX Power            = %d", __FUNCTION__, dev->config->desc.bMaxPower*2);
 
-	if (dev->config->bNumInterfaces != 1) {
+	if (dev->config->desc.bNumInterfaces != 1) {
 		err ("%s - bNumInterfaces is not 1, ERROR!", __FUNCTION__);
 		return -ENODEV;
 	}
@@ -980,7 +980,7 @@ static int TIDownloadFirmware (struct edgeport_serial *serial)
 	if (status)
 		return status;
 
-	interface = serial->serial->dev->config->interface->altsetting;
+	interface = &serial->serial->dev->config->interface->altsetting->desc;
 	if (!interface) {
 		err ("%s - no interface set, error!", __FUNCTION__);
 		return -ENODEV;
diff --git a/drivers/usb/serial/ipaq.c b/drivers/usb/serial/ipaq.c
index cc0beb63d50c..c4a145cb5aa2 100644
--- a/drivers/usb/serial/ipaq.c
+++ b/drivers/usb/serial/ipaq.c
@@ -200,7 +200,7 @@ static int ipaq_open(struct usb_serial_port *port, struct file *filp)
 	port->bulk_out_size = port->write_urb->transfer_buffer_length = URBDATA_SIZE;
 	
 	/* Start reading from the device */
-	FILL_BULK_URB(port->read_urb, serial->dev, 
+	usb_fill_bulk_urb(port->read_urb, serial->dev, 
 		      usb_rcvbulkpipe(serial->dev, port->bulk_in_endpointAddress),
 		      port->read_urb->transfer_buffer, port->read_urb->transfer_buffer_length,
 		      ipaq_read_bulk_callback, port);
@@ -308,7 +308,7 @@ static void ipaq_read_bulk_callback(struct urb *urb)
 	}
 
 	/* Continue trying to always read  */
-	FILL_BULK_URB(port->read_urb, serial->dev, 
+	usb_fill_bulk_urb(port->read_urb, serial->dev, 
 		      usb_rcvbulkpipe(serial->dev, port->bulk_in_endpointAddress),
 		      port->read_urb->transfer_buffer, port->read_urb->transfer_buffer_length,
 		      ipaq_read_bulk_callback, port);
@@ -429,7 +429,7 @@ static void ipaq_write_gather(struct usb_serial_port *port)
 	}
 
 	count = URBDATA_SIZE - room;
-	FILL_BULK_URB(port->write_urb, serial->dev, 
+	usb_fill_bulk_urb(port->write_urb, serial->dev, 
 		      usb_sndbulkpipe(serial->dev, port->bulk_out_endpointAddress),
 		      port->write_urb->transfer_buffer, count, ipaq_write_bulk_callback,
 		      port);
diff --git a/drivers/usb/serial/ir-usb.c b/drivers/usb/serial/ir-usb.c
index 307b62a32652..e11b418d6474 100644
--- a/drivers/usb/serial/ir-usb.c
+++ b/drivers/usb/serial/ir-usb.c
@@ -395,7 +395,7 @@ static int ir_write (struct usb_serial_port *port, int from_user, const unsigned
 		ir_write_bulk_callback,
 		port);
 
-	port->write_urb->transfer_flags = USB_ZERO_PACKET;
+	port->write_urb->transfer_flags = URB_ZERO_PACKET;
 
 	result = usb_submit_urb (port->write_urb, GFP_ATOMIC);
 	if (result)
@@ -597,7 +597,7 @@ static void ir_set_termios (struct usb_serial_port *port, struct termios *old_te
 			ir_write_bulk_callback,
 			port);
 
-		port->write_urb->transfer_flags = USB_ZERO_PACKET;
+		port->write_urb->transfer_flags = URB_ZERO_PACKET;
 
 		result = usb_submit_urb (port->write_urb, GFP_KERNEL);
 		if (result)
diff --git a/drivers/usb/serial/keyspan.c b/drivers/usb/serial/keyspan.c
index 7d2794872c6e..5afe854714ec 100644
--- a/drivers/usb/serial/keyspan.c
+++ b/drivers/usb/serial/keyspan.c
@@ -344,11 +344,11 @@ static int keyspan_write(struct usb_serial_port *port, int from_user,
 		dbg("%s - endpoint %d flip %d", __FUNCTION__, usb_pipeendpoint(this_urb->pipe), flip);
 
 		if (this_urb->status == -EINPROGRESS) {
-			if (this_urb->transfer_flags & USB_ASYNC_UNLINK)
+			if (this_urb->transfer_flags & URB_ASYNC_UNLINK)
 				break;
 			if (jiffies - p_priv->tx_start_time[flip] < 10 * HZ)
 				break;
-			this_urb->transfer_flags |= USB_ASYNC_UNLINK;
+			this_urb->transfer_flags |= URB_ASYNC_UNLINK;
 			usb_unlink_urb(this_urb);
 			break;
 		}
@@ -368,7 +368,7 @@ static int keyspan_write(struct usb_serial_port *port, int from_user,
 		/* send the data out the bulk port */
 		this_urb->transfer_buffer_length = todo + 1;
 
-		this_urb->transfer_flags &= ~USB_ASYNC_UNLINK;
+		this_urb->transfer_flags &= ~URB_ASYNC_UNLINK;
 		this_urb->dev = port->serial->dev;
 		if ((err = usb_submit_urb(this_urb, GFP_ATOMIC)) != 0) {
 			dbg("usb_submit_urb(write bulk) failed (%d)", err);
@@ -912,7 +912,7 @@ static int keyspan_open (struct usb_serial_port *port, struct file *filp)
 static inline void stop_urb(struct urb *urb)
 {
 	if (urb && urb->status == -EINPROGRESS) {
-		urb->transfer_flags &= ~USB_ASYNC_UNLINK;
+		urb->transfer_flags &= ~URB_ASYNC_UNLINK;
 		usb_unlink_urb(urb);
 	}
 }
@@ -1085,7 +1085,7 @@ static struct urb *keyspan_setup_urb (struct usb_serial *serial, int endpoint,
 	}
 
 		/* Fill URB using supplied data. */
-	FILL_BULK_URB(urb, serial->dev,
+	usb_fill_bulk_urb(urb, serial->dev,
 		      usb_sndbulkpipe(serial->dev, endpoint) | dir,
 		      buf, len, callback, ctx);
 
diff --git a/drivers/usb/serial/kl5kusb105.c b/drivers/usb/serial/kl5kusb105.c
index 47312691cc43..f97774827372 100644
--- a/drivers/usb/serial/kl5kusb105.c
+++ b/drivers/usb/serial/kl5kusb105.c
@@ -390,7 +390,7 @@ static int  klsi_105_open (struct usb_serial_port *port, struct file *filp)
 
 
 	/* READ_ON and urb submission */
-	FILL_BULK_URB(port->read_urb, serial->dev, 
+	usb_fill_bulk_urb(port->read_urb, serial->dev, 
 		      usb_rcvbulkpipe(serial->dev,
 				      port->bulk_in_endpointAddress),
 		      port->read_urb->transfer_buffer,
@@ -534,7 +534,7 @@ static int klsi_105_write (struct usb_serial_port *port, int from_user,
 		((__u8 *)urb->transfer_buffer)[1] = (__u8) ((size & 0xFF00)>>8);
 
 		/* set up our urb */
-		FILL_BULK_URB(urb, serial->dev,
+		usb_fill_bulk_urb(urb, serial->dev,
 			      usb_sndbulkpipe(serial->dev,
 					      port->bulk_out_endpointAddress),
 			      urb->transfer_buffer,
@@ -697,7 +697,7 @@ static void klsi_105_read_bulk_callback (struct urb *urb)
 		priv->bytes_in += bytes_sent;
 	}
 	/* Continue trying to always read  */
-	FILL_BULK_URB(port->read_urb, serial->dev, 
+	usb_fill_bulk_urb(port->read_urb, serial->dev, 
 		      usb_rcvbulkpipe(serial->dev,
 				      port->bulk_in_endpointAddress),
 		      port->read_urb->transfer_buffer,
diff --git a/drivers/usb/serial/mct_u232.c b/drivers/usb/serial/mct_u232.c
index 0cdb7e44933c..5b7a48de3b2c 100644
--- a/drivers/usb/serial/mct_u232.c
+++ b/drivers/usb/serial/mct_u232.c
@@ -450,7 +450,7 @@ static int mct_u232_write (struct usb_serial_port *port, int from_user,
 		}
 		
 		/* set up our urb */
-		FILL_BULK_URB(port->write_urb, serial->dev,
+		usb_fill_bulk_urb(port->write_urb, serial->dev,
 			      usb_sndbulkpipe(serial->dev,
 					      port->bulk_out_endpointAddress),
 			      port->write_urb->transfer_buffer, size,
diff --git a/drivers/usb/serial/omninet.c b/drivers/usb/serial/omninet.c
index b4d5fa960435..541bcdbe8f61 100644
--- a/drivers/usb/serial/omninet.c
+++ b/drivers/usb/serial/omninet.c
@@ -172,7 +172,7 @@ static int omninet_open (struct usb_serial_port *port, struct file *filp)
 	wport->tty = port->tty;
 
 	/* Start reading from the device */
-	FILL_BULK_URB(port->read_urb, serial->dev, 
+	usb_fill_bulk_urb(port->read_urb, serial->dev, 
 		      usb_rcvbulkpipe(serial->dev, port->bulk_in_endpointAddress),
 		      port->read_urb->transfer_buffer, port->read_urb->transfer_buffer_length,
 		      omninet_read_bulk_callback, port);
@@ -255,7 +255,7 @@ static void omninet_read_bulk_callback (struct urb *urb)
 	}
 
 	/* Continue trying to always read  */
-	FILL_BULK_URB(urb, serial->dev, 
+	usb_fill_bulk_urb(urb, serial->dev, 
 		      usb_rcvbulkpipe(serial->dev, port->bulk_in_endpointAddress),
 		      urb->transfer_buffer, urb->transfer_buffer_length,
 		      omninet_read_bulk_callback, port);
diff --git a/drivers/usb/serial/safe_serial.c b/drivers/usb/serial/safe_serial.c
index 1f64274873de..31301e598125 100644
--- a/drivers/usb/serial/safe_serial.c
+++ b/drivers/usb/serial/safe_serial.c
@@ -270,7 +270,7 @@ static void safe_read_bulk_callback (struct urb *urb)
 	}
 
 	/* Continue trying to always read  */
-	FILL_BULK_URB (urb, serial->dev,
+	usb_fill_bulk_urb (urb, serial->dev,
 		       usb_rcvbulkpipe (serial->dev, port->bulk_in_endpointAddress),
 		       urb->transfer_buffer, urb->transfer_buffer_length,
 		       safe_read_bulk_callback, port);
@@ -393,7 +393,7 @@ static int safe_write_room (struct usb_serial_port *port)
 
 static int safe_startup (struct usb_serial *serial)
 {
-	switch (serial->interface->altsetting->bInterfaceProtocol) {
+	switch (serial->interface->altsetting->desc.bInterfaceProtocol) {
 	case LINEO_SAFESERIAL_CRC:
 		break;
 	case LINEO_SAFESERIAL_CRC_PADDED:
diff --git a/drivers/usb/serial/usb-serial.c b/drivers/usb/serial/usb-serial.c
index 4cb3cb879e1b..75510b41e8ab 100644
--- a/drivers/usb/serial/usb-serial.c
+++ b/drivers/usb/serial/usb-serial.c
@@ -1147,7 +1147,7 @@ int usb_serial_probe(struct usb_interface *interface,
 	struct usb_device *dev = interface_to_usbdev (interface);
 	struct usb_serial *serial = NULL;
 	struct usb_serial_port *port;
-	struct usb_interface_descriptor *iface_desc;
+	struct usb_host_interface *iface_desc;
 	struct usb_endpoint_descriptor *endpoint;
 	struct usb_endpoint_descriptor *interrupt_in_endpoint[MAX_NUM_PORTS];
 	struct usb_endpoint_descriptor *bulk_in_endpoint[MAX_NUM_PORTS];
@@ -1208,8 +1208,8 @@ int usb_serial_probe(struct usb_interface *interface,
 	/* descriptor matches, let's find the endpoints needed */
 	/* check out the endpoints */
 	iface_desc = &interface->altsetting[0];
-	for (i = 0; i < iface_desc->bNumEndpoints; ++i) {
-		endpoint = &iface_desc->endpoint[i];
+	for (i = 0; i < iface_desc->desc.bNumEndpoints; ++i) {
+		endpoint = &iface_desc->endpoint[i].desc;
 		
 		if ((endpoint->bEndpointAddress & 0x80) &&
 		    ((endpoint->bmAttributes & 3) == 0x02)) {
@@ -1249,8 +1249,8 @@ int usb_serial_probe(struct usb_interface *interface,
 			//interface = &dev->actconfig->interface[ifnum ^ 1];
 			interface = &dev->actconfig->interface[0];
 			iface_desc = &interface->altsetting[0];
-			for (i = 0; i < iface_desc->bNumEndpoints; ++i) {
-				endpoint = &iface_desc->endpoint[i];
+			for (i = 0; i < iface_desc->desc.bNumEndpoints; ++i) {
+				endpoint = &iface_desc->endpoint[i].desc;
 				if ((endpoint->bEndpointAddress & 0x80) &&
 				    ((endpoint->bmAttributes & 3) == 0x03)) {
 					/* we found a interrupt in endpoint */
diff --git a/drivers/usb/storage/scsiglue.c b/drivers/usb/storage/scsiglue.c
index 928b739597b4..1db93f62063c 100644
--- a/drivers/usb/storage/scsiglue.c
+++ b/drivers/usb/storage/scsiglue.c
@@ -249,7 +249,7 @@ static int bus_reset( Scsi_Cmnd *srb )
 	/* FIXME: This needs to lock out driver probing while it's working
 	 * or we can have race conditions */
 	/* This functionality really should be provided by the khubd thread */
-	for (i = 0; i < pusb_dev_save->actconfig->bNumInterfaces; i++) {
+	for (i = 0; i < pusb_dev_save->actconfig->desc.bNumInterfaces; i++) {
  		struct usb_interface *intf =
 			&pusb_dev_save->actconfig->interface[i];
 
diff --git a/drivers/usb/storage/transport.c b/drivers/usb/storage/transport.c
index 6820bdc91e1b..b216f61e7919 100644
--- a/drivers/usb/storage/transport.c
+++ b/drivers/usb/storage/transport.c
@@ -381,7 +381,7 @@ unsigned int usb_stor_transfer_length(Scsi_Cmnd *srb)
  * before the submission or before setting the CAN_CANCEL bit.  If so, it's
  * essential to abort the URB if it hasn't been cancelled already (i.e.,
  * if the CAN_CANCEL bit is still set).  Either way, the function must then
- * wait for the URB to finish.  Note that because the USB_ASYNC_UNLINK flag
+ * wait for the URB to finish.  Note that because the URB_ASYNC_UNLINK flag
  * is set, the URB can still be in progress even after a call to
  * usb_unlink_urb() returns.
  *
@@ -426,7 +426,7 @@ static int usb_stor_msg_common(struct us_data *us)
 	us->current_urb->context = &urb_done;
 	us->current_urb->actual_length = 0;
 	us->current_urb->error_count = 0;
-	us->current_urb->transfer_flags = USB_ASYNC_UNLINK;
+	us->current_urb->transfer_flags = URB_ASYNC_UNLINK;
 
 	/* submit the URB */
 	status = usb_submit_urb(us->current_urb, GFP_NOIO);
@@ -474,7 +474,7 @@ int usb_stor_control_msg(struct us_data *us, unsigned int pipe,
 	us->dr->wLength = cpu_to_le16(size);
 
 	/* fill and submit the URB */
-	FILL_CONTROL_URB(us->current_urb, us->pusb_dev, pipe, 
+	usb_fill_control_urb(us->current_urb, us->pusb_dev, pipe, 
 			 (unsigned char*) us->dr, data, size, 
 			 usb_stor_blocking_completion, NULL);
 	status = usb_stor_msg_common(us);
@@ -494,7 +494,7 @@ int usb_stor_bulk_msg(struct us_data *us, void *data, unsigned int pipe,
 	int status;
 
 	/* fill and submit the URB */
-	FILL_BULK_URB(us->current_urb, us->pusb_dev, pipe, data, len,
+	usb_fill_bulk_urb(us->current_urb, us->pusb_dev, pipe, data, len,
 		      usb_stor_blocking_completion, NULL);
 	status = usb_stor_msg_common(us);
 
diff --git a/drivers/usb/storage/usb.c b/drivers/usb/storage/usb.c
index a463fe4544aa..445cb612db2a 100644
--- a/drivers/usb/storage/usb.c
+++ b/drivers/usb/storage/usb.c
@@ -577,7 +577,7 @@ static int usb_stor_allocate_urbs(struct us_data *ss)
 			maxp = sizeof(ss->irqbuf);
 
 		/* fill in the URB with our data */
-		FILL_INT_URB(ss->irq_urb, ss->pusb_dev, pipe, ss->irqbuf,
+		usb_fill_int_urb(ss->irq_urb, ss->pusb_dev, pipe, ss->irqbuf,
 			maxp, usb_stor_CBI_irq, ss, ss->ep_int->bInterval); 
 
 		/* submit the URB for processing */
@@ -646,7 +646,7 @@ static int storage_probe(struct usb_interface *intf,
 			 const struct usb_device_id *id)
 {
 	struct usb_device *dev = interface_to_usbdev(intf);
-	int ifnum = intf->altsetting->bInterfaceNumber;
+	int ifnum = intf->altsetting->desc.bInterfaceNumber;
 	int i;
 	const int id_index = id - storage_usb_ids; 
 	char mf[USB_STOR_STRING_LEN];		     /* manufacturer */
@@ -671,7 +671,7 @@ static int storage_probe(struct usb_interface *intf,
 	/* the altsetting on the interface we're probing that matched our
 	 * usb_match_id table
 	 */
-	struct usb_interface_descriptor *altsetting =
+	struct usb_host_interface *altsetting =
 		intf[ifnum].altsetting + intf[ifnum].act_altsetting;
 	US_DEBUGP("act_altsetting is %d\n", intf[ifnum].act_altsetting);
 
@@ -716,22 +716,25 @@ static int storage_probe(struct usb_interface *intf,
 	 * An optional interrupt is OK (necessary for CBI protocol).
 	 * We will ignore any others.
 	 */
-	for (i = 0; i < altsetting->bNumEndpoints; i++) {
+	for (i = 0; i < altsetting->desc.bNumEndpoints; i++) {
+		struct usb_endpoint_descriptor *ep;
+
+		ep = &altsetting->endpoint[i].desc;
+
 		/* is it an BULK endpoint? */
-		if ((altsetting->endpoint[i].bmAttributes & 
-		     USB_ENDPOINT_XFERTYPE_MASK) == USB_ENDPOINT_XFER_BULK) {
+		if ((ep->bmAttributes & USB_ENDPOINT_XFERTYPE_MASK)
+				== USB_ENDPOINT_XFER_BULK) {
 			/* BULK in or out? */
-			if (altsetting->endpoint[i].bEndpointAddress & 
-			    USB_DIR_IN)
-				ep_in = &altsetting->endpoint[i];
+			if (ep->bEndpointAddress & USB_DIR_IN)
+				ep_in = ep;
 			else
-				ep_out = &altsetting->endpoint[i];
+				ep_out = ep;
 		}
 
 		/* is it an interrupt endpoint? */
-		if ((altsetting->endpoint[i].bmAttributes & 
-		     USB_ENDPOINT_XFERTYPE_MASK) == USB_ENDPOINT_XFER_INT) {
-			ep_int = &altsetting->endpoint[i];
+		else if ((ep->bmAttributes & USB_ENDPOINT_XFERTYPE_MASK)
+				== USB_ENDPOINT_XFER_INT) {
+			ep_int = ep;
 		}
 	}
 	US_DEBUGP("Endpoints: In: 0x%p Out: 0x%p Int: 0x%p (Period %d)\n",
diff --git a/drivers/usb/usb-skeleton.c b/drivers/usb/usb-skeleton.c
index bae45783a718..97aa1a3556db 100644
--- a/drivers/usb/usb-skeleton.c
+++ b/drivers/usb/usb-skeleton.c
@@ -428,7 +428,7 @@ static ssize_t skel_write (struct file *file, const char *buffer, size_t count,
 			     dev->write_urb->transfer_buffer);
 
 	/* set up our urb */
-	FILL_BULK_URB(dev->write_urb, dev->udev, 
+	usb_fill_bulk_urb(dev->write_urb, dev->udev, 
 		      usb_sndbulkpipe(dev->udev, dev->bulk_out_endpointAddr),
 		      dev->write_urb->transfer_buffer, bytes_written,
 		      skel_write_bulk_callback, dev);
@@ -555,7 +555,7 @@ static int skel_probe(struct usb_interface *interface, const struct usb_device_i
 	/* check out the endpoints */
 	iface_desc = &interface->altsetting[0];
 	for (i = 0; i < iface_desc->bNumEndpoints; ++i) {
-		endpoint = &iface_desc->endpoint[i];
+		endpoint = &iface_desc->endpoint[i].desc;
 
 		if ((endpoint->bEndpointAddress & 0x80) &&
 		    ((endpoint->bmAttributes & 3) == 0x02)) {
@@ -587,7 +587,7 @@ static int skel_probe(struct usb_interface *interface, const struct usb_device_i
 				err("Couldn't allocate bulk_out_buffer");
 				goto error;
 			}
-			FILL_BULK_URB(dev->write_urb, udev, 
+			usb_fill_bulk_urb(dev->write_urb, udev, 
 				      usb_sndbulkpipe(udev, 
 						      endpoint->bEndpointAddress),
 				      dev->bulk_out_buffer, buffer_size,
diff --git a/include/linux/usb.h b/include/linux/usb.h
index 0397f55aabdc..0f486d95bdb7 100644
--- a/include/linux/usb.h
+++ b/include/linux/usb.h
@@ -41,56 +41,36 @@ struct usb_device;
 /*-------------------------------------------------------------------------*/
 
 /*
- * Standard USB Descriptor support.
+ * Host-side wrappers for standard USB descriptors ... these are parsed
+ * from the data provided by devices.  Parsing turns them from a flat
+ * sequence of descriptors into a hierarchy:
+ *
+ *  - devices have one (usually) or more configs;
+ *  - configs have one (often) or more interfaces;
+ *  - interfaces have one (usually) or more settings;
+ *  - each interface setting has zero or (usually) more endpoints.
+ *
+ * And there might be other descriptors mixed in with those.
+ *
  * Devices may also have class-specific or vendor-specific descriptors.
  */
 
-/*
- * Descriptor sizes per descriptor type
- */
-#define USB_DT_DEVICE_SIZE		18
-#define USB_DT_CONFIG_SIZE		9
-#define USB_DT_INTERFACE_SIZE		9
-#define USB_DT_ENDPOINT_SIZE		7
-#define USB_DT_ENDPOINT_AUDIO_SIZE	9	/* Audio extension */
-
-/* most of these maximums are arbitrary */
-#define USB_MAXCONFIG			8
-#define USB_ALTSETTINGALLOC		4
-#define USB_MAXALTSETTING		128	/* Hard limit */
-#define USB_MAXINTERFACES		32
-#define USB_MAXENDPOINTS		32	/* Hard limit */
-
-/* USB_DT_ENDPOINT: Endpoint descriptor */
-struct usb_endpoint_descriptor {
-	__u8  bLength		__attribute__ ((packed));
-	__u8  bDescriptorType	__attribute__ ((packed));
-	__u8  bEndpointAddress	__attribute__ ((packed));
-	__u8  bmAttributes	__attribute__ ((packed));
-	__u16 wMaxPacketSize	__attribute__ ((packed));
-	__u8  bInterval		__attribute__ ((packed));
-	__u8  bRefresh		__attribute__ ((packed));
-	__u8  bSynchAddress	__attribute__ ((packed));
-
-	/* the rest is internal to the Linux implementation */
+/* host-side wrapper for parsed endpoint descriptors */
+struct usb_host_endpoint {
+	struct usb_endpoint_descriptor	desc;
+
 	unsigned char *extra;   /* Extra descriptors */
 	int extralen;
 };
 
-/* USB_DT_INTERFACE: Interface descriptor */
-struct usb_interface_descriptor {
-	__u8  bLength		__attribute__ ((packed));
-	__u8  bDescriptorType	__attribute__ ((packed));
-	__u8  bInterfaceNumber	__attribute__ ((packed));
-	__u8  bAlternateSetting	__attribute__ ((packed));
-	__u8  bNumEndpoints	__attribute__ ((packed));
-	__u8  bInterfaceClass	__attribute__ ((packed));
-	__u8  bInterfaceSubClass __attribute__ ((packed));
-	__u8  bInterfaceProtocol __attribute__ ((packed));
-	__u8  iInterface	__attribute__ ((packed));
-
-	/* the rest is internal to the Linux implementation */
-	struct usb_endpoint_descriptor *endpoint;
+/* host-side wrapper for one interface setting's parsed descriptors */
+struct usb_host_interface {
+	struct usb_interface_descriptor	desc;
+
+	/* array of desc.bNumEndpoint endpoints associated with this
+	 * interface setting.  these will be in no particular order.
+	 */
+	struct usb_host_endpoint *endpoint;
 
 	unsigned char *extra;   /* Extra descriptors */
 	int extralen;
@@ -127,7 +107,10 @@ struct usb_interface_descriptor {
  * will use them in non-default settings.
  */
 struct usb_interface {
-	struct usb_interface_descriptor *altsetting;
+	/* array of alternate settings for this interface.
+	 * these will be in numeric order, 0..num_altsettting
+	 */
+	struct usb_host_interface *altsetting;
 
 	unsigned act_altsetting;	/* active alternate setting */
 	unsigned num_altsetting;	/* number of alternate settings */
@@ -148,17 +131,12 @@ struct usb_interface {
  * different depending on what speed they're currently running.  Only
  * devices with a USB_DT_DEVICE_QUALIFIER have an OTHER_SPEED_CONFIG.
  */
-struct usb_config_descriptor {
-	__u8  bLength		__attribute__ ((packed));
-	__u8  bDescriptorType	__attribute__ ((packed));
-	__u16 wTotalLength	__attribute__ ((packed));
-	__u8  bNumInterfaces	__attribute__ ((packed));
-	__u8  bConfigurationValue __attribute__ ((packed));
-	__u8  iConfiguration	__attribute__ ((packed));
-	__u8  bmAttributes	__attribute__ ((packed));
-	__u8  MaxPower		__attribute__ ((packed));
-
-	/* the rest is internal to the Linux implementation */
+struct usb_host_config {
+	struct usb_config_descriptor	desc;
+
+	/* the interfaces associated with this configuration
+	 * these will be in numeric order, 0..desc.bNumInterfaces
+	 */
 	struct usb_interface *interface;
 
 	unsigned char *extra;   /* Extra descriptors */
@@ -178,8 +156,6 @@ int __usb_get_extra_descriptor(char *buffer, unsigned size,
 
 /* -------------------------------------------------------------------------- */
 
-/* Host Controller Driver (HCD) support */
-
 struct usb_operations;
 
 /*
@@ -248,8 +224,8 @@ struct usb_device {
 	struct device dev;		/* Generic device interface */
 
 	struct usb_device_descriptor descriptor;/* Descriptor */
-	struct usb_config_descriptor *config;	/* All of the configs */
-	struct usb_config_descriptor *actconfig;/* the active configuration */
+	struct usb_host_config *config;	/* All of the configs */
+	struct usb_host_config *actconfig;/* the active configuration */
 
 	char **rawdescriptors;		/* Raw descriptors for each config */
 
@@ -560,17 +536,15 @@ extern int usb_disabled(void);
 
 /*
  * urb->transfer_flags:
- *
- * FIXME should _all_ be URB_* flags
  */
 #define URB_SHORT_NOT_OK	0x0001	/* report short reads as errors */
-#define USB_ISO_ASAP		0x0002	/* iso-only, urb->start_frame ignored */
+#define URB_ISO_ASAP		0x0002	/* iso-only, urb->start_frame ignored */
 #define URB_NO_DMA_MAP		0x0004	/* urb->*_dma are valid on submit */
-#define USB_ASYNC_UNLINK	0x0008	/* usb_unlink_urb() returns asap */
-#define USB_NO_FSBR		0x0020	/* UHCI-specific */
-#define USB_ZERO_PACKET		0x0040	/* Finish bulk OUTs with short packet */
+#define URB_ASYNC_UNLINK	0x0008	/* usb_unlink_urb() returns asap */
+#define URB_NO_FSBR		0x0020	/* UHCI-specific */
+#define URB_ZERO_PACKET		0x0040	/* Finish bulk OUTs with short packet */
 #define URB_NO_INTERRUPT	0x0080	/* HINT: no non-error interrupt needed */
-#define USB_TIMEOUT_KILLED	0x1000	/* only set by HCD! */
+#define URB_TIMEOUT_KILLED	0x1000	/* only set by HCD! */
 
 struct usb_iso_packet_descriptor {
 	unsigned int offset;
@@ -674,7 +648,7 @@ typedef void (*usb_complete_t)(struct urb *);
  *
  * All URBs submitted must initialize dev, pipe,
  * transfer_flags (may be zero), complete, timeout (may be zero).
- * The USB_ASYNC_UNLINK transfer flag affects later invocations of
+ * The URB_ASYNC_UNLINK transfer flag affects later invocations of
  * the usb_unlink_urb() routine.
  *
  * All URBs must also initialize 
@@ -683,7 +657,7 @@ typedef void (*usb_complete_t)(struct urb *);
  * to be treated as errors; that flag is invalid for write requests.
  *
  * Bulk URBs may
- * use the USB_ZERO_PACKET transfer flag, indicating that bulk OUT transfers
+ * use the URB_ZERO_PACKET transfer flag, indicating that bulk OUT transfers
  * should always terminate with a short packet, even if it means adding an
  * extra zero length packet.
  *
@@ -700,7 +674,7 @@ typedef void (*usb_complete_t)(struct urb *);
  * endpoints, as well as high speed interrupt endpoints, the encoding of
  * the transfer interval in the endpoint descriptor is logarithmic.)
  *
- * Isochronous URBs normally use the USB_ISO_ASAP transfer flag, telling
+ * Isochronous URBs normally use the URB_ISO_ASAP transfer flag, telling
  * the host controller to schedule the transfer as soon as bandwidth
  * utilization allows, and then set start_frame to reflect the actual frame
  * selected during submission.  Otherwise drivers must specify the start_frame
@@ -872,17 +846,6 @@ static inline void usb_fill_int_urb (struct urb *urb,
 	urb->start_frame = -1;
 }
 
-/*
- * old style macros to enable 2.4 and 2.2 drivers to build
- * properly.  Please do not use these for new USB drivers.
- */
-#define FILL_CONTROL_URB(URB,DEV,PIPE,SETUP_PACKET,TRANSFER_BUFFER,BUFFER_LENGTH,COMPLETE,CONTEXT) \
-    usb_fill_control_urb(URB,DEV,PIPE,SETUP_PACKET,TRANSFER_BUFFER,BUFFER_LENGTH,COMPLETE,CONTEXT)
-#define FILL_BULK_URB(URB,DEV,PIPE,TRANSFER_BUFFER,BUFFER_LENGTH,COMPLETE,CONTEXT) \
-    usb_fill_bulk_urb(URB,DEV,PIPE,TRANSFER_BUFFER,BUFFER_LENGTH,COMPLETE,CONTEXT)
-#define FILL_INT_URB(URB,DEV,PIPE,TRANSFER_BUFFER,BUFFER_LENGTH,COMPLETE,CONTEXT,INTERVAL) \
-    usb_fill_int_urb(URB,DEV,PIPE,TRANSFER_BUFFER,BUFFER_LENGTH,COMPLETE,CONTEXT,INTERVAL)
-
 extern struct urb *usb_alloc_urb(int iso_packets, int mem_flags);
 extern void usb_free_urb(struct urb *urb);
 #define usb_put_urb usb_free_urb
diff --git a/include/linux/usb_ch9.h b/include/linux/usb_ch9.h
index 9e05b8c05004..69645ae25aae 100644
--- a/include/linux/usb_ch9.h
+++ b/include/linux/usb_ch9.h
@@ -6,7 +6,7 @@
  *
  * - the master/host side Linux-USB kernel driver API;
  * - the "usbfs" user space API; and
- * - (eventually) a Linux slave/device side driver API.
+ * - (eventually) a Linux "gadget" slave/device side driver API.
  *
  * USB 2.0 adds an additional "On The Go" (OTG) mode, which lets systems
  * act either as a USB master/host or as a USB slave/device.  That means
@@ -101,7 +101,8 @@ struct usb_ctrlrequest {
  * (rarely) accepted by SET_DESCRIPTOR.
  *
  * Note that all multi-byte values here are encoded in little endian
- * byte order.
+ * byte order "on the wire".  But when exposed through Linux-USB APIs,
+ * they've been converted to cpu byte order.
  */
 
 /*
@@ -123,10 +124,13 @@ struct usb_descriptor_header {
 } __attribute__ ((packed));
 
 
+/*-------------------------------------------------------------------------*/
+
 /* USB_DT_DEVICE: Device descriptor */
 struct usb_device_descriptor {
 	__u8  bLength;
 	__u8  bDescriptorType;
+
 	__u16 bcdUSB;
 	__u8  bDeviceClass;
 	__u8  bDeviceSubClass;
@@ -141,10 +145,12 @@ struct usb_device_descriptor {
 	__u8  bNumConfigurations;
 } __attribute__ ((packed));
 
+#define USB_DT_DEVICE_SIZE		18
+
 
 /*
  * Device and/or Interface Class codes
- * as found in device and interface descriptors
+ * as found in bDeviceClass or bInterfaceClass
  * and defined by www.usb.org documents
  */
 #define USB_CLASS_PER_INTERFACE		0	/* for DeviceClass */
@@ -162,18 +168,88 @@ struct usb_device_descriptor {
 #define USB_CLASS_APP_SPEC		0xfe
 #define USB_CLASS_VENDOR_SPEC		0xff
 
-// FIXME include struct usb_config_descriptor
+/*-------------------------------------------------------------------------*/
+
+/* USB_DT_CONFIG: Configuration descriptor information.
+ *
+ * USB_DT_OTHER_SPEED_CONFIG is the same descriptor, except that the
+ * descriptor type is different.  Highspeed-capable devices can look
+ * different depending on what speed they're currently running.  Only
+ * devices with a USB_DT_DEVICE_QUALIFIER have any OTHER_SPEED_CONFIG
+ * descriptors.
+ */
+struct usb_config_descriptor {
+	__u8  bLength;
+	__u8  bDescriptorType;
+
+	__u16 wTotalLength;
+	__u8  bNumInterfaces;
+	__u8  bConfigurationValue;
+	__u8  iConfiguration;
+	__u8  bmAttributes;
+	__u8  bMaxPower;
+} __attribute__ ((packed));
+
+#define USB_DT_CONFIG_SIZE		9
+
+/* from config descriptor bmAttributes */
+#define USB_CONFIG_ATT_ONE		(1 << 7)	/* must be set */
+#define USB_CONFIG_ATT_SELFPOWER	(1 << 6)	/* self powered */
+#define USB_CONFIG_ATT_WAKEUP		(1 << 5)	/* can wakeup */
+
+/*-------------------------------------------------------------------------*/
 
 /* USB_DT_STRING: String descriptor */
 struct usb_string_descriptor {
 	__u8  bLength;
 	__u8  bDescriptorType;
+
 	__u16 wData[1];		/* UTF-16LE encoded */
 } __attribute__ ((packed));
 
-// FIXME include struct usb_interface_descriptor
+/* note that "string" zero is special, it holds language codes that
+ * the device supports, not Unicode characters.
+ */
+
+/*-------------------------------------------------------------------------*/
+
+/* USB_DT_INTERFACE: Interface descriptor */
+struct usb_interface_descriptor {
+	__u8  bLength;
+	__u8  bDescriptorType;
+
+	__u8  bInterfaceNumber;
+	__u8  bAlternateSetting;
+	__u8  bNumEndpoints;
+	__u8  bInterfaceClass;
+	__u8  bInterfaceSubClass;
+	__u8  bInterfaceProtocol;
+	__u8  iInterface;
+} __attribute__ ((packed));
+
+#define USB_DT_INTERFACE_SIZE		9
+
+/*-------------------------------------------------------------------------*/
+
+/* USB_DT_ENDPOINT: Endpoint descriptor */
+struct usb_endpoint_descriptor {
+	__u8  bLength;
+	__u8  bDescriptorType;
+
+	__u8  bEndpointAddress;
+	__u8  bmAttributes;
+	__u16 wMaxPacketSize;
+	__u8  bInterval;
+
+	// NOTE:  these two are _only_ in audio endpoints.
+	// use USB_DT_ENDPOINT*_SIZE in bLength, not sizeof.
+	__u8  bRefresh;
+	__u8  bSynchAddress;
+} __attribute__ ((packed));
+
+#define USB_DT_ENDPOINT_SIZE		7
+#define USB_DT_ENDPOINT_AUDIO_SIZE	9	/* Audio extension */
 
-// FIXME include struct usb_endpoint_descriptor
 
 /*
  * Endpoints
@@ -188,10 +264,13 @@ struct usb_string_descriptor {
 #define USB_ENDPOINT_XFER_INT		3
 
 
+/*-------------------------------------------------------------------------*/
+
 /* USB_DT_DEVICE_QUALIFIER: Device Qualifier descriptor */
 struct usb_qualifier_descriptor {
 	__u8  bLength;
 	__u8  bDescriptorType;
+
 	__u16 bcdUSB;
 	__u8  bDeviceClass;
 	__u8  bDeviceSubClass;
diff --git a/sound/usb/usbaudio.c b/sound/usb/usbaudio.c
index 0b867f319abd..93c5c240cbfc 100644
--- a/sound/usb/usbaudio.c
+++ b/sound/usb/usbaudio.c
@@ -82,7 +82,7 @@ MODULE_PARM_SYNTAX(pid, SNDRV_ENABLED ",allows:{{-1,0xffff}},base:16");
 /* #define SND_USE_ASYNC_UNLINK */
 
 #ifdef SND_USB_ASYNC_UNLINK
-#define UNLINK_FLAGS	USB_ASYNC_UNLINK
+#define UNLINK_FLAGS	URB_ASYNC_UNLINK
 #else
 #define UNLINK_FLAGS	0
 #endif
@@ -867,7 +867,7 @@ static int init_substream_urbs(snd_usb_substream_t *subs, snd_pcm_runtime_t *run
 		}
 		u->urb->dev = subs->dev;
 		u->urb->pipe = subs->datapipe;
-		u->urb->transfer_flags = USB_ISO_ASAP | UNLINK_FLAGS;
+		u->urb->transfer_flags = URB_ISO_ASAP | UNLINK_FLAGS;
 		u->urb->number_of_packets = u->packets;
 		u->urb->context = u;
 		u->urb->complete = snd_complete_urb;
@@ -889,7 +889,7 @@ static int init_substream_urbs(snd_usb_substream_t *subs, snd_pcm_runtime_t *run
 			u->urb->transfer_buffer_length = NRPACKS * 3;
 			u->urb->dev = subs->dev;
 			u->urb->pipe = subs->syncpipe;
-			u->urb->transfer_flags = USB_ISO_ASAP | UNLINK_FLAGS;
+			u->urb->transfer_flags = URB_ISO_ASAP | UNLINK_FLAGS;
 			u->urb->number_of_packets = u->packets;
 			u->urb->context = u;
 			u->urb->complete = snd_complete_sync_urb;
@@ -933,8 +933,8 @@ static struct audioformat *find_format(snd_usb_substream_t *subs, snd_pcm_runtim
 static int set_format(snd_usb_substream_t *subs, snd_pcm_runtime_t *runtime)
 {
 	struct usb_device *dev = subs->dev;
-	struct usb_config_descriptor *config = dev->actconfig;
-	struct usb_interface_descriptor *alts;
+	struct usb_host_config *config = dev->actconfig;
+	struct usb_host_interface *alts;
 	struct usb_interface *iface;	
 	struct audioformat *fmt;
 	unsigned int ep, attr;
@@ -951,7 +951,7 @@ static int set_format(snd_usb_substream_t *subs, snd_pcm_runtime_t *runtime)
 
 	iface = &config->interface[fmt->iface];
 	alts = &iface->altsetting[fmt->altset_idx];
-	snd_assert(alts->bAlternateSetting == fmt->altsetting, return -EINVAL);
+	snd_assert(alts->desc.bAlternateSetting == fmt->altsetting, return -EINVAL);
 
 	/* close the old interface */
 	if (subs->interface >= 0 && subs->interface != fmt->iface) {
@@ -973,31 +973,31 @@ static int set_format(snd_usb_substream_t *subs, snd_pcm_runtime_t *runtime)
 	}
 
 	/* create a data pipe */
-	ep = alts->endpoint[0].bEndpointAddress & USB_ENDPOINT_NUMBER_MASK;
+	ep = alts->endpoint[0].desc.bEndpointAddress & USB_ENDPOINT_NUMBER_MASK;
 	if (is_playback)
 		subs->datapipe = usb_sndisocpipe(dev, ep);
 	else
 		subs->datapipe = usb_rcvisocpipe(dev, ep);
 	subs->syncpipe = subs->syncinterval = 0;
-	subs->maxpacksize = alts->endpoint[0].wMaxPacketSize;
+	subs->maxpacksize = alts->endpoint[0].desc.wMaxPacketSize;
 	subs->maxframesize = bytes_to_frames(runtime, subs->maxpacksize);
 	subs->fill_max = 0;
 
 	/* we need a sync pipe in async OUT or adaptive IN mode */
-	attr = alts->endpoint[0].bmAttributes & EP_ATTR_MASK;
+	attr = alts->endpoint[0].desc.bmAttributes & EP_ATTR_MASK;
 	if ((is_playback && attr == EP_ATTR_ASYNC) ||
 	    (! is_playback && attr == EP_ATTR_ADAPTIVE)) {
 		/* check endpoint */
-		if (alts->bNumEndpoints < 2 ||
-		    alts->endpoint[1].bmAttributes != 0x01 ||
-		    alts->endpoint[1].bSynchAddress != 0) {
+		if (alts->desc.bNumEndpoints < 2 ||
+		    alts->endpoint[1].desc.bmAttributes != 0x01 ||
+		    alts->endpoint[1].desc.bSynchAddress != 0) {
 			snd_printk(KERN_ERR "%d:%d:%d : invalid synch pipe\n",
 				   dev->devnum, fmt->iface, fmt->altsetting);
 			return -EINVAL;
 		}
-		ep = alts->endpoint[1].bEndpointAddress;
-		if ((is_playback && ep != (alts->endpoint[0].bSynchAddress | USB_DIR_IN)) ||
-		    (! is_playback && ep != (alts->endpoint[0].bSynchAddress & ~USB_DIR_IN))) {
+		ep = alts->endpoint[1].desc.bEndpointAddress;
+		if ((is_playback && ep != (alts->endpoint[0].desc.bSynchAddress | USB_DIR_IN)) ||
+		    (! is_playback && ep != (alts->endpoint[0].desc.bSynchAddress & ~USB_DIR_IN))) {
 			snd_printk(KERN_ERR "%d:%d:%d : invalid synch pipe\n",
 				   dev->devnum, fmt->iface, fmt->altsetting);
 			return -EINVAL;
@@ -1007,10 +1007,10 @@ static int set_format(snd_usb_substream_t *subs, snd_pcm_runtime_t *runtime)
 			subs->syncpipe = usb_rcvisocpipe(dev, ep);
 		else
 			subs->syncpipe = usb_sndisocpipe(dev, ep);
-		subs->syncinterval = alts->endpoint[1].bRefresh;
+		subs->syncinterval = alts->endpoint[1].desc.bRefresh;
 	}
 
-	ep = alts->endpoint[0].bEndpointAddress;
+	ep = alts->endpoint[0].desc.bEndpointAddress;
 	/* if endpoint has pitch control, enable it */
 	if (fmt->attributes & EP_CS_ATTR_PITCH_CONTROL) {
 		data[0] = 1;
@@ -1673,9 +1673,9 @@ static int parse_audio_format_type(struct usb_device *dev, int iface_no, int alt
 static int parse_audio_endpoints(snd_usb_audio_t *chip, unsigned char *buffer, int buflen, int iface_no)
 {
 	struct usb_device *dev;
-	struct usb_config_descriptor *config;
+	struct usb_host_config *config;
 	struct usb_interface *iface;
-	struct usb_interface_descriptor *alts;
+	struct usb_host_interface *alts;
 	int i, altno, err, stream;
 	int channels, nr_rates, pcm_format, format;
 	struct audioformat *fp;
@@ -1689,18 +1689,18 @@ static int parse_audio_endpoints(snd_usb_audio_t *chip, unsigned char *buffer, i
 	for (i = 0; i < iface->num_altsetting; i++) {
 		alts = &iface->altsetting[i];
 		/* skip invalid one */
-		if (alts->bInterfaceClass != USB_CLASS_AUDIO ||
-		    alts->bInterfaceSubClass != USB_SUBCLASS_AUDIO_STREAMING ||
-		    alts->bNumEndpoints < 1)
+		if (alts->desc.bInterfaceClass != USB_CLASS_AUDIO ||
+		    alts->desc.bInterfaceSubClass != USB_SUBCLASS_AUDIO_STREAMING ||
+		    alts->desc.bNumEndpoints < 1)
 			continue;
 		/* must be isochronous */
-		if ((alts->endpoint[0].bmAttributes & USB_ENDPOINT_XFERTYPE_MASK) !=
+		if ((alts->endpoint[0].desc.bmAttributes & USB_ENDPOINT_XFERTYPE_MASK) !=
 		    USB_ENDPOINT_XFER_ISOC)
 			continue;
 		/* check direction */
-		stream = (alts->endpoint[0].bEndpointAddress & USB_DIR_IN) ?
+		stream = (alts->endpoint[0].desc.bEndpointAddress & USB_DIR_IN) ?
 			SNDRV_PCM_STREAM_CAPTURE : SNDRV_PCM_STREAM_PLAYBACK;
-		altno = alts->bAlternateSetting;
+		altno = alts->desc.bAlternateSetting;
 
 		/* get audio formats */
 		fmt = snd_usb_find_csint_desc(buffer, buflen, NULL, AS_GENERAL, iface_no, altno);
@@ -1767,8 +1767,8 @@ static int parse_audio_endpoints(snd_usb_audio_t *chip, unsigned char *buffer, i
 		fp->altsetting = altno;
 		fp->altset_idx = i;
 		fp->format = pcm_format;
-		fp->endpoint = alts->endpoint[0].bEndpointAddress;
-		fp->ep_attr = alts->endpoint[0].bmAttributes;
+		fp->endpoint = alts->endpoint[0].desc.bEndpointAddress;
+		fp->ep_attr = alts->endpoint[0].desc.bmAttributes;
 		fp->channels = channels;
 		fp->attributes = csep[3];
 
@@ -1837,7 +1837,7 @@ static int snd_usb_create_streams(snd_usb_audio_t *chip, int ctrlif,
 				  unsigned char *buffer, int buflen)
 {
 	struct usb_device *dev = chip->dev;
-	struct usb_config_descriptor *config;
+	struct usb_host_config *config;
 	struct usb_interface *iface;
 	unsigned char *p1;
 	int i, j;
@@ -1858,7 +1858,7 @@ static int snd_usb_create_streams(snd_usb_audio_t *chip, int ctrlif,
 	config = dev->actconfig;
 	for (i = 0; i < p1[7]; i++) {
 		j = p1[8 + i];
-		if (j >= config->bNumInterfaces) {
+		if (j >= config->desc.bNumInterfaces) {
 			snd_printk(KERN_ERR "%d:%u:%d : does not exist\n",
 				   dev->devnum, ctrlif, j);
 			continue;
@@ -1868,8 +1868,8 @@ static int snd_usb_create_streams(snd_usb_audio_t *chip, int ctrlif,
 			snd_printdd(KERN_INFO "%d:%d:%d: skipping, already claimed\n", dev->devnum, ctrlif, j);
 			continue;
 		}
-		if (iface->altsetting[0].bInterfaceClass == USB_CLASS_AUDIO &&
-		    iface->altsetting[0].bInterfaceSubClass == USB_SUBCLASS_MIDI_STREAMING) {
+		if (iface->altsetting[0].desc.bInterfaceClass == USB_CLASS_AUDIO &&
+		    iface->altsetting[0].desc.bInterfaceSubClass == USB_SUBCLASS_MIDI_STREAMING) {
 			if (snd_usb_create_midi_interface(chip, iface, NULL) < 0) {
 				snd_printk(KERN_ERR "%d:%u:%d: cannot create sequencer device\n", dev->devnum, ctrlif, j);
 				continue;
@@ -1877,8 +1877,8 @@ static int snd_usb_create_streams(snd_usb_audio_t *chip, int ctrlif,
 			usb_driver_claim_interface(&usb_audio_driver, iface, (void *)-1);
 			continue;
 		}
-		if (iface->altsetting[0].bInterfaceClass != USB_CLASS_AUDIO ||
-		    iface->altsetting[0].bInterfaceSubClass != USB_SUBCLASS_AUDIO_STREAMING) {
+		if (iface->altsetting[0].desc.bInterfaceClass != USB_CLASS_AUDIO ||
+		    iface->altsetting[0].desc.bInterfaceSubClass != USB_SUBCLASS_AUDIO_STREAMING) {
 			snd_printdd(KERN_ERR "%d:%u:%d: skipping non-supported interface %d\n", dev->devnum, ctrlif, j, iface->altsetting[0].bInterfaceClass);
 			/* skip non-supported classes */
 			continue;
@@ -1937,11 +1937,11 @@ static int snd_usb_roland_ua100_hack(snd_usb_audio_t *chip)
 		.type = QUIRK_MIDI_FIXED_ENDPOINT,
 		.data = &ep_quirk
 	};
-	struct usb_config_descriptor *cfg = chip->dev->actconfig;
+	struct usb_host_config *cfg = chip->dev->actconfig;
 	struct usb_interface *iface;
 	int err;
 
-	if (cfg->bNumInterfaces != 3) {
+	if (cfg->desc.bNumInterfaces != 3) {
 		snd_printdd(KERN_ERR "invalid UA-100 descriptor\n");
 		return -ENXIO;
 	}
@@ -2134,18 +2134,18 @@ static void *snd_usb_audio_probe(struct usb_device *dev,
 				 struct usb_interface *intf,
 				 const struct usb_device_id *usb_id)
 {
-	struct usb_config_descriptor *config = dev->actconfig;	
+	struct usb_host_config *config = dev->actconfig;	
 	const snd_usb_audio_quirk_t *quirk = (const snd_usb_audio_quirk_t *)usb_id->driver_info;
 	int i;
 	snd_card_t *card;
 	snd_usb_audio_t *chip;
-	int ifnum = intf->altsetting->bInterfaceNumber;
+	int ifnum = intf->altsetting->desc.bInterfaceNumber;
 
 	if (quirk && quirk->ifnum != QUIRK_ANY_INTERFACE && ifnum != quirk->ifnum)
 		goto __err_val;
 
-	if (usb_set_configuration(dev, config->bConfigurationValue) < 0) {
-		snd_printk(KERN_ERR "cannot set configuration (value 0x%x)\n", config->bConfigurationValue);
+	if (usb_set_configuration(dev, config->desc.bConfigurationValue) < 0) {
+		snd_printk(KERN_ERR "cannot set configuration (value 0x%x)\n", config->desc.bConfigurationValue);
 		goto __err_val;
 	}
 
diff --git a/sound/usb/usbmidi.c b/sound/usb/usbmidi.c
index f2f6f2a75a90..6972f89bca07 100644
--- a/sound/usb/usbmidi.c
+++ b/sound/usb/usbmidi.c
@@ -517,7 +517,7 @@ static void snd_usbmidi_in_endpoint_delete(snd_usb_midi_in_endpoint_t* ep)
 static struct usb_endpoint_descriptor* snd_usbmidi_get_int_epd(snd_usb_midi_t* umidi)
 {
 	struct usb_interface* intf;
-	struct usb_interface_descriptor* intfd;
+	struct usb_host_interface* intfd;
 
 	if (umidi->chip->dev->descriptor.idVendor != 0x0582)
 		return NULL;
@@ -526,28 +526,28 @@ static struct usb_endpoint_descriptor* snd_usbmidi_get_int_epd(snd_usb_midi_t* u
 		return NULL;
 
 	intfd = &intf->altsetting[0];
-	if (intfd->bNumEndpoints != 2 ||
-	    (intfd->endpoint[0].bmAttributes & USB_ENDPOINT_XFERTYPE_MASK) != USB_ENDPOINT_XFER_BULK ||
-	    (intfd->endpoint[1].bmAttributes & USB_ENDPOINT_XFERTYPE_MASK) != USB_ENDPOINT_XFER_BULK)
+	if (intfd->desc.bNumEndpoints != 2 ||
+	    (intfd->endpoint[0].desc.bmAttributes & USB_ENDPOINT_XFERTYPE_MASK) != USB_ENDPOINT_XFER_BULK ||
+	    (intfd->endpoint[1].desc.bmAttributes & USB_ENDPOINT_XFERTYPE_MASK) != USB_ENDPOINT_XFER_BULK)
 		return NULL;
 
 	intfd = &intf->altsetting[1];
-	if (intfd->bNumEndpoints != 2 ||
-	    (intfd->endpoint[0].bmAttributes & USB_ENDPOINT_XFERTYPE_MASK) != USB_ENDPOINT_XFER_BULK ||
-	    (intfd->endpoint[1].bmAttributes & USB_ENDPOINT_XFERTYPE_MASK) != USB_ENDPOINT_XFER_INT)
+	if (intfd->desc.bNumEndpoints != 2 ||
+	    (intfd->endpoint[0].desc.bmAttributes & USB_ENDPOINT_XFERTYPE_MASK) != USB_ENDPOINT_XFER_BULK ||
+	    (intfd->endpoint[1].desc.bmAttributes & USB_ENDPOINT_XFERTYPE_MASK) != USB_ENDPOINT_XFER_INT)
 		return NULL;
 
-	usb_set_interface(umidi->chip->dev, intfd->bInterfaceNumber,
-			  intfd->bAlternateSetting);
-	return &intfd->endpoint[1];
+	usb_set_interface(umidi->chip->dev, intfd->desc.bInterfaceNumber,
+			  intfd->desc.bAlternateSetting);
+	return &intfd->endpoint[1].desc;
 }
 
 static struct usb_endpoint_descriptor* snd_usbmidi_get_midiman_int_epd(snd_usb_midi_t* umidi)
 {
 	struct usb_interface* intf = umidi->iface;
-	if (!intf || intf->altsetting[0].bNumEndpoints < 1)
+	if (!intf || intf->altsetting[0].desc.bNumEndpoints < 1)
 		return NULL;
-	return &intf->altsetting[0].endpoint[0];
+	return &intf->altsetting[0].endpoint[0].desc;
 }
 
 /*
@@ -590,10 +590,10 @@ static int snd_usbmidi_in_endpoint_create(snd_usb_midi_t* umidi,
 		return -ENOMEM;
 	}
 	if (int_epd)
-		FILL_INT_URB(ep->urb, umidi->chip->dev, pipe, buffer, length,
+		usb_fill_int_urb(ep->urb, umidi->chip->dev, pipe, buffer, length,
 			     snd_usbmidi_in_urb_complete, ep, int_epd->bInterval);
 	else
-		FILL_BULK_URB(ep->urb, umidi->chip->dev, pipe, buffer, length,
+		usb_fill_bulk_urb(ep->urb, umidi->chip->dev, pipe, buffer, length,
 			      snd_usbmidi_in_urb_complete, ep);
 
 	rep->in = ep;
@@ -657,7 +657,7 @@ static int snd_usbmidi_out_endpoint_create(snd_usb_midi_t* umidi,
 		snd_usbmidi_out_endpoint_delete(ep);
 		return -ENOMEM;
 	}
-	FILL_BULK_URB(ep->urb, umidi->chip->dev, pipe, buffer,
+	usb_fill_bulk_urb(ep->urb, umidi->chip->dev, pipe, buffer,
 		      ep->max_transfer, snd_usbmidi_out_urb_complete, ep);
 
 	spin_lock_init(&ep->buffer_lock);
@@ -774,9 +774,9 @@ static int snd_usbmidi_get_ms_info(snd_usb_midi_t* umidi,
 			   	   snd_usb_midi_endpoint_info_t* endpoints)
 {
 	struct usb_interface* intf;
-	struct usb_interface_descriptor* intfd;
+	struct usb_host_interface* intfd;
 	struct usb_ms_header_descriptor* ms_header;
-	struct usb_endpoint_descriptor* ep;
+	struct usb_host_endpoint* ep;
 	struct usb_ms_endpoint_descriptor* ms_ep;
 	int i, epidx;
 
@@ -795,9 +795,9 @@ static int snd_usbmidi_get_ms_info(snd_usb_midi_t* umidi,
 		printk(KERN_WARNING "snd-usb-midi: MIDIStreaming interface descriptor not found\n");
 
 	epidx = 0;
-	for (i = 0; i < intfd->bNumEndpoints; ++i) {
+	for (i = 0; i < intfd->desc.bNumEndpoints; ++i) {
 		ep = &intfd->endpoint[i];
-		if ((ep->bmAttributes & USB_ENDPOINT_XFERTYPE_MASK) != USB_ENDPOINT_XFER_BULK)
+		if ((ep->desc.bmAttributes & USB_ENDPOINT_XFERTYPE_MASK) != USB_ENDPOINT_XFER_BULK)
 			continue;
 		ms_ep = (struct usb_ms_endpoint_descriptor*)ep->extra;
 		if (ep->extralen < 4 ||
@@ -806,22 +806,22 @@ static int snd_usbmidi_get_ms_info(snd_usb_midi_t* umidi,
 		    ms_ep->bDescriptorSubtype != MS_GENERAL)
 			continue;
 		if (endpoints[epidx].epnum != 0 &&
-		    endpoints[epidx].epnum != (ep->bEndpointAddress & USB_ENDPOINT_NUMBER_MASK)) {
+		    endpoints[epidx].epnum != (ep->desc.bEndpointAddress & USB_ENDPOINT_NUMBER_MASK)) {
 			++epidx;
 			if (epidx >= MIDI_MAX_ENDPOINTS) {
 				printk(KERN_WARNING "snd-usb-midi: too many endpoints\n");
 				break;
 			}
 		}
-		endpoints[epidx].epnum = ep->bEndpointAddress & USB_ENDPOINT_NUMBER_MASK;
-		if (ep->bEndpointAddress & USB_DIR_IN) {
+		endpoints[epidx].epnum = ep->desc.bEndpointAddress & USB_ENDPOINT_NUMBER_MASK;
+		if (ep->desc.bEndpointAddress & USB_DIR_IN) {
 			endpoints[epidx].in_cables = (1 << ms_ep->bNumEmbMIDIJack) - 1;
 		} else {
 			endpoints[epidx].out_cables = (1 << ms_ep->bNumEmbMIDIJack) - 1;
 		}
 		printk(KERN_INFO "snd-usb-midi: detected %d %s jack(s) on endpoint %d\n",
 		       ms_ep->bNumEmbMIDIJack,
-		       ep->bEndpointAddress & USB_DIR_IN ? "input" : "output",
+		       ep->desc.bEndpointAddress & USB_DIR_IN ? "input" : "output",
 		       endpoints[epidx].epnum);
 	}
 	return 0;
@@ -835,7 +835,7 @@ static int snd_usbmidi_detect_endpoint(snd_usb_midi_t* umidi,
 			       	       snd_usb_midi_endpoint_info_t* endpoint)
 {
 	struct usb_interface* intf;
-	struct usb_interface_descriptor* intfd;
+	struct usb_host_interface* intfd;
 	struct usb_endpoint_descriptor* epd;
 
 	if (endpoint->epnum == -1) {
@@ -843,9 +843,9 @@ static int snd_usbmidi_detect_endpoint(snd_usb_midi_t* umidi,
 		if (!intf || intf->num_altsetting < 1)
 			return -ENOENT;
 		intfd = intf->altsetting;
-		if (intfd->bNumEndpoints < 1)
+		if (intfd->desc.bNumEndpoints < 1)
 			return -ENOENT;
-		epd = intfd->endpoint;
+		epd = &intfd->endpoint [0].desc;
 		endpoint->epnum = epd->bEndpointAddress & USB_ENDPOINT_NUMBER_MASK;
 	}
 	return 0;
@@ -858,14 +858,14 @@ static int snd_usbmidi_detect_yamaha(snd_usb_midi_t* umidi,
 				     snd_usb_midi_endpoint_info_t* endpoint)
 {
 	struct usb_interface* intf;
-	struct usb_interface_descriptor* intfd;
+	struct usb_host_interface* intfd;
 	uint8_t* cs_desc;
 
 	intf = umidi->iface;
 	if (!intf)
 		return -ENOENT;
 	intfd = intf->altsetting;
-	if (intfd->bNumEndpoints < 1)
+	if (intfd->desc.bNumEndpoints < 1)
 		return -ENOENT;
 
 	for (cs_desc = intfd->extra;
@@ -892,7 +892,7 @@ static int snd_usbmidi_create_endpoints_midiman(snd_usb_midi_t* umidi, int ports
 {
 	snd_usb_midi_endpoint_info_t ep_info;
 	struct usb_interface* intf;
-	struct usb_interface_descriptor* intfd;
+	struct usb_host_interface* intfd;
 	struct usb_endpoint_descriptor* epd;
 	int cable, err;
 
@@ -900,25 +900,25 @@ static int snd_usbmidi_create_endpoints_midiman(snd_usb_midi_t* umidi, int ports
 	if (!intf)
 		return -ENOENT;
 	intfd = intf->altsetting;
-	if (intfd->bNumEndpoints < (ports > 1 ? 5 : 3)) {
+	if (intfd->desc.bNumEndpoints < (ports > 1 ? 5 : 3)) {
 		snd_printdd(KERN_ERR "not enough endpoints\n");
 		return -ENOENT;
 	}
 
-	epd = &intfd->endpoint[0];
+	epd = &intfd->endpoint[0].desc;
 	if ((epd->bEndpointAddress & USB_ENDPOINT_DIR_MASK) != USB_DIR_IN ||
 	    (epd->bmAttributes & USB_ENDPOINT_XFERTYPE_MASK) != USB_ENDPOINT_XFER_INT) {
 		snd_printdd(KERN_ERR "endpoint[0] isn't interrupt\n");
 		return -ENXIO;
 	}
-	epd = &intfd->endpoint[2];
+	epd = &intfd->endpoint[2].desc;
 	if ((epd->bEndpointAddress & USB_ENDPOINT_DIR_MASK) != USB_DIR_OUT ||
 	    (epd->bmAttributes & USB_ENDPOINT_XFERTYPE_MASK) != USB_ENDPOINT_XFER_BULK) {
 		snd_printdd(KERN_ERR "endpoint[2] isn't bulk output\n");
 		return -ENXIO;
 	}
 	if (ports > 1) {
-		epd = &intfd->endpoint[4];
+		epd = &intfd->endpoint[4].desc;
 		if ((epd->bEndpointAddress & USB_ENDPOINT_DIR_MASK) != USB_DIR_OUT ||
 		    (epd->bmAttributes & USB_ENDPOINT_XFERTYPE_MASK) != USB_ENDPOINT_XFER_BULK) {
 			snd_printdd(KERN_ERR "endpoint[4] isn't bulk output\n");
@@ -926,13 +926,13 @@ static int snd_usbmidi_create_endpoints_midiman(snd_usb_midi_t* umidi, int ports
 		}
 	}
 
-	ep_info.epnum = intfd->endpoint[2].bEndpointAddress & USB_ENDPOINT_NUMBER_MASK;
+	ep_info.epnum = intfd->endpoint[2].desc.bEndpointAddress & USB_ENDPOINT_NUMBER_MASK;
 	ep_info.out_cables = 0x5555 & ((1 << ports) - 1);
 	err = snd_usbmidi_out_endpoint_create(umidi, &ep_info, &umidi->endpoints[0]);
 	if (err < 0)
 		return err;
 
-	ep_info.epnum = intfd->endpoint[0].bEndpointAddress & USB_ENDPOINT_NUMBER_MASK;
+	ep_info.epnum = intfd->endpoint[0].desc.bEndpointAddress & USB_ENDPOINT_NUMBER_MASK;
 	ep_info.in_cables = (1 << ports) - 1;
 	err = snd_usbmidi_in_endpoint_create(umidi, &ep_info, &umidi->endpoints[0]);
 	if (err < 0)
@@ -940,7 +940,7 @@ static int snd_usbmidi_create_endpoints_midiman(snd_usb_midi_t* umidi, int ports
 	umidi->endpoints[0].in->urb->complete = snd_usbmidi_in_midiman_complete;
 
 	if (ports > 1) {
-		ep_info.epnum = intfd->endpoint[4].bEndpointAddress & USB_ENDPOINT_NUMBER_MASK;
+		ep_info.epnum = intfd->endpoint[4].desc.bEndpointAddress & USB_ENDPOINT_NUMBER_MASK;
 		ep_info.out_cables = 0xaaaa & ((1 << ports) - 1);
 		err = snd_usbmidi_out_endpoint_create(umidi, &ep_info, &umidi->endpoints[1]);
 		if (err < 0)