[PATCH] Eliminate Old Prototypes from 2.5.44

Attached patch is the result of:

dignity:~/src/linux-2.5.44 $ for x in `rgrep -l "FILL_.*URB"  *`;
do cp -v $x $x.backup;
cat $x.backup | perl -pe 's/FILL_CONTROL_URB/usb_fill_control_urb/g;
 s/FILL_BULK_URB/usb_fill_bulk_urb/g;
 s/FILL_INT_URB/usb_fill_int_urb/g;' > $x;
done

and a manual removal of the define's in usb.h.

Documentation/DocBook/writing_usb_driver.tmpl

@@ -307,7 +307,7 @@ if (result) {
   </programlisting>
   <para>
      When the write urb is filled up with the proper information using the
-     FILL_BULK_URB function, we point the urb's completion callback to call our
+     usb_fill_bulk_urb function, we point the urb's completion callback to call our
      own skel_write_bulk_callback function. This function is called when the
      urb is finished by the USB subsystem. The callback function is called in
      interrupt context, so caution must be taken not to do very much processing

drivers/bluetooth/hci_usb.c

@@ -131,7 +131,7 @@ static int hci_usb_enable_intr(struct hci_usb *husb)
 	
         pipe = usb_rcvintpipe(husb->udev, husb->intr_ep);
         size = usb_maxpacket(husb->udev, pipe, usb_pipeout(pipe));
-	FILL_INT_URB(urb, husb->udev, pipe, buf, size, 
+	usb_fill_int_urb(urb, husb->udev, pipe, buf, size, 
 			hci_usb_interrupt, husb, husb->intr_interval);
 	
 	return usb_submit_urb(urb, GFP_KERNEL);
@@ -182,7 +182,7 @@ static int hci_usb_rx_submit(struct hci_usb *husb, struct urb *urb)
 
         pipe = usb_rcvbulkpipe(husb->udev, husb->bulk_in_ep);
 
-        FILL_BULK_URB(urb, husb->udev, pipe, skb->data, size, hci_usb_rx_complete, skb);
+        usb_fill_bulk_urb(urb, husb->udev, pipe, skb->data, size, hci_usb_rx_complete, skb);
 
 	skb_queue_tail(&husb->pending_q, skb);
 	err = usb_submit_urb(urb, GFP_ATOMIC);
@@ -299,7 +299,7 @@ static inline int hci_usb_send_ctrl(struct hci_usb *husb, struct sk_buff *skb)
 	cr->wValue   = 0;
 	cr->wLength  = __cpu_to_le16(skb->len);
 
-	FILL_CONTROL_URB(urb, husb->udev, pipe, (void *) cr,
+	usb_fill_control_urb(urb, husb->udev, pipe, (void *) cr,
 			skb->data, skb->len, hci_usb_tx_complete, skb);
 
 	BT_DBG("%s urb %p len %d", husb->hdev.name, urb, skb->len);
@@ -328,7 +328,7 @@ static inline int hci_usb_send_bulk(struct hci_usb *husb, struct sk_buff *skb)
 
 	pipe = usb_sndbulkpipe(husb->udev, husb->bulk_out_ep);
         
-	FILL_BULK_URB(urb, husb->udev, pipe, skb->data, skb->len,
+	usb_fill_bulk_urb(urb, husb->udev, pipe, skb->data, skb->len,
 	              hci_usb_tx_complete, skb);
 	urb->transfer_flags = USB_ZERO_PACKET;
 

drivers/isdn/hisax/st5481_usb.c

@@ -284,7 +284,7 @@ int __devinit st5481_setup_usb(struct st5481_adapter *adapter)
 	ctrl->urb = urb;
 	
 	// Fill the control URB
-	FILL_CONTROL_URB (urb, dev, 
+	usb_fill_control_urb (urb, dev, 
 			  usb_sndctrlpipe(dev, 0),
 			  NULL, NULL, 0, usb_ctrl_complete, adapter);
 
@@ -306,7 +306,7 @@ int __devinit st5481_setup_usb(struct st5481_adapter *adapter)
 	endpoint = &altsetting->endpoint[EP_INT-1];
 				
 	// Fill the interrupt URB
-	FILL_INT_URB(urb, dev,
+	usb_fill_int_urb(urb, dev,
 		     usb_rcvintpipe(dev, endpoint->bEndpointAddress),
 		     buf, INT_PKT_SIZE,
 		     usb_int_complete, adapter,

drivers/net/irda/irda-usb.c

@@ -265,7 +265,7 @@ static void irda_usb_change_speed_xbofs(struct irda_usb_cb *self)
 	irda_usb_build_header(self, frame, 1);
 
 	/* Submit the 0 length IrDA frame to trigger new speed settings */
-        FILL_BULK_URB(urb, self->usbdev,
+        usb_fill_bulk_urb(urb, self->usbdev,
 		      usb_sndbulkpipe(self->usbdev, self->bulk_out_ep),
                       frame, IRDA_USB_SPEED_MTU,
                       speed_bulk_callback, self);
@@ -400,7 +400,7 @@ static int irda_usb_hard_xmit(struct sk_buff *skb, struct net_device *netdev)
 	/* FIXME: Make macro out of this one */
 	((struct irda_skb_cb *)skb->cb)->context = self;
 
-        FILL_BULK_URB(urb, self->usbdev, 
+        usb_fill_bulk_urb(urb, self->usbdev, 
 		      usb_sndbulkpipe(self->usbdev, self->bulk_out_ep),
                       skb->data, IRDA_USB_MAX_MTU,
                       write_bulk_callback, skb);
@@ -729,7 +729,7 @@ static void irda_usb_submit(struct irda_usb_cb *self, struct sk_buff *skb, struc
 	cb->context = self;
 
 	/* Reinitialize URB */
-	FILL_BULK_URB(urb, self->usbdev, 
+	usb_fill_bulk_urb(urb, self->usbdev, 
 		      usb_rcvbulkpipe(self->usbdev, self->bulk_in_ep), 
 		      skb->data, skb->truesize,
                       irda_usb_receive, skb);

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 @@ static void bluetooth_read_bulk_callback (struct urb *urb)
 	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);
@@ -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);
 

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 );

drivers/usb/class/usblp.c

@@ -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,

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) {

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);

drivers/usb/image/hpusbscsi.c

@@ -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),

drivers/usb/image/mdc800.c

@@ -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]),

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,

drivers/usb/image/scanner.c

@@ -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);

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,

drivers/usb/misc/auerswald.c

@@ -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 @@ static ssize_t auerchar_write (struct file *file, const char *buf, size_t len, l
 	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 */

drivers/usb/misc/brlvger.c

@@ -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),

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,

drivers/usb/net/catc.c

@@ -847,16 +847,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) {

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 );
@@ -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 );

drivers/usb/net/kaweth.c

@@ -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,
@@ -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);

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);	
@@ -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);

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)) {
@@ -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)))

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,7 +1472,7 @@ 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;
@@ -1954,7 +1954,7 @@ 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;

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) ? 

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,

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);

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);
 

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);

