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

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

MAINTAINERS

@@ -1592,6 +1592,11 @@ P:	Julien Blache
 M:	jb@technologeek.org
 S:	Maintained
 
+TI PARALLEL LINK CABLE DRIVER
+P:     Romain Lievin
+M:     roms@lpg.ticalc.org
+S:     Maintained
+
 TIEMAN VOYAGER USB BRAILLE DISPLAY DRIVER
 P:	Stephane Dalton
 M:	sdalton@videotron.ca

drivers/char/Config.help

@@ -1033,3 +1033,24 @@ CONFIG_SCx200_GPIO
 
   If compiled as a module, it will be called scx200_gpio.o.
 
+Texas Instruments parallel link cable support
+CONFIG_TIPAR
+  If you own a Texas Instruments graphing calculator and use a
+  parallel link cable, then you might be interested in this driver.
+
+  If you enable this driver, you will be able to communicate with
+  your calculator through a set of device nodes under /dev. The
+  main advantage of this driver is that you don't have to be root
+  to use this precise link cable (depending on the permissions on
+  the device nodes, though).
+
+  This code is also available as a module ( = code which can be
+  inserted in and removed from the running kernel whenever you want).
+  The module will be called tipar.o. If you want to compile it as a
+  module, say M here and read Documentation/modules.txt.
+
+  If you don't know what a parallel link cable is or what a Texas
+  Instruments graphing calculator is, then you probably don't need this
+  driver.
+
+  If unsure, say N.
\ No newline at end of file

drivers/char/Config.in

@@ -80,6 +80,7 @@ if [ "$CONFIG_PARPORT" != "n" ]; then
       bool '  Support for console on line printer' CONFIG_LP_CONSOLE
    fi
    dep_tristate 'Support for user-space parallel port device drivers' CONFIG_PPDEV $CONFIG_PARPORT
+   dep_tristate 'Texas Instruments parallel link cable support' CONFIG_TIPAR $CONFIG_PARPORT
 fi
 if [ "$CONFIG_PPC_PSERIES" = "y" ]; then
    bool 'pSeries Hypervisor Virtual Console support' CONFIG_HVC_CONSOLE

drivers/char/Makefile

@@ -50,6 +50,7 @@ obj-$(CONFIG_HVC_CONSOLE) += hvc_console.o
 obj-$(CONFIG_RAW_DRIVER) += raw.o
 
 obj-$(CONFIG_PRINTER) += lp.o
+obj-$(CONFIG_TIPAR) += tipar.o
 
 obj-$(CONFIG_BUSMOUSE) += busmouse.o
 obj-$(CONFIG_DTLK) += dtlk.o

drivers/usb/core/hcd-pci.c

@@ -62,6 +62,9 @@ int usb_hcd_pci_probe (struct pci_dev *dev, const struct pci_device_id *id)
 	int			retval, region;
 	char			buf [8], *bufp = buf;
 
+	if (usb_disabled())
+		return -ENODEV;
+
 	if (!id || !(driver = (struct hc_driver *) id->driver_data))
 		return -EINVAL;
 

drivers/usb/core/hub.c

@@ -943,7 +943,9 @@ static void usb_hub_events(void)
 
 		list_del_init(tmp);
 
-		down(&hub->khubd_sem); /* never blocks, we were on list */
+		if (unlikely(down_trylock(&hub->khubd_sem)))
+			BUG();	/* never blocks, we were on list */
+
 		spin_unlock_irqrestore(&hub_event_lock, flags);
 
 		if (hub->error) {
@@ -1067,10 +1069,10 @@ static int usb_hub_thread(void *__hub)
 }
 
 static struct usb_device_id hub_id_table [] = {
-    { match_flags: USB_DEVICE_ID_MATCH_DEV_CLASS,
-      bDeviceClass: USB_CLASS_HUB},
-    { match_flags: USB_DEVICE_ID_MATCH_INT_CLASS,
-      bInterfaceClass: USB_CLASS_HUB},
+    { .match_flags = USB_DEVICE_ID_MATCH_DEV_CLASS,
+      .bDeviceClass = USB_CLASS_HUB},
+    { .match_flags = USB_DEVICE_ID_MATCH_INT_CLASS,
+      .bInterfaceClass = USB_CLASS_HUB},
     { }						/* Terminating entry */
 };
 

drivers/usb/core/inode.c

@@ -45,7 +45,8 @@ static struct inode_operations usbfs_dir_inode_operations;
 static struct vfsmount *usbdevfs_mount;
 static struct vfsmount *usbfs_mount;
 static spinlock_t mount_lock = SPIN_LOCK_UNLOCKED;
-static int mount_count;	/* = 0 */
+static int usbdevfs_mount_count;	/* = 0 */
+static int usbfs_mount_count;	/* = 0 */
 
 static struct dentry *devices_usbdevfs_dentry;
 static struct dentry *devices_usbfs_dentry;
@@ -507,14 +508,14 @@ static struct file_system_type usb_fs_type = {
 };
 
 /* --------------------------------------------------------------------- */
-static int get_mount (struct file_system_type *fs_type, struct vfsmount **mount)
+static int get_mount (struct file_system_type *fs_type, struct vfsmount **mount, int *mount_count)
 {
 	struct vfsmount *mnt;
 
 	spin_lock (&mount_lock);
 	if (*mount) {
 		mntget(*mount);
-		++mount_count;
+		++(*mount_count);
 		spin_unlock (&mount_lock);
 		goto go_ahead;
 	}
@@ -528,33 +529,33 @@ static int get_mount (struct file_system_type *fs_type, struct vfsmount **mount)
 	spin_lock (&mount_lock);
 	if (!*mount) {
 		*mount = mnt;
-		++mount_count;
+		++(*mount_count);
 		spin_unlock (&mount_lock);
 		goto go_ahead;
 	}
 	mntget(*mount);
-	++mount_count;
+	++(*mount_count);
 	spin_unlock (&mount_lock);
 	mntput(mnt);
 
 go_ahead:
-	dbg("mount_count = %d", mount_count);
+	dbg("mount_count = %d", *mount_count);
 	return 0;
 }
 
-static void put_mount (struct vfsmount **mount)
+static void put_mount (struct vfsmount **mount, int *mount_count)
 {
 	struct vfsmount *mnt;
 
 	spin_lock (&mount_lock);
 	mnt = *mount;
-	--mount_count;
-	if (!mount_count)
+	--(*mount_count);
+	if (!(*mount_count))
 		*mount = NULL;
 
 	spin_unlock (&mount_lock);
 	mntput(mnt);
-	dbg("mount_count = %d", mount_count);
+	dbg("mount_count = %d", *mount_count);
 }
 
 static int create_special_files (void)
@@ -563,13 +564,13 @@ static int create_special_files (void)
 	int retval = 0;
 
 	/* create the devices special file */
-	retval = get_mount (&usbdevice_fs_type, &usbdevfs_mount);
+	retval = get_mount (&usbdevice_fs_type, &usbdevfs_mount, &usbdevfs_mount_count);
 	if (retval) {
 		err ("Unable to get usbdevfs mount");
 		goto exit;
 	}
 
-	retval = get_mount (&usb_fs_type, &usbfs_mount);
+	retval = get_mount (&usb_fs_type, &usbfs_mount, &usbfs_mount_count);
 	if (retval) {
 		err ("Unable to get usbfs mount");
 		goto error_clean_usbdevfs_mount;
@@ -604,10 +605,10 @@ static int create_special_files (void)
 	devices_usbfs_dentry = NULL;
 
 error_clean_mounts:
-	put_mount (&usbfs_mount);
+	put_mount (&usbfs_mount, &usbfs_mount_count);
 
 error_clean_usbdevfs_mount:
-	put_mount (&usbdevfs_mount);	
+	put_mount (&usbdevfs_mount, &usbdevfs_mount_count);
 
 exit:
 	return retval;
@@ -621,8 +622,8 @@ static void remove_special_files (void)
 		fs_remove_file (devices_usbfs_dentry);
 	devices_usbdevfs_dentry = NULL;
 	devices_usbfs_dentry = NULL;
-	put_mount (&usbdevfs_mount);
-	put_mount (&usbfs_mount);
+	put_mount (&usbdevfs_mount, &usbdevfs_mount_count);
+	put_mount (&usbfs_mount, &usbfs_mount_count);
 }
 
 void usbfs_update_special (void)

drivers/usb/core/message.c

@@ -756,6 +756,7 @@ int usb_clear_halt(struct usb_device *dev, int pipe)
  *
  * This is used to enable data transfers on interfaces that may not
  * be enabled by default.  Not all devices support such configurability.
