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

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

74 files changed, 621 insertions, 592 deletions

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,