drivers/usb/serial/keyspan.c

@@ -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);
 

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,

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,

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);

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);

drivers/usb/storage/transport.c

@@ -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);
 

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 */

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);
@@ -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,

include/linux/usb.h

@@ -872,17 +872,6 @@ static inline void usb_fill_int_urb (struct urb *urb,
 	urb->start_frame = -1;
 }
 
-/*
- * old style macros to enable 2.4 and 2.2 drivers to build
- * properly.  Please do not use these for new USB drivers.
- */
-#define FILL_CONTROL_URB(URB,DEV,PIPE,SETUP_PACKET,TRANSFER_BUFFER,BUFFER_LENGTH,COMPLETE,CONTEXT) \
-    usb_fill_control_urb(URB,DEV,PIPE,SETUP_PACKET,TRANSFER_BUFFER,BUFFER_LENGTH,COMPLETE,CONTEXT)
-#define FILL_BULK_URB(URB,DEV,PIPE,TRANSFER_BUFFER,BUFFER_LENGTH,COMPLETE,CONTEXT) \
-    usb_fill_bulk_urb(URB,DEV,PIPE,TRANSFER_BUFFER,BUFFER_LENGTH,COMPLETE,CONTEXT)
-#define FILL_INT_URB(URB,DEV,PIPE,TRANSFER_BUFFER,BUFFER_LENGTH,COMPLETE,CONTEXT,INTERVAL) \
-    usb_fill_int_urb(URB,DEV,PIPE,TRANSFER_BUFFER,BUFFER_LENGTH,COMPLETE,CONTEXT,INTERVAL)
-
 extern struct urb *usb_alloc_urb(int iso_packets, int mem_flags);
 extern void usb_free_urb(struct urb *urb);
 #define usb_put_urb usb_free_urb

sound/usb/usbmidi.c

@@ -590,10 +590,10 @@ static int snd_usbmidi_in_endpoint_create(snd_usb_midi_t* umidi,
 		return -ENOMEM;
 	}
 	if (int_epd)
-		FILL_INT_URB(ep->urb, umidi->chip->dev, pipe, buffer, length,
+		usb_fill_int_urb(ep->urb, umidi->chip->dev, pipe, buffer, length,
 			     snd_usbmidi_in_urb_complete, ep, int_epd->bInterval);
 	else
-		FILL_BULK_URB(ep->urb, umidi->chip->dev, pipe, buffer, length,
+		usb_fill_bulk_urb(ep->urb, umidi->chip->dev, pipe, buffer, length,
 			      snd_usbmidi_in_urb_complete, ep);
 
 	rep->in = ep;
@@ -657,7 +657,7 @@ static int snd_usbmidi_out_endpoint_create(snd_usb_midi_t* umidi,
 		snd_usbmidi_out_endpoint_delete(ep);
 		return -ENOMEM;
 	}
-	FILL_BULK_URB(ep->urb, umidi->chip->dev, pipe, buffer,
+	usb_fill_bulk_urb(ep->urb, umidi->chip->dev, pipe, buffer,
 		      ep->max_transfer, snd_usbmidi_out_urb_complete, ep);
 
 	spin_lock_init(&ep->buffer_lock);