+ * Only the driver bound to an interface may change its setting.
  *
  * Within any given configuration, each interface may have several
  * alternative settings.  These are often used to control levels of
@@ -808,6 +809,22 @@ int usb_set_interface(struct usb_device *dev, int interface, int alternate)
 				   interface, NULL, 0, HZ * 5)) < 0)
 		return ret;
 
+	/* FIXME drivers shouldn't need to replicate/bugfix the logic here
+	 * when they implement async or easily-killable versions of this or
+	 * other "should-be-internal" functions (like clear_halt).
+	 * should hcd+usbcore postprocess control requests?
+	 */
+
+	/* 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;
+		int	out = !(ep & USB_DIR_IN);
+
+		ep &= USB_ENDPOINT_NUMBER_MASK;
+		(out ? dev->epmaxpacketout : dev->epmaxpacketin ) [ep] = 0;
+		// FIXME want hcd hook here, "no such endpoint"
+	}
 	iface->act_altsetting = alternate;
 
 	/* 9.1.1.5: reset toggles for all endpoints affected by this iface-as
@@ -819,21 +836,20 @@ int usb_set_interface(struct usb_device *dev, int interface, int alternate)
 	 * any SetInterface request and hence assume toggles need to be reset.
 	 * However, EP0 toggles are re-synced for every individual transfer
 	 * during the SETUP stage - hence EP0 toggles are "don't care" here.
+	 * (Likewise, EP0 never "halts" on well designed devices.)
 	 */
 
 	iface_as = &iface->altsetting[alternate];
 	for (i = 0; i < iface_as->bNumEndpoints; i++) {
 		u8	ep = iface_as->endpoint[i].bEndpointAddress;
+		int	out = !(ep & USB_DIR_IN);
 
-		usb_settoggle(dev, ep&USB_ENDPOINT_NUMBER_MASK, usb_endpoint_out(ep), 0);
+		ep &= USB_ENDPOINT_NUMBER_MASK;
+		usb_settoggle (dev, ep, out, 0);
+		(out ? dev->epmaxpacketout : dev->epmaxpacketin) [ep]
+			= iface_as->endpoint [ep].wMaxPacketSize;
 	}
 
-	/* usb_set_maxpacket() sets the maxpacket size for all EP in all
-	 * interfaces but it shouldn't do any harm here: we have changed
-	 * the AS for the requested interface only, hence for unaffected
-	 * interfaces it's just re-application of still-valid values.
-	 */
-	usb_set_maxpacket(dev);
 	return 0;
 }
 

drivers/usb/core/urb.c

@@ -272,9 +272,9 @@ int usb_submit_urb(struct urb *urb, int mem_flags)
 	/* enforce simple/standard policy */
 	allowed = USB_ASYNC_UNLINK;	// affects later unlinks
 	allowed |= URB_NO_DMA_MAP;
+	allowed |= URB_NO_INTERRUPT;
 	switch (temp) {
 	case PIPE_BULK:
-		allowed |= URB_NO_INTERRUPT;
 		if (is_out)
 			allowed |= USB_ZERO_PACKET;
 		/* FALLTHROUGH */

drivers/usb/core/usb.c

@@ -50,6 +50,9 @@ extern int usb_major_init(void);
 extern void usb_major_cleanup(void);
 
 
+int nousb;		/* Disable USB when built into kernel image */
+			/* Not honored on modular build */
+
 
 static int generic_probe (struct device *dev)
 {
@@ -167,6 +170,9 @@ int usb_register(struct usb_driver *new_driver)
 {
 	int retval = 0;
 
+	if (nousb)
+		return -ENODEV;
+
 	new_driver->driver.name = (char *)new_driver->name;
 	new_driver->driver.bus = &usb_bus_type;
 	new_driver->driver.probe = usb_device_probe;
@@ -1338,11 +1344,37 @@ struct bus_type usb_bus_type = {
 	.hotplug =	usb_hotplug,
 };
 
+#ifndef MODULE
+
+static int __init usb_setup_disable(char *str)
+{
+	nousb = 1;
+	return 1;
+}
+
+/* format to disable USB on kernel command line is: nousb */
+__setup("nousb", usb_setup_disable);
+
+#endif
+
+/*
+ * for external read access to <nousb>
+ */
+int usb_disabled(void)
+{
+	return nousb;
+}
+
 /*
  * Init
  */
 static int __init usb_init(void)
 {
+	if (nousb) {
+		info("USB support disabled\n");
+		return 0;
+	}
+
 	bus_register(&usb_bus_type);
 	usb_major_init();
 	usbfs_init();
@@ -1358,6 +1390,10 @@ static int __init usb_init(void)
  */
 static void __exit usb_exit(void)
 {
+	/* This will matter if shutdown/reboot does exitcalls. */
+	if (nousb)
+		return;
+
 	remove_driver(&usb_generic_driver);
 	usb_major_cleanup();
 	usbfs_cleanup();
@@ -1377,6 +1413,7 @@ EXPORT_SYMBOL(usb_epnum_to_ep_desc);
 
 EXPORT_SYMBOL(usb_register);
 EXPORT_SYMBOL(usb_deregister);
+EXPORT_SYMBOL(usb_disabled);
 
 EXPORT_SYMBOL(usb_device_probe);
 EXPORT_SYMBOL(usb_device_remove);

drivers/usb/host/ehci-hcd.c

@@ -985,6 +985,9 @@ MODULE_LICENSE ("GPL");
 static int __init init (void) 
 {
 	dbg (DRIVER_INFO);
+	if (usb_disabled())
+		return -ENODEV;
+
 	dbg ("block sizes: qh %Zd qtd %Zd itd %Zd sitd %Zd",
 		sizeof (struct ehci_qh), sizeof (struct ehci_qtd),
 		sizeof (struct ehci_itd), sizeof (struct ehci_sitd));

drivers/usb/host/hc_sl811.c

@@ -1321,6 +1321,9 @@ static int __init hci_hcd_init (void)
 	int ret;
 
 	DBGFUNC ("Enter hci_hcd_init\n");
+	if (usb_disabled())
+		return -ENODEV;
+
 	ret = hc_found_hci (base_addr, data_reg_addr, irq);
 
 	return ret;

drivers/usb/host/ohci-pci.c

@@ -365,6 +365,9 @@ static struct pci_driver ohci_pci_driver = {
 static int __init ohci_hcd_pci_init (void) 
 {
 	dbg (DRIVER_INFO " (PCI)");
+	if (usb_disabled())
+		return -ENODEV;
+
 	dbg ("block sizes: ed %d td %d",
 		sizeof (struct ed), sizeof (struct td));
 	return pci_module_init (&ohci_pci_driver);

drivers/usb/host/ohci-sa1111.c

@@ -23,6 +23,8 @@
 #error "This file is SA-1111 bus glue.  CONFIG_SA1111 must be defined."
 #endif
 
+extern int usb_disabled(void);
+
 /*-------------------------------------------------------------------------*/
 
 static void sa1111_start_hc(struct sa1111_dev *dev)
@@ -355,6 +357,9 @@ static int ohci_hcd_sa1111_drv_probe(struct device *_dev)
 	struct usb_hcd *hcd = NULL;
 	int ret;
 
+	if (usb_disabled())
+		return -ENODEV;
+
 	ret = usb_hcd_sa1111_probe(&ohci_sa1111_hc_driver, &hcd, dev);
 
 	if (ret == 0)

drivers/usb/host/uhci-hcd.c

@@ -2484,6 +2484,9 @@ static int __init uhci_hcd_init(void)
 
 	info(DRIVER_DESC " " DRIVER_VERSION);
 
+	if (usb_disabled())
+		return -ENODEV;
+
 	if (debug) {
 		errbuf = kmalloc(ERRBUF_LEN, GFP_KERNEL);
 		if (!errbuf)

drivers/usb/input/wacom.c

@@ -402,7 +402,6 @@ static int wacom_probe(struct usb_interface *intf, const struct usb_device_id *i
 	struct usb_device *dev = interface_to_usbdev(intf);
 	struct usb_endpoint_descriptor *endpoint;
 	struct wacom *wacom;
-	char rep_data[2] = {0x02, 0x02};
 	char path[64];
 
 	if (!(wacom = kmalloc(sizeof(struct wacom), GFP_KERNEL)))

drivers/usb/media/Makefile

@@ -14,6 +14,6 @@ obj-$(CONFIG_USB_OV511)		+= ov511.o
 obj-$(CONFIG_USB_PWC)		+= pwc.o
 obj-$(CONFIG_USB_SE401)		+= se401.o
 obj-$(CONFIG_USB_STV680)	+= stv680.o
-obj-$(CONFIG_USB_VICAM)		+= vicam.o
+obj-$(CONFIG_USB_VICAM)		+= vicam.o usbvideo.o
 
 include $(TOPDIR)/Rules.make

drivers/usb/media/vicam.h

-/*
- *
- * Vista Imaging ViCAM / 3Com HomeConnect Usermode Driver
- * Christopher L Cheney (C) 2001
- * 
- */
-
-#ifndef __LINUX_VICAM_H
-#define __LINUX_VICAM_H
-
-
-#ifdef CONFIG_USB_DEBUG
-	static int debug = 1;
-#else
-	static int debug;
-#endif
-
-/* Use our own dbg macro */
-#undef dbg
-#define dbg(format, arg...) do { if (debug) printk(KERN_DEBUG __FILE__ ": " format "\n" , ## arg); } while (0)
-
-#define VICAM_NUMFRAMES 30
-#define VICAM_NUMSBUF 1
-
-/* USB REQUEST NUMBERS */
-#define VICAM_REQ_VENDOR	0xff
-#define VICAM_REQ_CAMERA_POWER	0x50
-#define VICAM_REQ_CAPTURE	0x51
-#define VICAM_REQ_LED_CONTROL	0x55
-#define VICAM_REQ_GET_SOMETHIN	0x56
- 
-/* not required but lets you know camera is on */
-/* camera must be on to turn on led */
-/* 0x01 always on  0x03 on when picture taken (flashes) */
-
-struct picture_parm
-{
-	int width;
-	int height;
-	int brightness;
-	int hue;
-	int colour;
-	int contrast;
-	int whiteness;
-	int depth;
-	int palette;
-};
-
-struct vicam_scratch {
-        unsigned char *data;
-        volatile int state;
-        int offset;
-        int length;
-};
-
-/* Structure to hold all of our device specific stuff */
-struct usb_vicam
-{
-	struct video_device vdev;
-	struct usb_device *udev;
-
-	int open_count;	/* number of times this port has been opened */
-	struct semaphore sem;			/* locks this structure */
-	wait_queue_head_t wait;			/* Processes waiting */ 
-
-	int streaming;
-
-	/* v4l stuff */
-	char *camera_name;
-	char *fbuf;
-	struct urb *urb[VICAM_NUMSBUF];
-	int sizes;
-	int *width;
-	int *height;
-	int maxframesize;
-	struct picture_parm win;
-	struct proc_dir_entry *proc_entry;      /* /proc/se401/videoX */
-	struct urb *readurb;
-};
-
-#endif

drivers/usb/net/usbnet.c

@@ -2092,7 +2092,7 @@ static const struct usb_device_id	products [] = {
 #ifdef	CONFIG_USB_EPSON2888
 {
 	USB_DEVICE (0x0525, 0x2888),	// EPSON USB client
-	driver_info:	(unsigned long) &epson2888_info,
+	.driver_info	= (unsigned long) &epson2888_info,
 },
 #endif
 

drivers/usb/serial/io_ti.c

@@ -2617,47 +2617,47 @@ static void edge_shutdown (struct usb_serial *serial)
 
 
 static struct usb_serial_device_type edgeport_1port_device = {
-	owner:			THIS_MODULE,
-	name:			"Edgeport TI 1 port adapter",
-	id_table:		edgeport_1port_id_table,
-	num_interrupt_in:	1,
-	num_bulk_in:		1,
-	num_bulk_out:		1,
-	num_ports:		1,
-	open:			edge_open,
-	close:			edge_close,
-	throttle:		edge_throttle,
-	unthrottle:		edge_unthrottle,
-	attach:			edge_startup,
-	shutdown:		edge_shutdown,
-	ioctl:			edge_ioctl,
-	set_termios:		edge_set_termios,
-	write:			edge_write,
-	write_room:		edge_write_room,
-	chars_in_buffer:	edge_chars_in_buffer,
-	break_ctl:		edge_break,
+	.owner			= THIS_MODULE,
+	.name			= "Edgeport TI 1 port adapter",
+	.id_table		= edgeport_1port_id_table,
+	.num_interrupt_in	= 1,
+	.num_bulk_in		= 1,
+	.num_bulk_out		= 1,
+	.num_ports		= 1,
+	.open			= edge_open,
+	.close			= edge_close,
+	.throttle		= edge_throttle,
+	.unthrottle		= edge_unthrottle,
+	.attach			= edge_startup,
+	.shutdown		= edge_shutdown,
+	.ioctl			= edge_ioctl,
+	.set_termios		= edge_set_termios,
+	.write			= edge_write,
+	.write_room		= edge_write_room,
+	.chars_in_buffer	= edge_chars_in_buffer,
+	.break_ctl		= edge_break,
 };
 
 static struct usb_serial_device_type edgeport_2port_device = {
-	owner:			THIS_MODULE,
-	name:			"Edgeport TI 2 port adapter",
-	id_table:		edgeport_2port_id_table,
-	num_interrupt_in:	1,
-	num_bulk_in:		2,
-	num_bulk_out:		2,
-	num_ports:		2,
-	open:			edge_open,
-	close:			edge_close,
-	throttle:		edge_throttle,
-	unthrottle:		edge_unthrottle,
-	attach:			edge_startup,
-	shutdown:		edge_shutdown,
-	ioctl:			edge_ioctl,
-	set_termios:		edge_set_termios,
-	write:			edge_write,
-	write_room:		edge_write_room,
-	chars_in_buffer:	edge_chars_in_buffer,
-	break_ctl:		edge_break,
+	.owner			= THIS_MODULE,
+	.name			= "Edgeport TI 2 port adapter",
+	.id_table		= edgeport_2port_id_table,
+	.num_interrupt_in	= 1,
+	.num_bulk_in		= 2,
+	.num_bulk_out		= 2,
+	.num_ports		= 2,
+	.open			= edge_open,
+	.close			= edge_close,
+	.throttle		= edge_throttle,
+	.unthrottle		= edge_unthrottle,
+	.attach			= edge_startup,
+	.shutdown		= edge_shutdown,
+	.ioctl			= edge_ioctl,
+	.set_termios		= edge_set_termios,
+	.write			= edge_write,
+	.write_room		= edge_write_room,
+	.chars_in_buffer	= edge_chars_in_buffer,
+	.break_ctl		= edge_break,
 };
 
 

drivers/usb/serial/usb-serial.c

@@ -1237,16 +1237,17 @@ int usb_serial_probe(struct usb_interface *interface,
 	}
 
 #if defined(CONFIG_USB_SERIAL_PL2303) || defined(CONFIG_USB_SERIAL_PL2303_MODULE)
-#if 0
 	/* BEGIN HORRIBLE HACK FOR PL2303 */ 
 	/* this is needed due to the looney way its endpoints are set up */
-	if (ifnum == 1) {
 	if (((dev->descriptor.idVendor == PL2303_VENDOR_ID) &&
 	     (dev->descriptor.idProduct == PL2303_PRODUCT_ID)) ||
 	    ((dev->descriptor.idVendor == ATEN_VENDOR_ID) &&
 	     (dev->descriptor.idProduct == ATEN_PRODUCT_ID))) {
+		//if (ifnum == 1) {
+		if (interface != &dev->actconfig->interface[0]) {
 			/* check out the endpoints of the other interface*/
-			interface = &dev->actconfig->interface[ifnum ^ 1];
+			//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];
@@ -1259,9 +1260,18 @@ int usb_serial_probe(struct usb_interface *interface,
 				}
 			}
 		}
+
+		/* Now make sure the PL-2303 is configured correctly.
+		 * If not, give up now and hope this hack will work
+		 * properly during a later invocation of usb_serial_probe
+		 */
+		if (num_bulk_in == 0 || num_bulk_out == 0) {
+			info("PL-2303 hack: descriptors matched but endpoints did not");
+			kfree (serial);
+			return -ENODEV;
+		}
 	}
 	/* END HORRIBLE HACK FOR PL2303 */
-#endif
 #endif
 
 	/* found all that we need */

drivers/usb/serial/visor.c

@@ -669,7 +669,7 @@ static int clie_3_5_startup (struct usb_serial *serial)
 	/* get the interface number */
 	result = usb_control_msg (serial->dev, usb_rcvctrlpipe(serial->dev, 0),
 				  USB_REQ_GET_INTERFACE, 
-				  USB_DIR_IN | USB_DT_DEVICE,
+				  USB_DIR_IN | USB_RECIP_INTERFACE,
 				  0, 0, &data, 1, HZ * 3);
 	if (result < 0) {
 		err("%s: get interface number failed: %d", __FUNCTION__, result);

drivers/usb/serial/whiteheat.c

@@ -334,6 +334,12 @@ static int whiteheat_attach (struct usb_serial *serial)
 	command_port = &serial->port[COMMAND_PORT];
 
 	pipe = usb_sndbulkpipe (serial->dev, command_port->bulk_out_endpointAddress);
+	/*
+	 * When the module is reloaded the firmware is still there and
+	 * the endpoints are still in the usb core unchanged. This is the
+         * unlinking bug in disguise. Same for the call below.
+         */
+	usb_clear_halt(serial->dev, pipe);
 	ret = usb_bulk_msg (serial->dev, pipe, command, sizeof(command), &alen, COMMAND_TIMEOUT);
 	if (ret) {
 		err("%s: Couldn't send command [%d]", serial->type->name, ret);
@@ -344,6 +350,8 @@ static int whiteheat_attach (struct usb_serial *serial)
 	}
 
 	pipe = usb_rcvbulkpipe (serial->dev, command_port->bulk_in_endpointAddress);
+	/* See the comment on the usb_clear_halt() above */
+	usb_clear_halt(serial->dev, pipe);
 	ret = usb_bulk_msg (serial->dev, pipe, result, sizeof(result), &alen, COMMAND_TIMEOUT);
 	if (ret) {
 		err("%s: Couldn't get results [%d]", serial->type->name, ret);
@@ -438,6 +446,10 @@ static int whiteheat_open (struct usb_serial_port *port, struct file *filp)
 	if (retval)
 		goto exit;
 
+	/* Work around HCD bugs */
+	usb_clear_halt(port->serial->dev, port->read_urb->pipe);
+	usb_clear_halt(port->serial->dev, port->write_urb->pipe);
+
 	/* Start reading from the device */
 	port->read_urb->dev = port->serial->dev;
 	retval = usb_submit_urb(port->read_urb, GFP_KERNEL);
@@ -489,7 +501,8 @@ static void whiteheat_close(struct usb_serial_port *port, struct file * filp)
 {
 	dbg("%s - port %d", __FUNCTION__, port->number);
 	
-	if (tty_hung_up_p(filp)) {
+	/* filp is NULL when called from usb_serial_disconnect */
+	if (filp && (tty_hung_up_p(filp))) {
 		return;
 	}
 
@@ -1145,6 +1158,9 @@ static int start_command_port(struct usb_serial *serial)
 	command_info = (struct whiteheat_command_private *)command_port->private;
 	spin_lock_irqsave(&command_info->lock, flags);
 	if (!command_info->port_running) {
+		/* Work around HCD bugs */
+		usb_clear_halt(serial->dev, command_port->read_urb->pipe);
+
 		command_port->read_urb->dev = serial->dev;
 		retval = usb_submit_urb(command_port->read_urb, GFP_KERNEL);
 		if (retval) {

drivers/usb/storage/datafab.c

@@ -67,25 +67,23 @@ static int datafab_determine_lun(struct us_data *us,
 
 static inline int
 datafab_bulk_read(struct us_data *us, unsigned char *data, unsigned int len) {
-	unsigned int act_len;	/* ignored */
-
 	if (len == 0)
 		return USB_STOR_XFER_GOOD;
 
 	US_DEBUGP("datafab_bulk_read:  len = %d\n", len);
-	return usb_storage_raw_bulk(us, SCSI_DATA_READ, data, len, &act_len);
+	return usb_stor_bulk_transfer_buf(us, us->recv_bulk_pipe,
+			data, len, NULL);
 }
 
 
 static inline int
 datafab_bulk_write(struct us_data *us, unsigned char *data, unsigned int len) {
-	unsigned int act_len;	/* ignored */
-
 	if (len == 0)
 		return USB_STOR_XFER_GOOD;
 
 	US_DEBUGP("datafab_bulk_write:  len = %d\n", len);
-	return usb_storage_raw_bulk(us, SCSI_DATA_WRITE, data, len, &act_len);
+	return usb_stor_bulk_transfer_buf(us, us->send_bulk_pipe,
+			data, len, NULL);
 }
 
 
@@ -522,6 +520,7 @@ int datafab_transport(Scsi_Cmnd * srb, struct us_data *us)
 		0x00, 0x80, 0x00, 0x01, 0x1F, 0x00, 0x00, 0x00
 	};
 
+	srb->resid = 0;
 	if (!us->extra) {
 		us->extra = kmalloc(sizeof(struct datafab_info), GFP_NOIO);
 		if (!us->extra) {

drivers/usb/storage/freecom.c

@@ -108,72 +108,9 @@ struct freecom_status {
 /* All packets (except for status) are 64 bytes long. */
 #define FCM_PACKET_LENGTH	64
 
-/*
- * Transfer an entire SCSI command's worth of data payload over the bulk
- * pipe.
- *
- * Note that this uses usb_stor_transfer_partial to achieve it's goals -- this
- * function simply determines if we're going to use scatter-gather or not,
- * and acts appropriately.  For now, it also re-interprets the error codes.
- */
-static void us_transfer_freecom(Scsi_Cmnd *srb, struct us_data* us, int transfer_amount)
-{
-	int i;
-	int result = -1;
-	struct scatterlist *sg;
-	unsigned int total_transferred = 0;
-
-	/* was someone foolish enough to request more data than available
-	 * buffer space? */
-	if (transfer_amount > srb->request_bufflen)
-		transfer_amount = srb->request_bufflen;
-
-	/* are we scatter-gathering? */
-	if (srb->use_sg) {
-
-		/* loop over all the scatter gather structures and 
-		 * make the appropriate requests for each, until done
-		 */
-		sg = (struct scatterlist *) srb->request_buffer;
-		for (i = 0; i < srb->use_sg; i++) {
-
-			US_DEBUGP("transfer_amount: %d and total_transferred: %d\n", transfer_amount, total_transferred);
-
-			/* End this if we're done */
-			if (transfer_amount == total_transferred)
-				break;
-
-			/* transfer the lesser of the next buffer or the
-			 * remaining data */
-			if (transfer_amount - total_transferred >= 
-					sg[i].length) {
-				result = usb_stor_transfer_partial(us,
-						sg_address(sg[i]), sg[i].length);
-				total_transferred += sg[i].length;
-			} else {
-				result = usb_stor_transfer_partial(us,
-						sg_address(sg[i]),
-						transfer_amount - total_transferred);
-				total_transferred += transfer_amount - total_transferred;
-			}
-
-			/* if we get an error, end the loop here */
-			if (result)
-				break;
-		}
-	}
-	else
-		/* no scatter-gather, just make the request */
-		result = usb_stor_transfer_partial(us, srb->request_buffer, 
-					     transfer_amount);
-
-	/* return the result in the data structure itself */
-	srb->result = result;
-}
-
 static int
 freecom_readdata (Scsi_Cmnd *srb, struct us_data *us,
-                int ipipe, int opipe, int count)
+                unsigned int ipipe, unsigned int opipe, int count)
 {
         freecom_udata_t extra = (freecom_udata_t) us->extra;
         struct freecom_xfer_wrap *fxfr =
@@ -206,15 +143,15 @@ freecom_readdata (Scsi_Cmnd *srb, struct us_data *us,
 
         /* Now transfer all of our blocks. */
 	US_DEBUGP("Start of read\n");
-	us_transfer_freecom(srb, us, count);
+	result = usb_stor_bulk_transfer_srb(us, ipipe, srb, count);
         US_DEBUGP("freecom_readdata done!\n");
 
-        return USB_STOR_TRANSPORT_GOOD;
+        return result;
 }
 
 static int
 freecom_writedata (Scsi_Cmnd *srb, struct us_data *us,
-                int ipipe, int opipe, int count)
+                int unsigned ipipe, unsigned int opipe, int count)
 {
         freecom_udata_t extra = (freecom_udata_t) us->extra;
         struct freecom_xfer_wrap *fxfr =
@@ -248,10 +185,10 @@ freecom_writedata (Scsi_Cmnd *srb, struct us_data *us,
 
         /* Now transfer all of our blocks. */
 	US_DEBUGP("Start of write\n");
-	us_transfer_freecom(srb, us, count);
+	result = usb_stor_bulk_transfer_srb(us, opipe, srb, count);
 
         US_DEBUGP("freecom_writedata done!\n");
-        return USB_STOR_TRANSPORT_GOOD;
+        return result;
 }
 
 /*
@@ -262,7 +199,7 @@ int freecom_transport(Scsi_Cmnd *srb, struct us_data *us)
 {
         struct freecom_cb_wrap *fcb;
         struct freecom_status  *fst;
-        int ipipe, opipe;             /* We need both pipes. */
+        unsigned int ipipe, opipe;             /* We need both pipes. */
         int result;
         int partial;
         int length;
@@ -276,8 +213,8 @@ int freecom_transport(Scsi_Cmnd *srb, struct us_data *us)
         US_DEBUGP("Freecom TRANSPORT STARTED\n");
 
         /* Get handles for both transports. */
-        opipe = usb_sndbulkpipe (us->pusb_dev, us->ep_out);
-        ipipe = usb_rcvbulkpipe (us->pusb_dev, us->ep_in);
+        opipe = us->send_bulk_pipe;
+        ipipe = us->recv_bulk_pipe;
 
         /* The ATAPI Command always goes out first. */
         fcb->Type = FCM_PACKET_ATAPI | 0x00;
@@ -515,8 +452,7 @@ freecom_init (struct us_data *us)
                 }
         }
 
-	result = usb_control_msg(us->pusb_dev,
-			usb_rcvctrlpipe(us->pusb_dev, 0),
+	result = usb_control_msg(us->pusb_dev, us->recv_ctrl_pipe,
 			0x4c, 0xc0, 0x4346, 0x0, buffer, 0x20, 3*HZ);
 	buffer[32] = '\0';
 	US_DEBUGP("String returned from FC init is: %s\n", buffer);
@@ -528,8 +464,7 @@ freecom_init (struct us_data *us)
 	 */
 
 	/* send reset */
-	result = usb_control_msg(us->pusb_dev,
-			usb_sndctrlpipe(us->pusb_dev, 0),
+	result = usb_control_msg(us->pusb_dev, us->send_ctrl_pipe,
 			0x4d, 0x40, 0x24d8, 0x0, NULL, 0x0, 3*HZ);
 	US_DEBUGP("result from activate reset is %d\n", result);
 
@@ -537,8 +472,7 @@ freecom_init (struct us_data *us)
 	mdelay(250);
 
 	/* clear reset */
-	result = usb_control_msg(us->pusb_dev,
-			usb_sndctrlpipe(us->pusb_dev, 0),
+	result = usb_control_msg(us->pusb_dev, us->send_ctrl_pipe,
 			0x4d, 0x40, 0x24f8, 0x0, NULL, 0x0, 3*HZ);
 	US_DEBUGP("result from clear reset is %d\n", result);
 

drivers/usb/storage/initializers.c

@@ -50,7 +50,7 @@ int usb_stor_euscsi_init(struct us_data *us)
 	int result;
 
 	US_DEBUGP("Attempting to init eUSCSI bridge...\n");
-	result = usb_control_msg(us->pusb_dev, usb_sndctrlpipe(us->pusb_dev, 0),
+	result = usb_control_msg(us->pusb_dev, us->send_ctrl_pipe,
 			0x0C, USB_RECIP_INTERFACE | USB_TYPE_VENDOR,
 			0x01, 0x0, &data, 0x1, 5*HZ);
 	US_DEBUGP("-- result is %d\n", result);

drivers/usb/storage/isd200.c

@@ -408,13 +408,13 @@ static int isd200_transfer_partial( struct us_data *us,
 {
         int result;
         int partial;
-        int pipe;
+        unsigned int pipe;
 
         /* calculate the appropriate pipe information */
 	if (dataDirection == SCSI_DATA_READ)
-                pipe = usb_rcvbulkpipe(us->pusb_dev, us->ep_in);
+                pipe = us->recv_bulk_pipe;
         else
-                pipe = usb_sndbulkpipe(us->pusb_dev, us->ep_out);
+                pipe = us->send_bulk_pipe;
 
         /* transfer the data */
         US_DEBUGP("isd200_transfer_partial(): xfer %d bytes\n", length);
@@ -546,7 +546,6 @@ int isd200_Bulk_transport( struct us_data *us, Scsi_Cmnd *srb,
         struct bulk_cb_wrap bcb;
         struct bulk_cs_wrap bcs;
         int result;
-        int pipe;
         int partial;
         unsigned int transfer_amount;
 
@@ -566,9 +565,6 @@ int isd200_Bulk_transport( struct us_data *us, Scsi_Cmnd *srb,
 
         bcb.Length = AtaCdbLength;
     
-        /* construct the pipe handle */
-        pipe = usb_sndbulkpipe(us->pusb_dev, us->ep_out);
-    
         /* copy the command payload */
         memset(bcb.CDB, 0, sizeof(bcb.CDB));
         memcpy(bcb.CDB, AtaCdb, bcb.Length);
@@ -578,8 +574,8 @@ int isd200_Bulk_transport( struct us_data *us, Scsi_Cmnd *srb,
                   le32_to_cpu(bcb.Signature), bcb.Tag,
                   (bcb.Lun >> 4), (bcb.Lun & 0xFF), 
                   le32_to_cpu(bcb.DataTransferLength), bcb.Flags, bcb.Length);
-        result = usb_stor_bulk_msg(us, &bcb, pipe, US_BULK_CB_WRAP_LEN, 
-				   &partial);
+        result = usb_stor_bulk_msg(us, &bcb, us->send_bulk_pipe,
+				US_BULK_CB_WRAP_LEN, &partial);
         US_DEBUGP("Bulk command transfer result=%d\n", result);
     
 	/* did we abort this command? */
@@ -589,8 +585,9 @@ int isd200_Bulk_transport( struct us_data *us, Scsi_Cmnd *srb,
 
 	else if (result == -EPIPE) {
 		/* if we stall, we need to clear it before we go on */
-                US_DEBUGP("clearing endpoint halt for pipe 0x%x\n", pipe);
-                if (usb_stor_clear_halt(us, pipe) < 0)
+                US_DEBUGP("clearing endpoint halt for pipe 0x%x\n",
+				us->send_bulk_pipe);
+                if (usb_stor_clear_halt(us, us->send_bulk_pipe) < 0)
 			return ISD200_TRANSPORT_ERROR;
 	} else if (result)  
                 return ISD200_TRANSPORT_ERROR;
@@ -608,13 +605,10 @@ int isd200_Bulk_transport( struct us_data *us, Scsi_Cmnd *srb,
          * an explanation of how this code works.
          */
     
-        /* construct the pipe handle */
-        pipe = usb_rcvbulkpipe(us->pusb_dev, us->ep_in);
-    
         /* get CSW for device status */
         US_DEBUGP("Attempting to get CSW...\n");
-        result = usb_stor_bulk_msg(us, &bcs, pipe, US_BULK_CS_WRAP_LEN, 
-				   &partial);
+        result = usb_stor_bulk_msg(us, &bcs, us->recv_bulk_pipe,
+				US_BULK_CS_WRAP_LEN, &partial);
 	/* did we abort this command? */
 	if (atomic_read(&us->sm_state) == US_STATE_ABORTING) {
 		return ISD200_TRANSPORT_ABORTED;
@@ -622,13 +616,14 @@ int isd200_Bulk_transport( struct us_data *us, Scsi_Cmnd *srb,
 
         /* did the attempt to read the CSW fail? */
         if (result == -EPIPE) {
-                US_DEBUGP("clearing endpoint halt for pipe 0x%x\n", pipe);
-                if (usb_stor_clear_halt(us, pipe) < 0)
+                US_DEBUGP("clearing endpoint halt for pipe 0x%x\n",
+				us->recv_bulk_pipe);
+                if (usb_stor_clear_halt(us, us->recv_bulk_pipe) < 0)
 			return ISD200_TRANSPORT_ERROR;
            
                 /* get the status again */
                 US_DEBUGP("Attempting to get CSW (2nd try)...\n");
-                result = usb_stor_bulk_msg(us, &bcs, pipe,
+                result = usb_stor_bulk_msg(us, &bcs, us->recv_bulk_pipe,
                                            US_BULK_CS_WRAP_LEN, &partial);
 
                 /* if the command was aborted, indicate that */
@@ -638,8 +633,9 @@ int isd200_Bulk_transport( struct us_data *us, Scsi_Cmnd *srb,
         
                 /* if it fails again, we need a reset and return an error*/
                 if (result == -EPIPE) {
-                        US_DEBUGP("clearing halt for pipe 0x%x\n", pipe);
-                        usb_stor_clear_halt(us, pipe);
+                        US_DEBUGP("clearing halt for pipe 0x%x\n",
+					us->recv_bulk_pipe);
+                        usb_stor_clear_halt(us, us->recv_bulk_pipe);
                         return ISD200_TRANSPORT_ERROR;
                 }
         }
@@ -937,7 +933,7 @@ int isd200_write_config( struct us_data *us )
 	/* let's send the command via the control pipe */
 	result = usb_stor_control_msg(
                 us, 
-                usb_sndctrlpipe(us->pusb_dev,0),
+                us->send_ctrl_pipe,
                 0x01, 
                 USB_TYPE_VENDOR | USB_RECIP_DEVICE | USB_DIR_OUT,
                 0x0000, 
@@ -978,7 +974,7 @@ int isd200_read_config( struct us_data *us )
 
 	result = usb_stor_control_msg(
                 us, 
-                usb_rcvctrlpipe(us->pusb_dev,0),
+                us->recv_ctrl_pipe,
                 0x02, 
                 USB_TYPE_VENDOR | USB_RECIP_DEVICE | USB_DIR_IN,
                 0x0000, 

drivers/usb/storage/jumpshot.c

@@ -62,13 +62,12 @@ static inline int jumpshot_bulk_read(struct us_data *us,
 				     unsigned char *data, 
 				     unsigned int len)
 {
-	unsigned int act_len;	/* ignored */
-
 	if (len == 0)
 		return USB_STOR_XFER_GOOD;
 
 	US_DEBUGP("jumpshot_bulk_read:  len = %d\n", len);
-	return usb_storage_raw_bulk(us, SCSI_DATA_READ, data, len, &act_len);
+	return usb_stor_bulk_transfer_buf(us, us->recv_bulk_pipe,
+			data, len, NULL);
 }
 
 
@@ -76,13 +75,12 @@ static inline int jumpshot_bulk_write(struct us_data *us,
 				      unsigned char *data, 
 				      unsigned int len)
 {
-	unsigned int act_len;	/* ignored */
-
 	if (len == 0)
 		return USB_STOR_XFER_GOOD;
 
 	US_DEBUGP("jumpshot_bulk_write:  len = %d\n", len);
-	return usb_storage_raw_bulk(us, SCSI_DATA_WRITE, data, len, &act_len);
+	return usb_stor_bulk_transfer_buf(us, us->send_bulk_pipe,
+			data, len, NULL);
 }
 
 
@@ -95,12 +93,11 @@ static int jumpshot_get_status(struct us_data  *us)
 		return USB_STOR_TRANSPORT_ERROR;
 
 	// send the setup
-	rc = usb_storage_send_control(us,
-				   usb_rcvctrlpipe(us->pusb_dev, 0),
+	rc = usb_stor_ctrl_transfer(us, us->recv_ctrl_pipe,
 				   0, 0xA0, 0, 7, &reply, 1);
 
-	if (rc != USB_STOR_TRANSPORT_GOOD)
-		return rc;
+	if (rc != USB_STOR_XFER_GOOD)
+		return USB_STOR_TRANSPORT_ERROR;
 
 	if (reply != 0x50) {
 		US_DEBUGP("jumpshot_get_status:  0x%2x\n",
@@ -160,10 +157,9 @@ static int jumpshot_read_data(struct us_data *us,
 		command[5] |= (sector >> 24) & 0x0F;
 
 		// send the setup + command
-		result = usb_storage_send_control(us,
-					       usb_sndctrlpipe(us->pusb_dev, 0),
+		result = usb_stor_ctrl_transfer(us, us->send_ctrl_pipe,
 					       0, 0x20, 0, 1, command, 7);
-		if (result != USB_STOR_TRANSPORT_GOOD)
+		if (result != USB_STOR_XFER_GOOD)
 			goto leave;
 
 		// read the result
@@ -247,9 +243,10 @@ static int jumpshot_write_data(struct us_data *us,
 		command[5] |= (sector >> 24) & 0x0F;
 
 		// send the setup + command
-		result = usb_storage_send_control(
-			us, usb_sndctrlpipe(us->pusb_dev, 0),
+		result = usb_stor_ctrl_transfer(us, us->send_ctrl_pipe,
 			0, 0x20, 0, 1, command, 7);
+		if (result != USB_STOR_XFER_GOOD)
+			goto leave;
 
 		// send the data
 		result = jumpshot_bulk_write(us, ptr, len);
@@ -302,11 +299,10 @@ static int jumpshot_id_device(struct us_data *us,
 		return USB_STOR_TRANSPORT_ERROR;
 
 	// send the setup
-	rc = usb_storage_send_control(us,
-				   usb_sndctrlpipe(us->pusb_dev, 0),
+	rc = usb_stor_ctrl_transfer(us, us->send_ctrl_pipe,
 				   0, 0x20, 0, 6, command, 2);
 
-	if (rc != USB_STOR_TRANSPORT_GOOD) {
+	if (rc != USB_STOR_XFER_GOOD) {
 		US_DEBUGP("jumpshot_id_device:  Gah! "
 			  "send_control for read_capacity failed\n");
 		return rc;
@@ -468,7 +464,7 @@ int jumpshot_transport(Scsi_Cmnd * srb, struct us_data *us)
 		0x00, 0x80, 0x00, 0x01, 0x1F, 0x00, 0x00, 0x00
 	};
 
-
+	srb->resid = 0;
 	if (!us->extra) {
 		us->extra = kmalloc(sizeof(struct jumpshot_info), GFP_NOIO);
 		if (!us->extra) {

drivers/usb/storage/raw_bulk.c

@@ -13,219 +13,6 @@
 #include "transport.h"
 #include "raw_bulk.h"
 
-#ifdef CONFIG_USB_STORAGE_DEBUG
-#define DEBUG_PRCT 12
-#else
-#define DEBUG_PRCT 0
-#endif
-
-/*
- * Send a control message and wait for the response.
- *
- * us - the pointer to the us_data structure for the device to use
- *
- * request - the URB Setup Packet's first 6 bytes. The first byte always
- *  corresponds to the request type, and the second byte always corresponds
- *  to the request.  The other 4 bytes do not correspond to value and index,
- *  since they are used in a custom way by the SCM protocol.
- *
- * xfer_data - a buffer from which to get, or to which to store, any data
- *  that gets send or received, respectively, with the URB. Even though
- *  it looks like we allocate a buffer in this code for the data, xfer_data
- *  must contain enough allocated space.
- *
- * xfer_len - the number of bytes to send or receive with the URB.
- *
- */
-
-int
-usb_storage_send_control(struct us_data *us,
-			 int pipe,
-			 unsigned char request,
-			 unsigned char requesttype,
-			 unsigned int value,
-			 unsigned int index,
-			 unsigned char *xfer_data,
-			 unsigned int xfer_len) {
-
-	int result;
-
-	// Send the URB to the device and wait for a response.
-
-	/* Why are request and request type reversed in this call? */
-
-	result = usb_stor_control_msg(us, pipe,
-			request, requesttype, value, index,
-			xfer_data, xfer_len);
-
-	/* did we abort this command? */
-	if (atomic_read(&us->sm_state) == US_STATE_ABORTING) {
-		US_DEBUGP("usb_stor_send_control(): transfer aborted\n");
-		return USB_STOR_TRANSPORT_ABORTED;
-	}
-
-	// Check the return code for the command.
-	if (result < 0) {
-
-		/* a stall indicates a protocol error */
-		if (result == -EPIPE) {
-			US_DEBUGP("-- Stall on control pipe\n");
-			return USB_STOR_TRANSPORT_ERROR;
-		}
-
-		/* Uh oh... serious problem here */
-		return USB_STOR_TRANSPORT_ERROR;
-	}
-
-	return USB_STOR_TRANSPORT_GOOD;
-}
-
-int
-usb_storage_raw_bulk(struct us_data *us, int direction, unsigned char *data,
-		     unsigned int len, unsigned int *act_len) {
-
-	int result;
-	int pipe;
-
-	if (direction == SCSI_DATA_READ)
-		pipe = usb_rcvbulkpipe(us->pusb_dev, us->ep_in);
-	else
-		pipe = usb_sndbulkpipe(us->pusb_dev, us->ep_out);
-
-	result = usb_stor_bulk_msg(us, data, pipe, len, act_len);
-
-	/* if we stall, we need to clear it before we go on */
-	if (result == -EPIPE) {
-		US_DEBUGP("EPIPE: clearing endpoint halt for"
-			  " pipe 0x%x, stalled at %d bytes\n",
-			  pipe, *act_len);
-		if (usb_stor_clear_halt(us, pipe) < 0)
-			return USB_STOR_XFER_ERROR;
-		return USB_STOR_XFER_STALLED;
-	}
-
-	/* did we abort this command? */
-	if (atomic_read(&us->sm_state) == US_STATE_ABORTING) {
-		US_DEBUGP("usb_storage_raw_bulk(): transfer aborted\n");
-		return USB_STOR_XFER_ABORTED;
-	}
-
-	if (result) {
-		/* NAK - that means we've retried a few times already */
-       		if (result == -ETIMEDOUT)
-			US_DEBUGP("raw_bulk(): device NAKed\n");
-		else if (result == -EOVERFLOW)
-			US_DEBUGP("raw_bulk(): babble/overflow\n");
-		else if (result == -ECONNRESET)
-			US_DEBUGP("raw_bulk(): asynchronous reset\n");
-		else if (result != -EPIPE)
-			US_DEBUGP("raw_bulk(): unknown error %d\n",
-				  result);
-
-		return USB_STOR_XFER_ERROR;
-	}
-
-	if (*act_len != len) {
-		US_DEBUGP("Warning: Transferred only %d of %d bytes\n",
-			  *act_len, len);
-		return USB_STOR_XFER_SHORT;
-	}
-
-#if 0
-	US_DEBUGP("raw_bulk(): Transferred %s %d of %d bytes\n",
-		  (direction == SCSI_DATA_READ) ? "in" : "out",
-		  *act_len, len);
-#endif
-
-	return USB_STOR_XFER_GOOD;
-}
-
-int
-usb_storage_bulk_transport(struct us_data *us, int direction,
-			   unsigned char *data, unsigned int len,
-			   int use_sg) {
-
-	int result = USB_STOR_XFER_ERROR;
-	int transferred = 0;
-	int i;
-	struct scatterlist *sg;
-	unsigned int act_len;
-
-	if (len == 0)
-		return USB_STOR_XFER_GOOD;
-
-#if DEBUG_PRCT
-
-	if (direction == SCSI_DATA_WRITE && !use_sg) {
-		char string[64];
-
-		/* Debug-print the first N bytes of the write transfer */
-
-		strcpy(string, "wr: ");
-		for (i=0; i<len && i<DEBUG_PRCT; i++) {
-			sprintf(string+strlen(string), "%02X ", data[i]);
-			if ((i%16) == 15) {
-				US_DEBUGP("%s\n", string);
-				strcpy(string, "wr: ");
-			}
-		}
-		if ((i%16)!=0)
-			US_DEBUGP("%s\n", string);
-	}
-
-	US_DEBUGP("SCM data %s transfer %d sg buffers %d\n",
-		  (direction == SCSI_DATA_READ) ? "in" : "out",
-		  len, use_sg);
-
-#endif /* DEBUG_PRCT */
-
-	if (!use_sg)
-		result = usb_storage_raw_bulk(us, direction,
-					      data, len, &act_len);
-	else {
-		sg = (struct scatterlist *)data;
-
-		for (i=0; i<use_sg && transferred<len; i++) {
-			unsigned char *buf;
-			unsigned int length;
-
-			buf = sg_address(sg[i]);
-			length = len-transferred;
-			if (length > sg[i].length)
-				length = sg[i].length;
-
-			result = usb_storage_raw_bulk(us, direction,
-						      buf, length, &act_len);
-			if (result != USB_STOR_XFER_GOOD)
-				break;
-			transferred += length;
-		}
-	}
-
-#if DEBUG_PRCT
-
-	if (direction == SCSI_DATA_READ && !use_sg) {
-		char string[64];
-
-		/* Debug-print the first N bytes of the read transfer */
-
-		strcpy(string, "rd: ");
-		for (i=0; i<len && i<act_len && i<DEBUG_PRCT; i++) {
-			sprintf(string+strlen(string), "%02X ", data[i]);
-			if ((i%16) == 15) {
-				US_DEBUGP("%s\n", string);
-				strcpy(string, "rd: ");
-			}
-		}
-		if ((i%16)!=0)
-			US_DEBUGP("%s\n", string);
-	}
-
-#endif /* DEBUG_PRCT */
-
-	return result;
-}
-
 /*
  * The routines below convert scatter-gather to single buffer.
  * Some drivers claim this is necessary.

drivers/usb/storage/raw_bulk.h

 #ifndef _USB_STORAGE_RAW_BULK_H_
 #define _USB_STORAGE_RAW_BULK_H_
 
-/* usb bulk */
-extern int usb_storage_send_control(
-	struct us_data *us, int pipe,
-	unsigned char request, unsigned char requesttype,
-	unsigned int value, unsigned int index,
-	unsigned char *xfer_data, unsigned int xfer_len);
-
-extern int usb_storage_raw_bulk(
-	struct us_data *us, int direction,
-	unsigned char *data, unsigned int len, unsigned int *act_len);
-
-extern int usb_storage_bulk_transport(
-	struct us_data *us, int direction,
-	unsigned char *data, unsigned int len, int use_sg);
-
 /* scatter-gather */
 extern unsigned char *us_copy_from_sgbuf(
 	unsigned char *content, int buflen,

drivers/usb/storage/sddr09.c

@@ -224,18 +224,21 @@ sddr09_send_command(struct us_data *us,
 		    unsigned char direction,
 		    unsigned char *xfer_data,
 		    unsigned int xfer_len) {
-	int pipe;
+	unsigned int pipe;
 	unsigned char requesttype = (0x41 | direction);
+	int rc;
 
 	// Get the receive or send control pipe number
 
 	if (direction == USB_DIR_IN)
-		pipe = usb_rcvctrlpipe(us->pusb_dev,0);
+		pipe = us->recv_ctrl_pipe;
 	else
-		pipe = usb_sndctrlpipe(us->pusb_dev,0);
+		pipe = us->send_ctrl_pipe;
 
-	return usb_storage_send_control(us, pipe, request, requesttype,
+	rc = usb_stor_ctrl_transfer(us, pipe, request, requesttype,
 				   0, 0, xfer_data, xfer_len);
+	return (rc == USB_STOR_XFER_GOOD ? USB_STOR_TRANSPORT_GOOD :
+			USB_STOR_TRANSPORT_ERROR);
 }
 
 static int
@@ -276,7 +279,6 @@ sddr09_request_sense(struct us_data *us, unsigned char *sensebuf, int buflen) {
 		0x03, LUNBITS, 0, 0, buflen, 0, 0, 0, 0, 0, 0, 0
 	};
 	int result;
-	unsigned int act_len;
 
 	result = sddr09_send_scsi_command(us, command, sizeof(command));
 	if (result != USB_STOR_TRANSPORT_GOOD) {
@@ -284,7 +286,8 @@ sddr09_request_sense(struct us_data *us, unsigned char *sensebuf, int buflen) {
 		return result;
 	}
 
-	result = usb_storage_raw_bulk(us, SCSI_DATA_READ, sensebuf, buflen, &act_len);
+	result = usb_stor_bulk_transfer_buf(us, us->recv_bulk_pipe,
+			sensebuf, buflen, NULL);
 	if (result != USB_STOR_XFER_GOOD) {
 		US_DEBUGP("request sense bulk in failed\n");
 		return USB_STOR_TRANSPORT_ERROR;
@@ -343,11 +346,11 @@ sddr09_readX(struct us_data *us, int x, unsigned long fromaddress,
 		return result;
 	}
 
-	result = usb_storage_bulk_transport(us, SCSI_DATA_READ,
-				       buf, bulklen, use_sg);
+	result = usb_stor_bulk_transfer_sg(us, us->recv_bulk_pipe,
+				       buf, bulklen, use_sg, NULL);
 
 	if (result != USB_STOR_XFER_GOOD) {
-		US_DEBUGP("Result for bulk_transport in sddr09_read2%d %d\n",
+		US_DEBUGP("Result for bulk_transfer in sddr09_read2%d %d\n",
 			  x, result);
 		return USB_STOR_TRANSPORT_ERROR;
 	}
@@ -510,11 +513,11 @@ sddr09_writeX(struct us_data *us,
 		return result;
 	}
 
-	result = usb_storage_bulk_transport(us, SCSI_DATA_WRITE,
-				       buf, bulklen, use_sg);
+	result = usb_stor_bulk_transfer_sg(us, us->send_bulk_pipe,
+				       buf, bulklen, use_sg, NULL);
 
 	if (result != USB_STOR_XFER_GOOD) {
-		US_DEBUGP("Result for bulk_transport in sddr09_writeX %d\n",
+		US_DEBUGP("Result for bulk_transfer in sddr09_writeX %d\n",
 			  result);
 		return USB_STOR_TRANSPORT_ERROR;
 	}
@@ -592,11 +595,11 @@ sddr09_read_sg_test_only(struct us_data *us) {
 	if (!buf)
 		return USB_STOR_TRANSPORT_ERROR;
 
-	result = usb_storage_bulk_transport(us, SCSI_DATA_READ,
-				       buf, bulklen, 0);
+	result = usb_stor_bulk_transfer_buf(us, us->recv_bulk_pipe,
+				       buf, bulklen, NULL);
 	kfree(buf);
 	if (result != USB_STOR_XFER_GOOD) {
-		US_DEBUGP("Result for bulk_transport in sddr09_read_sg %d\n",
+		US_DEBUGP("Result for bulk_transfer in sddr09_read_sg %d\n",
 			  result);
 		return USB_STOR_TRANSPORT_ERROR;
 	}
@@ -631,8 +634,8 @@ sddr09_read_status(struct us_data *us, unsigned char *status) {
 	if (result != USB_STOR_TRANSPORT_GOOD)
 		return result;
 
-	result = usb_storage_bulk_transport(us, SCSI_DATA_READ,
-				       data, sizeof(data), 0);
+	result = usb_stor_bulk_transfer_buf(us, us->recv_bulk_pipe,
+				       data, sizeof(data), NULL);
 	*status = data[0];
 	return (result == USB_STOR_XFER_GOOD ?
 			USB_STOR_TRANSPORT_GOOD : USB_STOR_TRANSPORT_ERROR);
@@ -954,7 +957,8 @@ sddr09_read_deviceID(struct us_data *us, unsigned char *deviceID) {
 	if (result != USB_STOR_TRANSPORT_GOOD)
 		return result;
 
-	result = usb_storage_bulk_transport(us, SCSI_DATA_READ, content, 64, 0);
+	result = usb_stor_bulk_transfer_buf(us, us->recv_bulk_pipe,
+			content, 64, NULL);
 
 	for (i = 0; i < 4; i++)
 		deviceID[i] = content[i];
@@ -1368,6 +1372,7 @@ int sddr09_transport(Scsi_Cmnd *srb, struct us_data *us)
 		0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00
 	};
 
+	srb->resid = 0;
 	info = (struct sddr09_card_info *)us->extra;
 	if (!info) {
 		nand_init_ecc();
@@ -1544,17 +1549,16 @@ int sddr09_transport(Scsi_Cmnd *srb, struct us_data *us)
 
 	if (srb->sc_data_direction == SCSI_DATA_WRITE ||
 	    srb->sc_data_direction == SCSI_DATA_READ) {
+		unsigned int pipe = (srb->sc_data_direction == SCSI_DATA_WRITE)
+				? us->send_bulk_pipe : us->recv_bulk_pipe;
 
 		US_DEBUGP("SDDR09: %s %d bytes\n",
 			  (srb->sc_data_direction == SCSI_DATA_WRITE) ?
 			  "sending" : "receiving",
 			  srb->request_bufflen);
 
-		result = usb_storage_bulk_transport(us,
-					       srb->sc_data_direction,
-					       srb->request_buffer, 
-					       srb->request_bufflen,
-					       srb->use_sg);
+		result = usb_stor_bulk_transfer_srb(us, pipe, srb,
+							srb->request_bufflen);
 
 		return (result == USB_STOR_XFER_GOOD ?
 			USB_STOR_TRANSPORT_GOOD : USB_STOR_TRANSPORT_ERROR);

drivers/usb/storage/sddr55.c

@@ -75,10 +75,13 @@ static int
 sddr55_bulk_transport(struct us_data *us, int direction,
 		      unsigned char *data, unsigned int len) {
 	struct sddr55_card_info *info = (struct sddr55_card_info *)us->extra;
+	unsigned int pipe = (direction == SCSI_DATA_READ) ?
+			us->recv_bulk_pipe : us->send_bulk_pipe;
 
-	if (len)
+	if (!len)
+		return USB_STOR_XFER_GOOD;
 	info->last_access = jiffies;
-	return usb_storage_bulk_transport(us, direction, data, len, 0);
+	return usb_stor_bulk_transfer_buf(us, pipe, data, len, NULL);
 }
 
 /* check if card inserted, if there is, update read_only status
@@ -743,6 +746,7 @@ int sddr55_transport(Scsi_Cmnd *srb, struct us_data *us)
 	unsigned short pages;
 	struct sddr55_card_info *info;
 
+	srb->resid = 0;
 	if (!us->extra) {
 		us->extra = kmalloc(
 			sizeof(struct sddr55_card_info), GFP_NOIO);

drivers/usb/storage/transport.h

@@ -115,7 +115,7 @@ struct bulk_cs_wrap {
 #define US_BULK_GET_MAX_LUN	0xfe
 
 /*
- * usb_stor_transfer() return codes, in order of severity
+ * usb_stor_bulk_transfer_xxx() return codes, in order of severity
  */
 #define USB_STOR_XFER_GOOD		0  /* good transfer                 */
 #define USB_STOR_XFER_SHORT		1  /* transfered less than expected */
@@ -151,14 +151,26 @@ extern int usb_stor_Bulk_reset(struct us_data*);
 extern unsigned int usb_stor_transfer_length(Scsi_Cmnd*);
 extern void usb_stor_invoke_transport(Scsi_Cmnd*, struct us_data*);
 extern void usb_stor_abort_transport(struct us_data*);
-extern int usb_stor_transfer_partial(struct us_data*, char*, int);
 
-extern int usb_stor_bulk_msg(struct us_data *us, void *data, int pipe,
-		unsigned int len, unsigned int *act_len);
+extern int usb_stor_bulk_msg(struct us_data *us, void *data,
+		unsigned int pipe, unsigned int len, unsigned int *act_len);
 extern int usb_stor_control_msg(struct us_data *us, unsigned int pipe,
 		u8 request, u8 requesttype, u16 value, u16 index,
 		void *data, u16 size);
 
-extern int usb_stor_clear_halt(struct us_data*, int );
-extern void usb_stor_transfer(Scsi_Cmnd*, struct us_data*);
+extern int usb_stor_clear_halt(struct us_data*, unsigned int pipe);
+extern int usb_stor_ctrl_transfer(struct us_data *us, unsigned int pipe,
+		u8 request, u8 requesttype, u16 value, u16 index,
+		void *data, u16 size);
+extern int usb_stor_bulk_transfer_buf(struct us_data *us, unsigned int pipe,
+		char *buf, unsigned int length, unsigned int *act_len);
+extern int usb_stor_bulk_transfer_sg(struct us_data *us, unsigned int pipe,
+		char *buf, unsigned int length, int use_sg, int *residual);
+
+static __inline__ int usb_stor_bulk_transfer_srb(struct us_data *us,
+		unsigned int pipe, Scsi_Cmnd *srb, unsigned int length) {
+	return usb_stor_bulk_transfer_sg(us, pipe, srb->request_buffer,
+			length, srb->use_sg, &srb->resid);
+}
+
 #endif

drivers/usb/storage/usb.c

@@ -525,6 +525,12 @@ static int usb_stor_allocate_urbs(struct us_data *ss)
 	int maxp;
 	int result;
 
+	/* calculate and store the pipe values */
+	ss->send_bulk_pipe = usb_sndbulkpipe(ss->pusb_dev, ss->ep_out);
+	ss->recv_bulk_pipe = usb_rcvbulkpipe(ss->pusb_dev, ss->ep_in);
+	ss->send_ctrl_pipe = usb_sndctrlpipe(ss->pusb_dev, 0);
+	ss->recv_ctrl_pipe = usb_rcvctrlpipe(ss->pusb_dev, 0);
+
 	/* allocate the usb_ctrlrequest for control packets */
 	US_DEBUGP("Allocating usb_ctrlrequest\n");
 	ss->dr = kmalloc(sizeof(struct usb_ctrlrequest), GFP_NOIO);

drivers/usb/storage/usb.h

@@ -134,6 +134,10 @@ struct us_data {
 	struct semaphore	dev_semaphore;	 /* protect pusb_dev */
 	struct usb_device	*pusb_dev;	 /* this usb_device */
 	unsigned long		flags;		 /* from filter initially */
+	unsigned int		send_bulk_pipe;	 /* cached pipe values */
+	unsigned int		recv_bulk_pipe;
+	unsigned int		send_ctrl_pipe;
+	unsigned int		recv_ctrl_pipe;
 
 	/* information about the device -- always good */
 	char			vendor[USB_STOR_STRING_LEN];

include/linux/videodev.h

@@ -397,6 +397,7 @@ struct video_code
 #define VID_HARDWARE_PWC	31	/* Philips webcams */
 #define VID_HARDWARE_MEYE	32	/* Sony Vaio MotionEye cameras */
 #define VID_HARDWARE_CPIA2	33
+#define VID_HARDWARE_VICAM	34
 
 #endif /* __LINUX_VIDEODEV_H */