Merge kroah.com:/home/greg/linux/BK/bleeding_edge-2.5

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

Documentation/usb/dc2xx.txt

-14 April 2000
-david-b@pacbell.net
-
-This is an overview of how to use the "dc2xx" USB driver with certain
-digital still cameras from Kodak and other vendors.
-
-
-CAMERAS
-
-This driver will mostly be used with Kodak DC-2xx series digital still
-cameras, but it should be trivial to tell it about several non-Kodak
-USB-enabled cameras.
-
-You'll most likely want to hook it up to recent versions of "gPhoto"
-(www.gphoto.org), since version 0.4 and later know how to use it to talk
-to Kodak DC-240 and DC-280 cameras over USB.
-
-In addition the DC-220, DC-260, DC-265, and DC-290 are also recognized.
-However, like other cameras using the "Digita OS" (from www.flashpoint.com)
-there is no gPhoto support for this camera.  There is a python script
-for accessing these cameras (see archives of the linux-usb mailing list)
-and a "Digita Services" library that can also use this driver.
-
-The HP PhotoSmart C500 should also work, since it's another Digita camera
-with USB support.
-
-
-USB HARDWARE
-
-Recent kernels have had no particular problems using this driver with
-either OHCI or UHCI chipsets, and have worked on the PowerMac platform.
-
-Note that in some cases changes in BIOS settings may be needed before
-your USB works.  At least one user has reported a need for SMP-related 
-settings as well, and some old hardware may not handle USB correctly.
-
-
-SETUP
-
-Configure in the DC2XX USB driver, and have it in your kernel.  It works
-as a module, or compiled in directly.
-
-Create at least one device, perhaps like this (both read and write):
-
-    # mknod -m 0660 /dev/usb/dc2xx0 c 180 80
-    # mknod -m 0660 /dev/usb/dc2xx1 c 180 81
-    ...
-
-NOTE:  you would normally configure PAM so that the user logged in at
-the console is granted ownership of these devices.  console.perms(5)
-explains how to do this.
-
-The driver supports multiple device nodes.  The USB framework supports
-a maximum of sixteen device nodes (up to minor device number 96).
-
-When you plug in one camera, it will use the first device node (dc2xx0
-in the example above).  A second camera will use the second device node,
-and so on.
-
-
-SANITY TESTING
-
-First:  if you've got /proc support, make sure that the driver has hooked
-itself up correctly.
-
-    - You should see an entry in /proc/bus/usb/drivers for "dc2xx",
-      if you enabled USB /proc support and correctly mounted the
-      usbdevfs on /proc/bus/usb.
-
-Second:  when you connect your camera to the computer, does it get recognized
-by the driver?  (Make sure the camera is powered on!)
-
-    - if you've got /proc/bus/usb/devices, you should see an entry
-      something like this.  The "ProdID" may be different if you didn't
-      plug in a DC-240, as may the strings presented, but "Driver=dc2xx"
-      had better be there.
-
-	T:  Lev=01 Prnt=00 Port=00 Cnt=01 Dev#=  1 Spd=12  MxCh= 0
-	D:  Ver= 1.00 Cls=00(>ifc ) Sub=00 Prot=00 MxPS= 8 #Cfgs=  1
-	P:  Vendor=040a ProdID=0120 Rev= 1.08
-	S:  Manufacturer=Eastman Kodak Company
-	S:  Product=KODAK DC240 Zoom Digital Camera
-	C:* #Ifs= 1 Cfg#= 1 Atr=40 MxPwr=100mA
-	I:  If#= 0 Alt= 0 #EPs= 2 Cls=00(>ifc ) Sub=00 Prot=00 Driver=dc2xx
-	E:  Ad=01(O) Atr=02(Bulk) MxPS=  64 Ivl=  0ms
-	E:  Ad=82(I) Atr=02(Bulk) MxPS=  64 Ivl=  0ms
-
-    - see if "dmesg" output tells you that you plugged in your camera.
-
-	Manufacturer: Eastman Kodak Company
-	Product: KODAK DC240 Zoom Digital Camera
-	dc2xx.c: USB Camera #0 connected
-
-Third:  (optional) can you use gPhoto to talk to the camera?
-
-    - When you configure your camera, tell it to use "/dev/usb/dc2xx0"
-      (or whatever name you used).  Right now, gPhoto emits a diagnostic
-      message (non-GUI) saying that it since it didn't act like a TTY,
-      it's assuming it's got a USB connection.
-
-    - With the camera turned on, get the "camera summary".  It'll
-      talk to the camera -- and tell you you're using USB.
-
-If you got that far, you should be able to use everything fine.
-
-
-ADDITIONAL INFORMATION
-
-You may find that you need more driver-specific information, which is
-currently accessible through a link from http://www.linux-usb.org/
-along with other Linux USB resources.

drivers/usb/core/hcd.c

@@ -310,7 +310,7 @@ static int rh_string (
 
 	// serial number
 	} else if (id == 1) {
-		strcpy (buf, hcd->bus_name);
+		strcpy (buf, hcd->self.bus_name);
 
 	// product description
 	} else if (id == 2) {
@@ -406,7 +406,7 @@ static int rh_call_control (struct usb_hcd *hcd, struct urb *urb)
 	case DeviceOutRequest | USB_REQ_SET_ADDRESS:
 		// wValue == urb->dev->devaddr
 		dbg ("%s root hub device address %d",
-			hcd->bus_name, wValue);
+			hcd->self.bus_name, wValue);
 		break;
 
 	/* INTERFACE REQUESTS (no defined feature/status flags) */
@@ -520,7 +520,7 @@ static void rh_report_status (unsigned long ptr)
 					&& rh_status_urb (hcd, urb) != 0) {
 				/* another driver snuck in? */
 				dbg ("%s, can't resubmit roothub status urb?",
-					hcd->bus_name);
+					hcd->self.bus_name);
 				spin_unlock_irqrestore (&hcd_data_lock, flags);
 				BUG ();
 			}
@@ -1051,8 +1051,7 @@ int usb_hcd_pci_probe (struct pci_dev *dev, const struct pci_device_id *id)
 	usb_init_bus (&hcd->self);
 	hcd->self.op = &hcd_operations;
 	hcd->self.hcpriv = (void *) hcd;
-	hcd->bus = &hcd->self;
-	hcd->bus_name = dev->slot_name;
+	hcd->self.bus_name = dev->slot_name;
 	hcd->product_desc = dev->name;
 
 	INIT_LIST_HEAD (&hcd->dev_list);
@@ -1089,16 +1088,15 @@ void usb_hcd_pci_remove (struct pci_dev *dev)
 	hcd = pci_get_drvdata(dev);
 	if (!hcd)
 		return;
-	info ("remove: %s, state %x", hcd->bus_name, hcd->state);
+	info ("remove: %s, state %x", hcd->self.bus_name, hcd->state);
 
 	if (in_interrupt ()) BUG ();
 
-	hub = hcd->bus->root_hub;
+	hub = hcd->self.root_hub;
 	hcd->state = USB_STATE_QUIESCING;
 
-	dbg ("%s: roothub graceful disconnect", hcd->bus_name);
+	dbg ("%s: roothub graceful disconnect", hcd->self.bus_name);
 	usb_disconnect (&hub);
-	// usb_disconnect (&hcd->bus->root_hub);
 
 	hcd->driver->stop (hcd);
 	hcd->state = USB_STATE_HALT;
@@ -1113,10 +1111,9 @@ void usb_hcd_pci_remove (struct pci_dev *dev)
 			pci_resource_len (dev, hcd->region));
 	}
 
-	usb_deregister_bus (hcd->bus);
+	usb_deregister_bus (&hcd->self);
 	if (atomic_read (&hcd->self.refcnt) != 1)
-		err ("usb_hcd_pci_remove %s, count != 1", hcd->bus_name);
-	hcd->bus = NULL;
+		err ("usb_hcd_pci_remove %s, count != 1", hcd->self.bus_name);
 
 	hcd->driver->hcd_free (hcd);
 }
@@ -1164,7 +1161,7 @@ int usb_hcd_pci_suspend (struct pci_dev *dev, u32 state)
 	int			retval;
 
 	hcd = pci_get_drvdata(dev);
-	info ("suspend %s to state %d", hcd->bus_name, state);
+	info ("suspend %s to state %d", hcd->self.bus_name, state);
 
 	pci_save_state (dev, hcd->pci_state);
 
@@ -1193,12 +1190,12 @@ int usb_hcd_pci_resume (struct pci_dev *dev)
 	int			retval;
 
 	hcd = pci_get_drvdata(dev);
-	info ("resume %s", hcd->bus_name);
+	info ("resume %s", hcd->self.bus_name);
 
 	/* guard against multiple resumes (APM bug?) */
 	atomic_inc (&hcd->resume_count);
 	if (atomic_read (&hcd->resume_count) != 1) {
-		err ("concurrent PCI resumes for %s", hcd->bus_name);
+		err ("concurrent PCI resumes for %s", hcd->self.bus_name);
 		retval = 0;
 		goto done;
 	}
@@ -1215,7 +1212,7 @@ int usb_hcd_pci_resume (struct pci_dev *dev)
 
 	retval = hcd->driver->resume (hcd);
 	if (!HCD_IS_RUNNING (hcd->state)) {
-		dbg ("resume %s failure, retval %d", hcd->bus_name, retval);
+		dbg ("resume %s failure, retval %d", hcd->self.bus_name, retval);
 		hc_died (hcd);
 // FIXME:  recover, reset etc.
 	} else {
@@ -1290,7 +1287,7 @@ static void hc_died (struct usb_hcd *hcd)
 		list_for_each (urblist, &dev->urb_list) {
 			urb = list_entry (urblist, struct urb, urb_list);
 			dbg ("shutdown %s urb %p pipe %x, current status %d",
-				hcd->bus_name, urb, urb->pipe, urb->status);
+				hcd->self.bus_name, urb, urb->pipe, urb->status);
 			if (urb->status == -EINPROGRESS)
 				urb->status = -ESHUTDOWN;
 		}
@@ -1534,7 +1531,7 @@ static int hcd_submit_urb (struct urb *urb, int mem_flags)
 	 * since we report some queuing/setup errors ourselves
 	 */
 	urb = usb_get_urb (urb);
-	if (urb->dev == hcd->bus->root_hub)
+	if (urb->dev == hcd->self.root_hub)
 		status = rh_urb_enqueue (hcd, urb);
 	else
 		status = hcd->driver->urb_enqueue (hcd, urb, mem_flags);
@@ -1686,7 +1683,7 @@ if (retval && urb->status == -ENOENT) err ("whoa! retval %d", retval);
 			&& HCD_IS_RUNNING (hcd->state)
 			&& !retval) {
 		dbg ("%s: wait for giveback urb %p",
-			hcd->bus_name, urb);
+			hcd->self.bus_name, urb);
 		wait_for_completion (&splice.done);
 	} else if ((urb->transfer_flags & USB_ASYNC_UNLINK) && retval == 0) {
 		return -EINPROGRESS;
@@ -1698,7 +1695,7 @@ if (retval && urb->status == -ENOENT) err ("whoa! retval %d", retval);
 bye:
 	if (retval)
 		dbg ("%s: hcd_unlink_urb fail %d",
-		    hcd ? hcd->bus_name : "(no bus?)",
+		    hcd ? hcd->self.bus_name : "(no bus?)",
 		    retval);
 	return retval;
 }
@@ -1731,7 +1728,7 @@ static int hcd_free_dev (struct usb_device *udev)
 	/* device driver problem with refcounts? */
 	if (!list_empty (&dev->urb_list)) {
 		dbg ("free busy dev, %s devnum %d (bug!)",
-			hcd->bus_name, udev->devnum);
+			hcd->self.bus_name, udev->devnum);
 		return -EINVAL;
 	}
 

drivers/usb/core/hcd.h

@@ -35,10 +35,8 @@ struct usb_hcd {	/* usb_bus.hcpriv points to this */
 	/*
 	 * housekeeping
 	 */
-	struct usb_bus		*bus;		/* FIXME only use "self" */
 	struct usb_bus		self;		/* hcd is-a bus */
 
-	const char		*bus_name;
 	const char		*product_desc;	/* product/vendor string */
 	const char		*description;	/* "ehci-hcd" etc */
 

drivers/usb/core/hub.c

@@ -765,23 +765,23 @@ static void usb_hub_port_connect_change(struct usb_hub *hubstate, int port,
 		 * devices by location for diagnostics, tools, etc.  The
 		 * string is a path along hub ports, from the root.  Each
 		 * device's id will be stable until USB is re-cabled, and
-		 * hubs are often labled with these port numbers.
+		 * hubs are often labeled with these port numbers.
 		 *
-		 * Initial size: "/NN" times five hubs + NUL = 16 bytes max
+		 * Initial size: ".NN" times five hubs + NUL = 16 bytes max
 		 * (quite rare, since most hubs have 4-6 ports).
 		 */
 		pdev = dev->parent;
-		if (pdev->devpath [1] != '\0')	/* parent not root */
+		if (pdev->devpath [0] != '/')	/* parent not root */
 			len = snprintf (dev->devpath, sizeof dev->devpath,
-				"%s/%d", pdev->devpath, port + 1);
-		else	/* root == "/", root port 2 == "/2" */
+				"%s.%d", pdev->devpath, port + 1);
+		else	/* root == "/", root port 2 == "2", port 3 that hub "/2.3" */
 			len = snprintf (dev->devpath, sizeof dev->devpath,
-				"/%d", port + 1);
+				"%d", port + 1);
 		if (len == sizeof dev->devpath)
 			warn ("devpath size! usb/%03d/%03d path %s",
 				dev->bus->busnum, dev->devnum, dev->devpath);
-		info("new USB device on bus %d path %s, assigned address %d",
-			dev->bus->busnum, dev->devpath, dev->devnum);
+		info("new USB device %s-%s, assigned address %d",
+			dev->bus->bus_name, dev->devpath, dev->devnum);
 
 		/* put the device in the global device tree */
 		dev->dev.parent = &dev->parent->dev;

drivers/usb/core/usb.c

@@ -2407,56 +2407,6 @@ int usb_string(struct usb_device *dev, int index, char *buf, size_t size)
 	return err;
 }
 
-/**
- * usb_make_path - returns device path in the hub tree
- * @dev: the device whose path is being constructed
- * @buf: where to put the string
- * @size: how big is "buf"?
- * Context: !in_interrupt ()
- *
- * Returns length of the string (>= 0) or out of memory status (< 0).
- *
- * NOTE:  prefer to use use dev->devpath directly.
- */
-int usb_make_path(struct usb_device *dev, char *buf, size_t size)
-{
-	struct usb_device *pdev = dev->parent;
-	char *tmp;
-	char *port;
-	int i;
-
-	if (!(port = kmalloc(size, GFP_KERNEL)))
-		return -ENOMEM;
-	if (!(tmp = kmalloc(size, GFP_KERNEL))) {
-		kfree(port);
-		return -ENOMEM;
-	}
-
-	*port = 0;
-	while (pdev) {
-		for (i = 0; i < pdev->maxchild; i++)
-			if (pdev->children[i] == dev)
-				break;
-
-		if (pdev->children[i] != dev) {
-			kfree(port);
-			kfree(tmp);
-			return -ENODEV;
-		}
-
-		strcpy(tmp, port);
-		snprintf(port, size, strlen(port) ? "%d.%s" : "%d", i + 1, tmp);
-
-		dev = pdev;
-		pdev = dev->parent;
-	}
-
-	snprintf(buf, size, "usb%d:%s", dev->bus->busnum, port);
-	kfree(port);
-	kfree(tmp);
-	return strlen(buf);
-}
-
 /*
  * By the time we get here, the device has gotten a new device ID
  * and is in the default state. We need to identify the thing and

drivers/usb/host/ehci-dbg.c

@@ -55,7 +55,7 @@ static void dbg_hcs_params (struct ehci_hcd *ehci, char *label)
 			strcat(buf, tmp);
 		}
 		dbg ("%s: %s portroute %s", 
-			ehci->hcd.bus_name, label,
+			ehci->hcd.self.bus_name, label,
 			buf);
 	}
 }

drivers/usb/host/ehci-hcd.c

@@ -248,7 +248,7 @@ static int ehci_start (struct usb_hcd *hcd)
 	ehci->tasklet.data = (unsigned long) ehci;
 
 	/* wire up the root hub */
-	hcd->bus->root_hub = udev = usb_alloc_dev (NULL, hcd->bus);
+	hcd->self.root_hub = udev = usb_alloc_dev (NULL, &hcd->self);
 	if (!udev) {
 done2:
 		ehci_mem_cleanup (ehci);
@@ -288,8 +288,7 @@ static int ehci_start (struct usb_hcd *hcd)
 		while (readl (&ehci->regs->status) & (STS_ASS | STS_PSS))
 			udelay (100);
 		ehci_reset (ehci);
-		// usb_disconnect (udev); 
-		hcd->bus->root_hub = 0;
+		hcd->self.root_hub = 0;
 		usb_free_dev (udev); 
 		retval = -ENODEV;
 		goto done2;
@@ -304,7 +303,7 @@ static void ehci_stop (struct usb_hcd *hcd)
 {
 	struct ehci_hcd		*ehci = hcd_to_ehci (hcd);
 
-	dbg ("%s: stop", hcd->bus_name);
+	dbg ("%s: stop", hcd->self.bus_name);
 
 	if (hcd->state == USB_STATE_RUNNING)
 		ehci_ready (ehci);
@@ -339,7 +338,7 @@ static int ehci_suspend (struct usb_hcd *hcd, u32 state)
 	int			ports;
 	int			i;
 
-	dbg ("%s: suspend to %d", hcd->bus_name, state);
+	dbg ("%s: suspend to %d", hcd->self.bus_name, state);
 
 	ports = HCS_N_PORTS (ehci->hcs_params);
 
@@ -356,7 +355,7 @@ static int ehci_suspend (struct usb_hcd *hcd, u32 state)
 		if ((temp & PORT_PE) == 0
 				|| (temp & PORT_OWNER) != 0)
 			continue;
-dbg ("%s: suspend port %d", hcd->bus_name, i);
+dbg ("%s: suspend port %d", hcd->self.bus_name, i);
 		temp |= PORT_SUSPEND;
 		writel (temp, &ehci->regs->port_status [i]);
 	}
@@ -380,7 +379,7 @@ static int ehci_resume (struct usb_hcd *hcd)
 	int			ports;
 	int			i;
 
-	dbg ("%s: resume", hcd->bus_name);
+	dbg ("%s: resume", hcd->self.bus_name);
 
 	ports = HCS_N_PORTS (ehci->hcs_params);
 
@@ -400,7 +399,7 @@ static int ehci_resume (struct usb_hcd *hcd)
 		if ((temp & PORT_PE) == 0
 				|| (temp & PORT_SUSPEND) != 0)
 			continue;
-dbg ("%s: resume port %d", hcd->bus_name, i);
+dbg ("%s: resume port %d", hcd->self.bus_name, i);
 		temp |= PORT_RESUME;
 		writel (temp, &ehci->regs->port_status [i]);
 		readl (&ehci->regs->command);	/* unblock posted writes */
@@ -472,7 +471,7 @@ static void ehci_irq (struct usb_hcd *hcd)
 
 	/* PCI errors [4.15.2.4] */
 	if (unlikely ((status & STS_FATAL) != 0)) {
-		err ("%s: fatal error, state %x", hcd->bus_name, hcd->state);
+		err ("%s: fatal error, state %x", hcd->self.bus_name, hcd->state);
 		ehci_reset (ehci);
 		// generic layer kills/unlinks all urbs
 		// then tasklet cleans up the rest
@@ -547,7 +546,7 @@ static int ehci_urb_dequeue (struct usb_hcd *hcd, struct urb *urb)
 	unsigned long		flags;
 
 	dbg ("%s urb_dequeue %p qh state %d",
-		hcd->bus_name, urb, qh->qh_state);
+		hcd->self.bus_name, urb, qh->qh_state);
 
 	switch (usb_pipetype (urb->pipe)) {
 	case PIPE_CONTROL:
@@ -608,7 +607,7 @@ static void ehci_free_config (struct usb_hcd *hcd, struct usb_device *udev)
 
 	/* ASSERT:  nobody can be submitting urbs for this any more */
 
-	dbg ("%s: free_config devnum %d", hcd->bus_name, udev->devnum);
+	dbg ("%s: free_config devnum %d", hcd->self.bus_name, udev->devnum);
 
 	spin_lock_irqsave (&ehci->lock, flags);
 	for (i = 0; i < 32; i++) {

drivers/usb/host/ehci-hub.c

@@ -41,14 +41,14 @@ static int check_reset_complete (
 	/* if reset finished and it's still not enabled -- handoff */
 	if (!(port_status & PORT_PE)) {
 		dbg ("%s port %d full speed, give to companion, 0x%x",
-			ehci->hcd.bus_name, index + 1, port_status);
+			ehci->hcd.self.bus_name, index + 1, port_status);
 
 		// what happens if HCS_N_CC(params) == 0 ?
 		port_status |= PORT_OWNER;
 		writel (port_status, &ehci->regs->port_status [index]);
 
 	} else
-		dbg ("%s port %d high speed", ehci->hcd.bus_name, index + 1);
+		dbg ("%s port %d high speed", ehci->hcd.self.bus_name, index + 1);
 
 	return port_status;
 }
@@ -306,11 +306,11 @@ static int ehci_hub_control (
 			if ((temp & (PORT_PE|PORT_CONNECT)) == PORT_CONNECT
 					&& PORT_USB11 (temp)) {
 				dbg ("%s port %d low speed, give to companion",
-					hcd->bus_name, wIndex + 1);
+					hcd->self.bus_name, wIndex + 1);
 				temp |= PORT_OWNER;
 			} else {
 				vdbg ("%s port %d reset",
-					hcd->bus_name, wIndex + 1);
+					hcd->self.bus_name, wIndex + 1);
 				temp |= PORT_RESET;
 				temp &= ~PORT_PE;
 

drivers/usb/host/ehci-q.c

@@ -733,7 +733,7 @@ submit_async (
 		epnum |= 0x10;
 
 	vdbg ("%s: submit_async urb %p len %d ep %d-%s qtd %p [qh %p]",
-		ehci->hcd.bus_name, urb, urb->transfer_buffer_length,
+		ehci->hcd.self.bus_name, urb, urb->transfer_buffer_length,
 		epnum & 0x0f, (epnum & 0x10) ? "in" : "out",
 		qtd, dev ? dev->ep [epnum] : (void *)~0);
 

drivers/usb/host/ohci-dbg.c

@@ -89,7 +89,7 @@ void ohci_dump_periodic (struct ohci_hcd *ohci, char *label)
 			continue;
 		printed = 1;
 		printk (KERN_DEBUG "%s, ohci %s frame %2d:",
-				label, ohci->hcd.bus_name, i);
+				label, ohci->hcd.self.bus_name, i);
 		while (*ed_p != 0 && j--) {
 			struct ed *ed = dma_to_ed (ohci, le32_to_cpup(ed_p));
 			printk (" %p/%08x;", ed, ed->hwINFO);
@@ -99,7 +99,7 @@ void ohci_dump_periodic (struct ohci_hcd *ohci, char *label)
 	}
 	if (!printed)
 		printk (KERN_DEBUG "%s, ohci %s, empty periodic schedule\n",
-				label, ohci->hcd.bus_name);
+				label, ohci->hcd.self.bus_name);
 }
 #endif
 
@@ -229,7 +229,7 @@ static void ohci_dump_roothub (struct ohci_hcd *controller, int verbose)
 
 static void ohci_dump (struct ohci_hcd *controller, int verbose)
 {
-	dbg ("OHCI controller %s state", controller->hcd.bus_name);
+	dbg ("OHCI controller %s state", controller->hcd.self.bus_name);
 
 	// dumps some of the state we know about
 	ohci_dump_status (controller);

drivers/usb/host/ohci-hcd.c

@@ -379,7 +379,7 @@ static int hc_reset (struct ohci_hcd *ohci)
 	writel (OHCI_INTR_MIE, &ohci->regs->intrdisable);
 
 	dbg ("USB HC reset_hc %s: ctrl = 0x%x ;",
-		ohci->hcd.bus_name,
+		ohci->hcd.self.bus_name,
 		readl (&ohci->regs->control));
 
   	/* Reset USB (needed by some controllers) */
@@ -449,7 +449,7 @@ static int hc_start (struct ohci_hcd *ohci)
 	mdelay ((roothub_a (ohci) >> 23) & 0x1fe);
  
 	/* connect the virtual root hub */
-	ohci->hcd.bus->root_hub = udev = usb_alloc_dev (NULL, ohci->hcd.bus);
+	ohci->hcd.self.root_hub = udev = usb_alloc_dev (NULL, &ohci->hcd.self);
 	ohci->hcd.state = USB_STATE_READY;
 	if (!udev) {
 	    ohci->disabled = 1;
@@ -491,7 +491,7 @@ static void ohci_irq (struct usb_hcd *hcd)
 
 	if (ints & OHCI_INTR_UE) {
 		ohci->disabled++;
-		err ("OHCI Unrecoverable Error, %s disabled", hcd->bus_name);
+		err ("OHCI Unrecoverable Error, %s disabled", hcd->self.bus_name);
 		// e.g. due to PCI Master/Target Abort
 
 #ifdef	DEBUG
@@ -530,7 +530,7 @@ static void ohci_stop (struct usb_hcd *hcd)
 	struct ohci_hcd		*ohci = hcd_to_ohci (hcd);
 
 	dbg ("%s: stop %s controller%s",
-		hcd->bus_name,
+		hcd->self.bus_name,
 		hcfs2string (ohci->hc_control & OHCI_CTRL_HCFS),
 		ohci->disabled ? " (disabled)" : ""
 		);
@@ -571,7 +571,7 @@ ohci_start (struct usb_hcd *hcd)
 				&& hcd->pdev->device == 0x740c) {
 			ohci->flags = OHCI_QUIRK_AMD756;
 			info ("%s: AMD756 erratum 4 workaround",
-				hcd->bus_name);
+				hcd->self.bus_name);
 		}
 
 		/* Apple's OHCI driver has a lot of bizarre workarounds
@@ -581,7 +581,7 @@ ohci_start (struct usb_hcd *hcd)
 		else if (hcd->pdev->vendor == 0x1045
 				&& hcd->pdev->device == 0xc861) {
 			info ("%s: WARNING: OPTi workarounds unavailable",
-				hcd->bus_name);
+				hcd->self.bus_name);
 		}
 	}
 #else
@@ -601,7 +601,7 @@ ohci_start (struct usb_hcd *hcd)
 	}
 
 	if (hc_start (ohci) < 0) {
-		err ("can't start %s", ohci->hcd.bus_name);
+		err ("can't start %s", ohci->hcd.self.bus_name);
 		ohci_stop (hcd);
 		return -EBUSY;
 	}
@@ -623,13 +623,13 @@ static int ohci_suspend (struct usb_hcd *hcd, u32 state)
 	u16			cmd;
 
 	if ((ohci->hc_control & OHCI_CTRL_HCFS) != OHCI_USB_OPER) {
-		dbg ("can't suspend %s (state is %s)", hcd->bus_name,
+		dbg ("can't suspend %s (state is %s)", hcd->self.bus_name,
 			hcfs2string (ohci->hc_control & OHCI_CTRL_HCFS));
 		return -EIO;
 	}
 
 	/* act as if usb suspend can always be used */
-	dbg ("%s: suspend to %d", hcd->bus_name, state);
+	dbg ("%s: suspend to %d", hcd->self.bus_name, state);
 	ohci->sleeping = 1;
 
 	/* First stop processing */
@@ -664,16 +664,16 @@ static int ohci_suspend (struct usb_hcd *hcd, u32 state)
 
 	switch (readl (&ohci->regs->control) & OHCI_CTRL_HCFS) {
 		case OHCI_USB_RESET:
-			dbg ("%s suspend->reset ?", hcd->bus_name);
+			dbg ("%s suspend->reset ?", hcd->self.bus_name);
 			break;
 		case OHCI_USB_RESUME:
-			dbg ("%s suspend->resume ?", hcd->bus_name);
+			dbg ("%s suspend->resume ?", hcd->self.bus_name);
 			break;
 		case OHCI_USB_OPER:
-			dbg ("%s suspend->operational ?", hcd->bus_name);
+			dbg ("%s suspend->operational ?", hcd->self.bus_name);
 			break;
 		case OHCI_USB_SUSPEND:
-			dbg ("%s suspended", hcd->bus_name);
+			dbg ("%s suspended", hcd->self.bus_name);
 			break;
 	}
 
@@ -711,8 +711,8 @@ static int hc_restart (struct ohci_hcd *ohci)
 
 	ohci->disabled = 1;
 	ohci->sleeping = 0;
-	if (ohci->hcd.bus->root_hub)
-		usb_disconnect (&ohci->hcd.bus->root_hub);
+	if (ohci->hcd.self.root_hub)
+		usb_disconnect (&ohci->hcd.self.root_hub);
 	
 	/* empty the interrupt branches */
 	for (i = 0; i < NUM_INTS; i++) ohci->ohci_int_load [i] = 0;
@@ -728,10 +728,10 @@ static int hc_restart (struct ohci_hcd *ohci)
 	ohci->ed_bulktail    = NULL;
 
 	if ((temp = hc_reset (ohci)) < 0 || (temp = hc_start (ohci)) < 0) {
-		err ("can't restart %s, %d", ohci->hcd.bus_name, temp);
+		err ("can't restart %s, %d", ohci->hcd.self.bus_name, temp);
 		return temp;
 	} else
-		dbg ("restart %s completed", ohci->hcd.bus_name);
+		dbg ("restart %s completed", ohci->hcd.self.bus_name);
 	return 0;
 }
 
@@ -767,13 +767,13 @@ static int ohci_resume (struct usb_hcd *hcd)
 	switch (temp) {
 
 	case OHCI_USB_RESET:	// lost power
-		info ("USB restart: %s", hcd->bus_name);
+		info ("USB restart: %s", hcd->self.bus_name);
 		retval = hc_restart (ohci);
 		break;
 
 	case OHCI_USB_SUSPEND:	// host wakeup
 	case OHCI_USB_RESUME:	// remote wakeup
-		info ("USB continue: %s from %s wakeup", hcd->bus_name,
+		info ("USB continue: %s from %s wakeup", hcd->self.bus_name,
 			 (temp == OHCI_USB_SUSPEND)
 				? "host" : "remote");
 		ohci->hc_control = OHCI_USB_RESUME;
@@ -786,7 +786,7 @@ static int ohci_resume (struct usb_hcd *hcd)
 		temp = readl (&ohci->regs->control);
 		temp = ohci->hc_control & OHCI_CTRL_HCFS;
 		if (temp != OHCI_USB_RESUME) {
-			err ("controller %s won't resume", hcd->bus_name);
+			err ("controller %s won't resume", hcd->self.bus_name);
 			ohci->disabled = 1;
 			retval = -EIO;
 			break;
@@ -836,7 +836,7 @@ dbg ("sleeping = %d, disabled = %d", ohci->sleeping, ohci->disabled);
 		break;
 
 	default:
-		warn ("odd PCI resume for %s", hcd->bus_name);
+		warn ("odd PCI resume for %s", hcd->self.bus_name);
 	}
 	return retval;
 }

drivers/usb/host/ohci-hub.c

@@ -41,7 +41,7 @@ static u32 roothub_portstatus (struct ohci_hcd *hc, int i)
 #define dbg_port(hc,label,num,value) \
 	dbg ("%s: %s roothub.portstatus [%d] " \
 		"= 0x%08x%s%s%s%s%s%s%s%s%s%s%s%s", \
-		hc->hcd.bus_name, label, num, temp, \
+		hc->hcd.self.bus_name, label, num, temp, \
 		(temp & RH_PS_PRSC) ? " PRSC" : "", \
 		(temp & RH_PS_OCIC) ? " OCIC" : "", \
 		(temp & RH_PS_PSSC) ? " PSSC" : "", \
@@ -71,7 +71,7 @@ ohci_hub_status_data (struct usb_hcd *hcd, char *buf)
 
 	ports = roothub_a (ohci) & RH_A_NDP; 
 	if (ports > MAX_ROOT_PORTS) {
-		err ("%s: bogus NDP=%d", hcd->bus_name, ports);
+		err ("%s: bogus NDP=%d", hcd->self.bus_name, ports);
 		err ("rereads as NDP=%d",
 			readl (&ohci->regs->roothub.a) & RH_A_NDP);
 		/* retry later; "should not happen" */

drivers/usb/host/uhci.c

@@ -2799,6 +2799,7 @@ static int alloc_uhci(struct pci_dev *dev, unsigned int io_addr, unsigned int io
 
 	uhci->bus = bus;
 	bus->hcpriv = uhci;
+	bus->bus_name = dev->slot_name;
 
 	usb_register_bus(uhci->bus);
 

drivers/usb/host/usb-ohci.c

@@ -2400,6 +2400,7 @@ static ohci_t * __devinit hc_alloc_ohci (struct pci_dev *dev, void * mem_base)
 		return NULL;
 	}
 	ohci->bus->hcpriv = (void *) ohci;
+	ohci->bus->bus_name = dev->slot_name;
 
 	return ohci;
 } 

drivers/usb/host/usb-uhci.c

@@ -2977,6 +2977,7 @@ _static int __devinit alloc_uhci (struct pci_dev *dev, int irq, unsigned int io_
 
 	s->bus = bus;
 	bus->hcpriv = s;
+	bus->bus_name = dev->slot_name;
 
 	/* UHCI specs says devices must have 2 ports, but goes on to say */
 	/* they may have more but give no way to determine how many they */

drivers/usb/image/Config.help

-CONFIG_USB_DC2XX
-  Say Y here if you want to connect this type of still camera to your
-  computer's USB port.  See <file:Documentation/usb/dc2xx.txt> for
-  more information; some non-Kodak cameras may also work with this
-  driver, given application support (such as <http://www.gphoto.org/>).
-
-  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 dc2xx.o. If you want to compile it as a
-  module, say M here and read <file:Documentation/modules.txt>.
-
 CONFIG_USB_MDC800
   Say Y here if you want to connect this type of still camera to
   your computer's USB port. This driver can be used with gphoto 0.4.3

drivers/usb/image/Config.in

@@ -2,7 +2,6 @@
 # USB Imageing devices configuration
 #
 comment 'USB Imaging devices'
-dep_tristate '  USB Kodak DC-2xx Camera support' CONFIG_USB_DC2XX $CONFIG_USB
 dep_tristate '  USB Mustek MDC800 Digital Camera support (EXPERIMENTAL)' CONFIG_USB_MDC800 $CONFIG_USB $CONFIG_EXPERIMENTAL
 dep_tristate '  USB Scanner support' CONFIG_USB_SCANNER $CONFIG_USB
 dep_tristate '  Microtek X6USB scanner support' CONFIG_USB_MICROTEK $CONFIG_USB $CONFIG_SCSI
@@ -10,10 +9,10 @@ dep_tristate '  HP53xx USB scanner support (EXPERIMENTAL)' CONFIG_USB_HPUSBSCSI
 
 # Turn on CONFIG_USB_IMAGE if any of the drivers are compiled into the kernel to
 # make our Makefile logic a bit simpler
-if [ "$CONFIG_USB_DC2XX" = "y" -o "$CONFIG_USB_MDC800" = "y" ]; then
+if [ "$CONFIG_USB_MDC800" = "y" -o "$CONFIG_USB_SCANNER" = "y" ]; then
    define_bool CONFIG_USB_IMAGE y
 fi
-if [ "$CONFIG_USB_SCANNER" = "y" -o "$CONFIG_USB_MICROTEK" = "y" -o "$CONFIG_USB_HPUSBSCSI" = "y" ]; then
+if [ "$CONFIG_USB_MICROTEK" = "y" -o "$CONFIG_USB_HPUSBSCSI" = "y" ]; then
    define_bool CONFIG_USB_IMAGE y
 fi
    

drivers/usb/image/Makefile

@@ -4,7 +4,6 @@
 
 O_TARGET	:= usb-image.o
 
-obj-$(CONFIG_USB_DC2XX)		+= dc2xx.o
 obj-$(CONFIG_USB_MDC800)	+= mdc800.o
 obj-$(CONFIG_USB_HPUSBSCSI)	+= hpusbscsi.o
 obj-$(CONFIG_USB_MICROTEK)	+= microtek.o

drivers/usb/image/dc2xx.c

-/*
- * Copyright (C) 1999-2000 by David Brownell <dbrownell@users.sourceforge.net>
- *
- * This program is free software; you can redistribute it and/or modify it
- * under the terms of the GNU General Public License as published by the
- * Free Software Foundation; either version 2 of the License, or (at your
- * option) any later version.
- *
- * This program is distributed in the hope that it will be useful, but
- * WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY
- * or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
- * for more details.
- *
- * You should have received a copy of the GNU General Public License
- * along with this program; if not, write to the Free Software Foundation,
- * Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
- */
- 
- 
-/*
- * USB driver for Kodak DC-2XX series digital still cameras
- *
- * The protocol here is the same as the one going over a serial line, but
- * it uses USB for speed.  Set up /dev/kodak, get gphoto (www.gphoto.org),
- * and have fun!
- *
- * This should also work for a number of other digital (non-Kodak) cameras,
- * by adding the vendor and product IDs to the table below.  They'll need
- * to be the sort using USB just as a fast bulk data channel.
- */
-
-/*
- * HISTORY
- *
- * 26 August, 1999 -- first release (0.1), works with my DC-240.
- * 	The DC-280 (2Mpixel) should also work, but isn't tested.
- *	If you use gphoto, make sure you have the USB updates.
- *	Lives in a 2.3.14 or so Linux kernel, in drivers/usb.
- * 31 August, 1999 -- minor update to recognize DC-260 and handle
- *	its endpoints being in a different order.  Note that as
- *	of gPhoto 0.36pre, the USB updates are integrated.
- * 12 Oct, 1999 -- handle DC-280 interface class (0xff not 0x0);
- *	added timeouts to bulk_msg calls.  Minor updates, docs.
- * 03 Nov, 1999 -- update for 2.3.25 kernel API changes.
- * 08 Jan, 2000 .. multiple camera support
- * 12 Aug, 2000 .. add some real locking, remove an Oops
- * 10 Oct, 2000 .. usb_device_id table created. 
- * 01 Nov, 2000 .. usb_device_id support added by Adam J. Richter
- * 08 Apr, 2001 .. Identify version on module load. gb
- *
- * Thanks to:  the folk who've provided USB product IDs, sent in
- * patches, and shared their successes!
- */
-
-#include <linux/config.h>
-#include <linux/kernel.h>
-#include <linux/sched.h>
-#include <linux/signal.h>
-#include <linux/errno.h>
-#include <linux/miscdevice.h>
-#include <linux/random.h>
-#include <linux/poll.h>
-#include <linux/init.h>
-#include <linux/slab.h>
-#include <linux/module.h>
-#include <linux/devfs_fs_kernel.h>
-
-#ifdef CONFIG_USB_DEBUG
-	#define DEBUG
-#else
-	#undef DEBUG
-#endif
-#include <linux/usb.h>
-
-
-/* /dev/usb dir. */
-extern devfs_handle_t usb_devfs_handle;			
-
-/*
- * Version Information
- */
-#define DRIVER_VERSION "v1.0.0"
-#define DRIVER_AUTHOR "David Brownell, <dbrownell@users.sourceforge.net>"
-#define DRIVER_DESC "USB Camera Driver for Kodak DC-2xx series cameras"
-
-
-/* current USB framework handles max of 16 USB devices per driver */
-#define	MAX_CAMERAS		16
-
-/* USB char devs use USB_MAJOR and from USB_CAMERA_MINOR_BASE up */
-#define	USB_CAMERA_MINOR_BASE	80
-
-
-// XXX remove packet size limit, now that bulk transfers seem fixed
-
-/* Application protocol limit is 0x8002; USB has disliked that limit! */
-#define	MAX_PACKET_SIZE		0x2000		/* e.g. image downloading */
-
-#define	MAX_READ_RETRY		5		/* times to retry reads */
-#define	MAX_WRITE_RETRY		5		/* times to retry writes */
-#define	RETRY_TIMEOUT		(HZ)		/* sleep between retries */
-
-
-/* table of cameras that work through this driver */
-static struct usb_device_id camera_table [] = {
-	/* These have the same application level protocol */  
-	{ USB_DEVICE(0x040a, 0x0120) },		// Kodak DC-240
-	{ USB_DEVICE(0x040a, 0x0130) },		// Kodak DC-280
-	{ USB_DEVICE(0x040a, 0x0131) },		// Kodak DC-5000
-	{ USB_DEVICE(0x040a, 0x0132) },		// Kodak DC-3400
-
-	/* These have a different application level protocol which
-	 * is part of the Flashpoint "DigitaOS".  That supports some
-	 * non-camera devices, and some non-Kodak cameras.
-	 * Use this driver to get USB and "OpenDis" to talk.
-	 */  
-	{ USB_DEVICE(0x040a, 0x0100) },		// Kodak DC-220
-	{ USB_DEVICE(0x040a, 0x0110) },		// Kodak DC-260
-	{ USB_DEVICE(0x040a, 0x0111) },		// Kodak DC-265
-	{ USB_DEVICE(0x040a, 0x0112) },		// Kodak DC-290
-	{ USB_DEVICE(0xf003, 0x6002) },		// HP PhotoSmart C500
-	{ USB_DEVICE(0x03f0, 0x4102) },		// HP PhotoSmart C618
-	{ USB_DEVICE(0x0a17, 0x1001) },		// Pentax EI-200
-
-	/* Other USB devices may well work here too, so long as they
-	 * just stick to half duplex bulk packet exchanges.  That
-	 * means, among other things, no iso or interrupt endpoints.
-	 */
-
-	{ }					/* Terminating entry */
-};
-
-MODULE_DEVICE_TABLE (usb, camera_table);
-
-
-struct camera_state {
-	struct usb_device	*dev;		/* USB device handle */
-	int			inEP;		/* read endpoint */
-	int			outEP;		/* write endpoint */
-	const struct usb_device_id	*info;	/* DC-240, etc */
-	int			subminor;	/* which minor dev #? */
-	struct semaphore	sem;		/* locks this struct */
-
-	/* this is non-null iff the device is open */
-	char			*buf;		/* buffer for I/O */
-
-	devfs_handle_t		devfs;		/* devfs device */
-
-	/* always valid */
-	wait_queue_head_t	wait;		/* for timed waits */
-};
-
-/* Support multiple cameras, possibly of different types.  */
-static struct camera_state *minor_data [MAX_CAMERAS];
-
-/* make this an rwlock if contention becomes an issue */
-static DECLARE_MUTEX (state_table_mutex);
-
-static ssize_t camera_read (struct file *file,
-	char *buf, size_t len, loff_t *ppos)
-{
-	struct camera_state	*camera;
-	int			retries;
-	int			retval = 0;
-
-	if (len > MAX_PACKET_SIZE)
-		return -EINVAL;
-
-	camera = (struct camera_state *) file->private_data;
-	down (&camera->sem);
-	if (!camera->dev) {
-		up (&camera->sem);
-		return -ENODEV;
-	}
-
-	/* Big reads are common, for image downloading.  Smaller ones
-	 * are also common (even "directory listing" commands don't
-	 * send very much data).  We preserve packet boundaries here,
-	 * they matter in the application protocol.
-	 */
-	for (retries = 0; retries < MAX_READ_RETRY; retries++) {
-		int			count;
-
-		if (signal_pending (current)) {
-			retval = -EINTR;
-			break;
-		}
-
-		retval = usb_bulk_msg (camera->dev,
-			  usb_rcvbulkpipe (camera->dev, camera->inEP),
-			  camera->buf, len, &count, HZ*10);
-
-		dbg ("read (%Zd) - 0x%x %d", len, retval, count);
-
-		if (!retval) {
-			if (copy_to_user (buf, camera->buf, count))
-				retval = -EFAULT;
-			else
-				retval = count;
-			break;
-		}
-		if (retval != -ETIMEDOUT)
-			break;
-		interruptible_sleep_on_timeout (&camera->wait, RETRY_TIMEOUT);
-
-		dbg ("read (%Zd) - retry", len);
-	}
-	up (&camera->sem);
-	return retval;
-}
-
-static ssize_t camera_write (struct file *file,
-	const char *buf, size_t len, loff_t *ppos)
-{
-	struct camera_state	*camera;
-	ssize_t			bytes_written = 0;
-
-	if (len > MAX_PACKET_SIZE)
-		return -EINVAL;
-
-	camera = (struct camera_state *) file->private_data;
-	down (&camera->sem);
-	if (!camera->dev) {
-		up (&camera->sem);
-		return -ENODEV;
-	}
-	
-	/* most writes will be small: simple commands, sometimes with
-	 * parameters.  putting images (like borders) into the camera
-	 * would be the main use of big writes.
-	 */
-	while (len > 0) {
-		char		*obuf = camera->buf;
-		int		maxretry = MAX_WRITE_RETRY;
-		unsigned long	copy_size, thistime;
-
-		/* it's not clear that retrying can do any good ... or that
-		 * fragmenting application packets into N writes is correct.
-		 */
-		thistime = copy_size = len;
-		if (copy_from_user (obuf, buf, copy_size)) {
-			bytes_written = -EFAULT;
-			break;
-		}
-		while (thistime) {
-			int		result;
-			int		count;
-
-			if (signal_pending (current)) {
-				if (!bytes_written)
-					bytes_written = -EINTR;
-				goto done;
-			}
-
-			result = usb_bulk_msg (camera->dev,
-				 usb_sndbulkpipe (camera->dev, camera->outEP),
-				 obuf, thistime, &count, HZ*10);
-
-			if (result)
-				dbg ("write USB err - %d", result);
-
-			if (count) {
-				obuf += count;
-				thistime -= count;
-				maxretry = MAX_WRITE_RETRY;
-				continue;
-			} else if (!result)
-				break;
-				
-			if (result == -ETIMEDOUT) {	/* NAK - delay a bit */
-				if (!maxretry--) {
-					if (!bytes_written)
-						bytes_written = -ETIME;
-					goto done;
-				}
-                                interruptible_sleep_on_timeout (&camera->wait,
-					RETRY_TIMEOUT);
-				continue;
-			} 
-			if (!bytes_written)
-				bytes_written = -EIO;
-			goto done;
-		}
-		bytes_written += copy_size;
-		len -= copy_size;
-		buf += copy_size;
-	}
-done:
-	up (&camera->sem);
-	dbg ("wrote %Zd", bytes_written); 
-	return bytes_written;
-}
-
-static int camera_open (struct inode *inode, struct file *file)
-{
-	struct camera_state	*camera = NULL;
-	int			subminor;
-	int			value = 0;
-
-	down (&state_table_mutex);
-	subminor = minor (inode->i_rdev) - USB_CAMERA_MINOR_BASE;
-	if (subminor < 0 || subminor >= MAX_CAMERAS
-			|| !(camera = minor_data [subminor])) {
-		up (&state_table_mutex);
-		return -ENODEV;
-	}
-	down (&camera->sem);
-	up (&state_table_mutex);
-
-	if (camera->buf) {
-		value = -EBUSY;
-		goto done;
-	}
-
-	if (!(camera->buf = (char *) kmalloc (MAX_PACKET_SIZE, GFP_KERNEL))) {
-		value = -ENOMEM;
-		goto done;
-	}
-
-	dbg ("open #%d", subminor); 
-
-	file->private_data = camera;
-done:
-	up (&camera->sem);
-	return value;
-}
-
-static int camera_release (struct inode *inode, struct file *file)
-{
-	struct camera_state	*camera;
-	int			subminor;
-
-	camera = (struct camera_state *) file->private_data;
-	down (&state_table_mutex);
-	down (&camera->sem);
-
-	if (camera->buf) {
-		kfree (camera->buf);
-		camera->buf = 0;
-	}
-	subminor = camera->subminor;
-
-	/* If camera was unplugged with open file ... */
-	if (!camera->dev) {
-		minor_data [subminor] = NULL;
-		kfree (camera);
-	} else
-		up (&camera->sem);
-	
-	up (&state_table_mutex);
-
-	dbg ("close #%d", subminor); 
-
-	return 0;
-}
-
-	/* XXX should define some ioctls to expose camera type
-	 * to applications ... what USB exposes should suffice.
-	 * apps should be able to see the camera type.
-	 */
-static /* const */ struct file_operations usb_camera_fops = {
-	    /* Uses GCC initializer extension; simpler to maintain */
-	owner:		THIS_MODULE,
-	read:		camera_read,
-	write:		camera_write,
-	open:		camera_open,
-	release:	camera_release,
-};
-
-
-
-static void *
-camera_probe (struct usb_device *dev, unsigned int ifnum, const struct usb_device_id *camera_info)
-{
-	int				i;
-	struct usb_interface_descriptor	*interface;
-	struct usb_endpoint_descriptor	*endpoint;
-	int				direction, ep;
-	char name[8];
-	struct camera_state		*camera = NULL;
-
-
-	/* these have one config, one interface */
-	if (dev->descriptor.bNumConfigurations != 1
-			|| dev->config[0].bNumInterfaces != 1) {
-		dbg ("Bogus camera config info");
-		return NULL;
-	}
-
-	/* models differ in how they report themselves */
-	interface = &dev->actconfig->interface[ifnum].altsetting[0];
-	if ((interface->bInterfaceClass != USB_CLASS_PER_INTERFACE
-		&& interface->bInterfaceClass != USB_CLASS_VENDOR_SPEC)
-			|| interface->bInterfaceSubClass != 0
-			|| interface->bInterfaceProtocol != 0
-			|| interface->bNumEndpoints != 2
-			) {
-		dbg ("Bogus camera interface info");
-		return NULL;
-	}
-
-
-	/* select "subminor" number (part of a minor number) */
-	down (&state_table_mutex);
-	for (i = 0; i < MAX_CAMERAS; i++) {
-		if (!minor_data [i])
-			break;
-	}
-	if (i >= MAX_CAMERAS) {
-		info ("Ignoring additional USB Camera");
-		goto bye;
-	}
-
-	/* allocate & init camera state */
-	camera = minor_data [i] = kmalloc (sizeof *camera, GFP_KERNEL);
-	if (!camera) {
-		err ("no memory!");
-		goto bye;
-	}
-
-	init_MUTEX (&camera->sem);
-	camera->info = camera_info;
-	camera->subminor = i;
-	camera->buf = NULL;
-	init_waitqueue_head (&camera->wait);
-
-
-	/* get input and output endpoints (either order) */
-	endpoint = interface->endpoint;
-	camera->outEP = camera->inEP =  -1;
-
-	ep = endpoint [0].bEndpointAddress & USB_ENDPOINT_NUMBER_MASK;
-	direction = endpoint [0].bEndpointAddress & USB_ENDPOINT_DIR_MASK;
-	if (direction == USB_DIR_IN)
-		camera->inEP = ep;
-	else
-		camera->outEP = ep;
-
-	ep = endpoint [1].bEndpointAddress & USB_ENDPOINT_NUMBER_MASK;
-	direction = endpoint [1].bEndpointAddress & USB_ENDPOINT_DIR_MASK;
-	if (direction == USB_DIR_IN)
-		camera->inEP = ep;
-	else
-		camera->outEP = ep;
-
-	if (camera->outEP == -1 || camera->inEP == -1
-			|| endpoint [0].bmAttributes != USB_ENDPOINT_XFER_BULK
-			|| endpoint [1].bmAttributes != USB_ENDPOINT_XFER_BULK
-			) {
-		dbg ("Bogus endpoints");
-		goto error;
-	}
-
-	info ("USB Camera #%d connected, major/minor %d/%d", camera->subminor,
-		USB_MAJOR, USB_CAMERA_MINOR_BASE + camera->subminor);
-
-	camera->dev = dev;
-	usb_inc_dev_use (dev);
-
-	/* If we have devfs, register the device */
-	sprintf(name, "dc2xx%d", camera->subminor);
-	camera->devfs = devfs_register(usb_devfs_handle, name,
-				       DEVFS_FL_DEFAULT, USB_MAJOR,
-				       USB_CAMERA_MINOR_BASE + camera->subminor,
-				       S_IFCHR | S_IRUSR | S_IWUSR | S_IRGRP |
-				       S_IWGRP, &usb_camera_fops, NULL);
-
-	goto bye;
-
-error:
-	minor_data [camera->subminor] = NULL;
-	kfree (camera);
-	camera = NULL;
-bye:
-	up (&state_table_mutex);
-	return camera;
-}
-
-static void camera_disconnect(struct usb_device *dev, void *ptr)
-{
-	struct camera_state	*camera = (struct camera_state *) ptr;
-	int			subminor = camera->subminor;
-
-	down (&state_table_mutex);
-	down (&camera->sem);
-
-	devfs_unregister(camera->devfs); 
-
-	/* If camera's not opened, we can clean up right away.
-	 * Else apps see a disconnect on next I/O; the release cleans.
-	 */
-	if (!camera->buf) {
-		minor_data [subminor] = NULL;
-		kfree (camera);
-		camera = NULL;
-	} else
-		camera->dev = NULL;
-
-	info ("USB Camera #%d disconnected", subminor);
-	usb_dec_dev_use (dev);
-
-	if (camera != NULL)
-		up (&camera->sem);
-	up (&state_table_mutex);
-}
-
-static /* const */ struct usb_driver camera_driver = {
-	name:		"dc2xx",
-
-	id_table:	camera_table,
-	probe:		camera_probe,
-	disconnect:	camera_disconnect,
-
-	fops:		&usb_camera_fops,
-	minor:		USB_CAMERA_MINOR_BASE
-};
-
-
-int __init usb_dc2xx_init(void)
-{
- 	if (usb_register (&camera_driver) < 0)
- 		return -1;
-	info(DRIVER_VERSION ":" DRIVER_DESC);
-	return 0;
-}
-
-void __exit usb_dc2xx_cleanup(void)
-{
-	usb_deregister (&camera_driver);
-}
-
-module_init (usb_dc2xx_init);
-module_exit (usb_dc2xx_cleanup);
-
-MODULE_AUTHOR( DRIVER_AUTHOR );
-MODULE_DESCRIPTION( DRIVER_DESC );
-MODULE_LICENSE("GPL");
-

drivers/usb/net/catc.c

@@ -655,7 +655,6 @@ static int netdev_ethtool_ioctl(struct net_device *dev, void *useraddr)
 {
         struct catc *catc = dev->priv;
         u32 cmd;
-	char tmp[40];
         
         if (get_user(cmd, (u32 *)useraddr))
                 return -EFAULT;
@@ -666,8 +665,7 @@ static int netdev_ethtool_ioctl(struct net_device *dev, void *useraddr)
                 struct ethtool_drvinfo info = {ETHTOOL_GDRVINFO};
                 strncpy(info.driver, SHORT_DRIVER_DESC, ETHTOOL_BUSINFO_LEN);
                 strncpy(info.version, DRIVER_VERSION, ETHTOOL_BUSINFO_LEN);
-		sprintf(tmp, "usb%d:%d", catc->usbdev->bus->busnum, catc->usbdev->devnum);
-                strncpy(info.bus_info, tmp,ETHTOOL_BUSINFO_LEN);
+		usb_make_path (catc->usbdev, info.bus_info, sizeof info.bus_info);
                 if (copy_to_user(useraddr, &info, sizeof(info)))
                         return -EFAULT;
                 return 0;
@@ -909,9 +907,9 @@ static void *catc_probe(struct usb_device *usbdev, unsigned int ifnum, const str
 		f5u011_rxmode(catc, catc->rxmode);
 	}
 	dbg("Init done.");
-	printk(KERN_INFO "%s: %s USB Ethernet at usb%d:%d.%d, ",
+	printk(KERN_INFO "%s: %s USB Ethernet at usb-%s-%s/%d, ",
 	       netdev->name, (catc->is_f5u011) ? "Belkin F5U011" : "CATC EL1210A NetMate",
-	       usbdev->bus->busnum, usbdev->devnum, ifnum);
+	       usbdev->bus->bus_name, usbdev->devpath, ifnum);
 	for (i = 0; i < 5; i++) printk("%2.2x:", netdev->dev_addr[i]);
 	printk("%2.2x.\n", netdev->dev_addr[i]);
 	return catc;

drivers/usb/net/pegasus.c

@@ -798,7 +798,6 @@ static int pegasus_ethtool_ioctl(struct net_device *net, void *uaddr)
 {
 	pegasus_t	*pegasus;
 	int		cmd;
-	char		tmp[128];
 
 	pegasus = net->priv;
 	if (get_user(cmd, (int *)uaddr))
@@ -808,9 +807,7 @@ static int pegasus_ethtool_ioctl(struct net_device *net, void *uaddr)
 		struct ethtool_drvinfo info = {ETHTOOL_GDRVINFO};
 		strncpy(info.driver, DRIVER_DESC, ETHTOOL_BUSINFO_LEN);
 		strncpy(info.version, DRIVER_VERSION, ETHTOOL_BUSINFO_LEN);
-		sprintf(tmp, "usb%d:%d", pegasus->usb->bus->busnum,
-		        pegasus->usb->devnum);
-		strncpy(info.bus_info, tmp, ETHTOOL_BUSINFO_LEN);
+		usb_make_path (pegasus->usb, info.bus_info, sizeof info.bus_info);
 		if (copy_to_user(uaddr, &info, sizeof(info)))
 			return -EFAULT;
 		return 0;

drivers/usb/net/rtl8150.c

@@ -21,14 +21,11 @@
 #include <linux/usb.h>
 #include <asm/uaccess.h>
 
-
-
 /* Version Information */
-#define DRIVER_VERSION "v0.5.0 (2002/03/28)"
+#define DRIVER_VERSION "v0.5.3 (2002/04/08)"
 #define DRIVER_AUTHOR "Petko Manolov <petkan@users.sourceforge.net>"
 #define DRIVER_DESC "rtl8150 based usb-ethernet driver"
 
-
 #define	IRD			0x0120
 #define	MAR			0x0126
 #define	CR			0x012e
@@ -53,64 +50,64 @@
 #define	PHY_WRITE		0x20
 #define	PHY_GO			0x40
 
+#define	MII_TIMEOUT		10
+
 #define	RTL8150_REQT_READ	0xc0
 #define	RTL8150_REQT_WRITE	0x40
 #define	RTL8150_REQ_GET_REGS	0x05
 #define	RTL8150_REQ_SET_REGS	0x05
 
-#define	RTL8150_MTU		1500
-#define	RTL8150_MAX_MTU		1536
-
+#define	RTL8150_MTU		1540
 #define	RTL8150_TX_TIMEOUT	(HZ)
+#define	RX_SKB_POOL_SIZE	4
 
 /* rtl8150 flags */
-#define	RTL8150_FLAG_HWCRC	0
+#define	RTL8150_HW_CRC		0
 #define	RX_REG_SET		1
 #define	RTL8150_UNPLUG		2
 
-
 /* Define these values to match your device */
 #define VENDOR_ID_REALTEK		0x0bda
 #define PRODUCT_ID_RTL8150		0x8150
 
 /* table of devices that work with this driver */
-static struct usb_device_id rtl8150_table [] = {
-	{ USB_DEVICE(VENDOR_ID_REALTEK, PRODUCT_ID_RTL8150) },
-	{ }				
+static struct usb_device_id rtl8150_table[] = {
+	{USB_DEVICE(VENDOR_ID_REALTEK, PRODUCT_ID_RTL8150)},
+	{}
 };
 
-MODULE_DEVICE_TABLE (usb, rtl8150_table);
-
+MODULE_DEVICE_TABLE(usb, rtl8150_table);
 
 struct rtl8150 {
-	unsigned int		flags;
-	struct usb_device	*udev;
-	struct usb_interface	*interface;
-	struct semaphore	sem;
-	struct net_device_stats	stats;
-	struct net_device	*netdev;
-	struct urb		*rx_urb, *tx_urb, *intr_urb, *ctrl_urb;
-	struct usb_ctrlrequest	dr;
-	int			intr_interval;
-	u16			rx_creg;
-	u8			rx_buff[RTL8150_MAX_MTU];
-	u8			tx_buff[RTL8150_MAX_MTU];
-	u8			intr_buff[8];
-	u8			phy;
+	unsigned long flags;
+	struct usb_device *udev;
+	struct semaphore sem;
+	struct tasklet_struct tl;
+	struct net_device_stats stats;
+	struct net_device *netdev;
+	struct urb *rx_urb, *tx_urb, *intr_urb, *ctrl_urb;
+	struct sk_buff *tx_skb, *rx_skb;
+	struct sk_buff *rx_skb_pool[RX_SKB_POOL_SIZE];
+	spinlock_t rx_pool_lock;
+	struct usb_ctrlrequest dr;
+	int intr_interval;
+	u16 rx_creg;
+	u8 intr_buff[8];
+	u8 phy;
 };
 
-typedef	struct rtl8150	rtl8150_t;
-
+typedef struct rtl8150 rtl8150_t;
 
 /* the global usb devfs handle */
 extern devfs_handle_t usb_devfs_handle;
 unsigned long multicast_filter_limit = 32;
 
-
+static void fill_skb_pool(rtl8150_t *);
+static void free_skb_pool(rtl8150_t *);
+static struct sk_buff *pull_skb(rtl8150_t *);
 static void rtl8150_disconnect(struct usb_device *dev, void *ptr);
-static void * rtl8150_probe(struct usb_device *dev, unsigned int ifnum,
-			    const struct usb_device_id *id);
-
+static void *rtl8150_probe(struct usb_device *dev, unsigned int ifnum,
+			   const struct usb_device_id *id);
 
 static struct usb_driver rtl8150_driver = {
 	name:		"rtl8150",
@@ -119,33 +116,29 @@ static struct usb_driver rtl8150_driver = {
 	id_table:	rtl8150_table,
 };
 
-
-
 /*
 **
 **	device related part of the code
 **
 */
-static int get_registers(rtl8150_t *dev, u16 indx, u16 size, void *data)
+static int get_registers(rtl8150_t * dev, u16 indx, u16 size, void *data)
 {
-	return usb_control_msg(dev->udev, usb_rcvctrlpipe(dev->udev,0),
-				RTL8150_REQ_GET_REGS, RTL8150_REQT_READ,
-				indx, 0, data, size, HZ/2);
+	return usb_control_msg(dev->udev, usb_rcvctrlpipe(dev->udev, 0),
+			       RTL8150_REQ_GET_REGS, RTL8150_REQT_READ,
+			       indx, 0, data, size, HZ / 2);
 }
 
-
-static int set_registers(rtl8150_t *dev, u16 indx, u16 size, void *data)
+static int set_registers(rtl8150_t * dev, u16 indx, u16 size, void *data)
 {
-	return usb_control_msg(dev->udev, usb_sndctrlpipe(dev->udev,0),
-				RTL8150_REQ_SET_REGS, RTL8150_REQT_WRITE,
-				indx, 0, data, size, HZ/2);
+	return usb_control_msg(dev->udev, usb_sndctrlpipe(dev->udev, 0),
+			       RTL8150_REQ_SET_REGS, RTL8150_REQT_WRITE,
+			       indx, 0, data, size, HZ / 2);
 }
 
-
 static void ctrl_callback(struct urb *urb)
 {
-	rtl8150_t	*dev;
-	
+	rtl8150_t *dev;
+
 	switch (urb->status) {
 	case 0:
 		break;
@@ -160,23 +153,22 @@ static void ctrl_callback(struct urb *urb)
 	clear_bit(RX_REG_SET, &dev->flags);
 }
 
-
-static int async_set_registers(rtl8150_t *dev, u16 indx, u16 size, void *data)
+static int async_set_registers(rtl8150_t * dev, u16 indx, u16 size, void *data)
 {
-	int	ret;
+	int ret;
 
 	if (test_bit(RX_REG_SET, &dev->flags))
 		return -EAGAIN;
-	
+
 	dev->dr.bRequestType = RTL8150_REQT_WRITE;
 	dev->dr.bRequest = RTL8150_REQ_SET_REGS;
 	dev->dr.wValue = cpu_to_le16(indx);
 	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_sndctrlpipe(dev->udev,0),
-	                 (char*)&dev->dr, &dev->rx_creg, size,
-	                 ctrl_callback, dev);
+	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)))
 		err("control request submission failed: %d", ret);
 	else
@@ -185,11 +177,10 @@ static int async_set_registers(rtl8150_t *dev, u16 indx, u16 size, void *data)
 	return ret;
 }
 
-
-static int read_mii_word(rtl8150_t *dev, u8 phy, __u8 indx, u16 *reg)
+static int read_mii_word(rtl8150_t * dev, u8 phy, __u8 indx, u16 * reg)
 {
-	int	i;
-	u8	data[3], tmp;
+	int i;
+	u8 data[3], tmp;
 
 	data[0] = phy;
 	data[1] = data[2] = 0;
@@ -200,9 +191,9 @@ static int read_mii_word(rtl8150_t *dev, u8 phy, __u8 indx, u16 *reg)
 	set_registers(dev, PHYCNT, 1, &tmp);
 	do {
 		get_registers(dev, PHYCNT, 1, data);
-	} while ((data[0] & PHY_GO) && (i++ < HZ));
+	} while ((data[0] & PHY_GO) && (i++ < MII_TIMEOUT));
 
-	if (i < HZ) {
+	if (i < MII_TIMEOUT) {
 		get_registers(dev, PHYDAT, 2, data);
 		*reg = le16_to_cpup(data);
 		return 0;
@@ -210,11 +201,10 @@ static int read_mii_word(rtl8150_t *dev, u8 phy, __u8 indx, u16 *reg)
 		return 1;
 }
 
-
-static int write_mii_word(rtl8150_t *dev, u8 phy, __u8 indx, u16 reg)
+static int write_mii_word(rtl8150_t * dev, u8 phy, __u8 indx, u16 reg)
 {
-	int	i;
-	u8	data[3], tmp;
+	int i;
+	u8 data[3], tmp;
 
 	data[0] = phy;
 	*(data + 1) = cpu_to_le16p(&reg);
@@ -225,39 +215,36 @@ static int write_mii_word(rtl8150_t *dev, u8 phy, __u8 indx, u16 reg)
 	set_registers(dev, PHYCNT, 1, &tmp);
 	do {
 		get_registers(dev, PHYCNT, 1, data);
-	} while((data[0] & PHY_GO) && (i++ < HZ));
+	} while ((data[0] & PHY_GO) && (i++ < MII_TIMEOUT));
 
-	if (i < HZ)
+	if (i < MII_TIMEOUT)
 		return 0;
 	else
 		return 1;
 }
 
-
-static inline void set_ethernet_addr(rtl8150_t *dev)
+static inline void set_ethernet_addr(rtl8150_t * dev)
 {
-	u8	node_id[6];
+	u8 node_id[6];
 
 	get_registers(dev, IRD, sizeof(node_id), node_id);
 	memcpy(dev->netdev->dev_addr, node_id, sizeof(node_id));
 }
 
-
-static int rtl8150_reset(rtl8150_t *dev)
+static int rtl8150_reset(rtl8150_t * dev)
 {
-	u8	data=0x10;
-	int	i=HZ;
+	u8 data = 0x10;
+	int i = HZ;
 
 	set_registers(dev, CR, 1, &data);
 	do {
 		get_registers(dev, CR, 1, &data);
 	} while ((data & 0x10) && --i);
-	
-	return (i > 0) ? 0 : -1;
-}
 
+	return (i > 0) ? 1 : 0;
+}
 
-static int alloc_all_urbs(rtl8150_t *dev)
+static int alloc_all_urbs(rtl8150_t * dev)
 {
 	dev->rx_urb = usb_alloc_urb(0, GFP_KERNEL);
 	if (!dev->rx_urb)
@@ -284,8 +271,7 @@ static int alloc_all_urbs(rtl8150_t *dev)
 	return 1;
 }
 
-
-static void free_all_urbs(rtl8150_t *dev)
+static void free_all_urbs(rtl8150_t * dev)
 {
 	usb_free_urb(dev->rx_urb);
 	usb_free_urb(dev->tx_urb);
@@ -293,8 +279,7 @@ static void free_all_urbs(rtl8150_t *dev)
 	usb_free_urb(dev->ctrl_urb);
 }
 
-
-static void unlink_all_urbs(rtl8150_t *dev)
+static void unlink_all_urbs(rtl8150_t * dev)
 {
 	usb_unlink_urb(dev->rx_urb);
 	usb_unlink_urb(dev->tx_urb);
@@ -302,14 +287,13 @@ static void unlink_all_urbs(rtl8150_t *dev)
 	usb_unlink_urb(dev->ctrl_urb);
 }
 
-
 static void read_bulk_callback(struct urb *urb)
 {
-	rtl8150_t	*dev;
-	unsigned	pkt_len, res;
-	struct sk_buff	*skb;
+	rtl8150_t *dev;
+	unsigned pkt_len, res;
+	struct sk_buff *skb;
 	struct net_device *netdev;
-	u16		rx_stat;
+	u16 rx_stat;
 
 	dev = urb->context;
 	if (!dev) {
@@ -318,7 +302,7 @@ static void read_bulk_callback(struct urb *urb)
 	}
 	netdev = dev->netdev;
 	if (!netif_device_present(netdev)) {
-		warn("netdev is not present");
+		warn("the network device is not present");
 		return;
 	}
 	switch (urb->status) {
@@ -334,35 +318,67 @@ static void read_bulk_callback(struct urb *urb)
 		goto goon;
 	}
 
+	if (!dev->rx_skb) {
+		/* lost packets++ */
+		return;
+	}
+
 	res = urb->actual_length;
-	rx_stat = le16_to_cpu(*(short*)(dev->rx_buff + res - 4));
+	rx_stat = le16_to_cpu(*(short *)(urb->transfer_buffer + res - 4));
 	pkt_len = res - 4;
 
-	if (!(skb = dev_alloc_skb(pkt_len + 2))) 
-		goto goon;
-	skb->dev = netdev;
-	skb_reserve(skb, 2);
-	eth_copy_and_sum(skb, dev->rx_buff, pkt_len, 0);
-	skb_put(skb, pkt_len);
-	skb->protocol = eth_type_trans(skb, netdev);
-	netif_rx(skb);
+	skb_put(dev->rx_skb, pkt_len);
+	dev->rx_skb->protocol = eth_type_trans(dev->rx_skb, netdev);
+	netif_rx(dev->rx_skb);
 	dev->stats.rx_packets++;
 	dev->stats.rx_bytes += pkt_len;
+	
+	tasklet_schedule(&dev->tl);
+
+	skb = pull_skb(dev);
+	if (!skb) {
+		dev->rx_skb = NULL;
+		return;
+	}
+
+	skb->dev = netdev;
+	skb_reserve(skb, 2);
+	dev->rx_skb = skb;
 goon:
-	FILL_BULK_URB(dev->rx_urb, dev->udev, usb_rcvbulkpipe(dev->udev,1),
-	              dev->rx_buff, RTL8150_MAX_MTU, read_bulk_callback, dev);
-	if ((res=usb_submit_urb(dev->rx_urb, GFP_ATOMIC)))
+	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_ATOMIC)))
 		warn("%s: Rx urb submission failed %d", netdev->name, res);
 }
 
+static void rx_fixup(unsigned long data)
+{
+	rtl8150_t *dev;
+	struct sk_buff *skb;
+
+	dev = (rtl8150_t *)data;
+	fill_skb_pool(dev);
+	skb = pull_skb(dev);
+	if (!skb) {
+		tasklet_schedule(&dev->tl);
+		return;
+	}
+	if (dev->rx_skb)
+		return;
+	dev->rx_skb = skb;
+	FILL_BULK_URB(dev->rx_urb, dev->udev, usb_rcvbulkpipe(dev->udev, 1),
+		      dev->rx_skb->data, RTL8150_MTU, read_bulk_callback, dev);
+	usb_submit_urb(dev->rx_urb, GFP_ATOMIC);
+}
 
 static void write_bulk_callback(struct urb *urb)
 {
-	rtl8150_t	*dev;
+	rtl8150_t *dev;
 
 	dev = urb->context;
 	if (!dev)
 		return;
+	dev_kfree_skb_irq(dev->tx_skb);
 	if (!netif_device_present(dev->netdev))
 		return;
 	if (urb->status)
@@ -371,43 +387,94 @@ static void write_bulk_callback(struct urb *urb)
 	netif_wake_queue(dev->netdev);
 }
 
-
 void intr_callback(struct urb *urb)
 {
-	rtl8150_t	*dev;
+	rtl8150_t *dev;
 
 	dev = urb->context;
 	if (!dev)
 		return;
 	switch (urb->status) {
-		case 0:
-			break;
-		case -ENOENT:
-			return;
-		default:
-			info("%s: intr status %d", dev->netdev->name,
-			     urb->status);
+	case 0:
+		break;
+	case -ENOENT:
+		return;
+	default:
+		info("%s: intr status %d", dev->netdev->name, urb->status);
 	}
 }
 
-
 /*
 **
 **	network related part of the code
 **
 */
 
+static void fill_skb_pool(rtl8150_t *dev)
+{
+	struct sk_buff *skb;
+	int i;
+	unsigned long flags;
+
+	spin_lock_irqsave(&dev->rx_pool_lock, flags);
+	for (i = 0; i < RX_SKB_POOL_SIZE; i++) {
+		if (dev->rx_skb_pool[i])
+			continue;
+		skb = dev_alloc_skb(RTL8150_MTU + 2);
+		if (!skb) {
+			spin_unlock_irqrestore(&dev->rx_pool_lock, flags);
+			return;
+		}
+		skb->dev = dev->netdev;
+		skb_reserve(skb, 2);
+		dev->rx_skb_pool[i] = skb;
+	}
+	spin_unlock_irqrestore(&dev->rx_pool_lock, flags);
+}
+
+static void free_skb_pool(rtl8150_t *dev)
+{
+	int i;
+
+	spin_lock_irq(&dev->rx_pool_lock);
+	for (i = 0; i < RX_SKB_POOL_SIZE; i++)
+		if (dev->rx_skb_pool[i])
+			dev_kfree_skb(dev->rx_skb_pool[i]);
+	spin_unlock_irq(&dev->rx_pool_lock);
+}
+
+static struct sk_buff *pull_skb(rtl8150_t *dev)
+{
+	struct sk_buff *skb;
+	int i;
+	unsigned long flags;
+
+	spin_lock_irqsave(&dev->rx_pool_lock, flags);
+	for (i = 0; i < RX_SKB_POOL_SIZE; i++) {
+		if (dev->rx_skb_pool[i]) {
+			skb = dev->rx_skb_pool[i];
+			dev->rx_skb_pool[i] = NULL;
+			spin_unlock_irqrestore(&dev->rx_pool_lock, flags);
+			return skb;
+		}
+	}
+	spin_unlock_irqrestore(&dev->rx_pool_lock, flags);
+	return NULL;
+}
 
-static int enable_net_traffic(rtl8150_t *dev)
+static int enable_net_traffic(rtl8150_t * dev)
 {
-	u8	cr, tcr, rcr, msr;
+	u8 cr, tcr, rcr, msr;
 
-	if (rtl8150_reset(dev)) {
+	if (!rtl8150_reset(dev)) {
 		warn("%s - device reset failed", __FUNCTION__);
 	}
-	dev->rx_creg = rcr = 0x9e;	/* bit7=1 attach Rx info at the end */
-	tcr = 0xd8;		/* bit0=1 no CRC at the end of the frame */
+	/* RCR bit7=1 attach Rx info at the end;  =0 HW CRC (which is broken) */
+	dev->rx_creg = rcr = 0x9e;
+	tcr = 0xd8;
 	cr = 0x0c;
+	if (!(rcr & 0x80))
+		set_bit(RTL8150_HW_CRC, &dev->flags);
 	set_registers(dev, RCR, 1, &rcr);
 	set_registers(dev, TCR, 1, &tcr);
 	set_registers(dev, CR, 1, &cr);
@@ -416,26 +483,23 @@ static int enable_net_traffic(rtl8150_t *dev)
 	return 0;
 }
 
-
-static void disable_net_traffic(rtl8150_t *dev)
+static void disable_net_traffic(rtl8150_t * dev)
 {
-	u8	cr;
+	u8 cr;
 
 	get_registers(dev, CR, 1, &cr);
 	cr &= 0xf3;
 	set_registers(dev, CR, 1, &cr);
 }
 
-
 static struct net_device_stats *rtl8150_netdev_stats(struct net_device *dev)
 {
-	return &((rtl8150_t *)dev->priv)->stats;
+	return &((rtl8150_t *) dev->priv)->stats;
 }
 
-
 static void rtl8150_tx_timeout(struct net_device *netdev)
 {
-	rtl8150_t	*dev;
+	rtl8150_t *dev;
 
 	dev = netdev->priv;
 	if (!dev)
@@ -446,10 +510,9 @@ static void rtl8150_tx_timeout(struct net_device *netdev)
 	dev->stats.tx_errors++;
 }
 
-
 static void rtl8150_set_multicast(struct net_device *netdev)
 {
-	rtl8150_t	*dev;
+	rtl8150_t *dev;
 
 	dev = netdev->priv;
 	netif_stop_queue(netdev);
@@ -457,7 +520,7 @@ static void rtl8150_set_multicast(struct net_device *netdev)
 		dev->rx_creg |= 0x0001;
 		info("%s: promiscuous mode", netdev->name);
 	} else if ((netdev->mc_count > multicast_filter_limit) ||
-	           (netdev->flags & IFF_ALLMULTI)) {
+		   (netdev->flags & IFF_ALLMULTI)) {
 		dev->rx_creg &= 0xfffe;
 		dev->rx_creg |= 0x0002;
 		info("%s: allmulti set", netdev->name);
@@ -469,21 +532,18 @@ static void rtl8150_set_multicast(struct net_device *netdev)
 	netif_wake_queue(netdev);
 }
 
-
 static int rtl8150_start_xmit(struct sk_buff *skb, struct net_device *netdev)
 {
-	rtl8150_t	*dev;
-	int		count, res;
+	rtl8150_t *dev;
+	int count, res;
 
 	netif_stop_queue(netdev);
 	dev = netdev->priv;
 	count = (skb->len < 60) ? 60 : skb->len;
 	count = (count & 0x3f) ? count : count + 1;
-	memcpy(dev->tx_buff, skb->data, skb->len);
-	FILL_BULK_URB(dev->tx_urb, dev->udev, usb_sndbulkpipe(dev->udev,2),
-		      dev->tx_buff, RTL8150_MAX_MTU, write_bulk_callback, dev);
-	dev->tx_urb->transfer_buffer_length = count;
-
+	dev->tx_skb = skb;
+	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_KERNEL))) {
 		warn("failed tx_urb %d\n", res);
 		dev->stats.tx_errors++;
@@ -493,31 +553,33 @@ static int rtl8150_start_xmit(struct sk_buff *skb, struct net_device *netdev)
 		dev->stats.tx_bytes += skb->len;
 		netdev->trans_start = jiffies;
 	}
-	dev_kfree_skb(skb);
 
 	return 0;
 }
 
-
 static int rtl8150_open(struct net_device *netdev)
 {
-	rtl8150_t	*dev;
-	int		res;
-	
+	rtl8150_t *dev;
+	int res;
+
 	dev = netdev->priv;
 	if (dev == NULL) {
 		return -ENODEV;
 	}
 
+	dev->rx_skb = pull_skb(dev);
+	if (!dev->rx_skb)
+		return -ENOMEM;
+
 	down(&dev->sem);
-	FILL_BULK_URB(dev->rx_urb, dev->udev, usb_rcvbulkpipe(dev->udev,1),
-			dev->rx_buff, RTL8150_MAX_MTU, read_bulk_callback, dev);
-	if ((res=usb_submit_urb(dev->rx_urb, GFP_KERNEL)))
+	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),
-			dev->intr_buff, sizeof(dev->intr_buff), intr_callback,
-			dev, dev->intr_interval);
-	if ((res=usb_submit_urb(dev->intr_urb, GFP_KERNEL)))
+	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)))
 		warn("%s: intr_urb submit failed: %d", __FUNCTION__, res);
 	netif_start_queue(netdev);
 	enable_net_traffic(dev);
@@ -526,7 +588,6 @@ static int rtl8150_open(struct net_device *netdev)
 	return res;
 }
 
-
 static int rtl8150_close(struct net_device *netdev)
 {
 	rtl8150_t *dev;
@@ -543,47 +604,41 @@ static int rtl8150_close(struct net_device *netdev)
 	netif_stop_queue(netdev);
 	up(&dev->sem);
 
-
 	return res;
 }
 
-
 static int rtl8150_ethtool_ioctl(struct net_device *netdev, void *uaddr)
 {
-	rtl8150_t	*dev;
-	int		cmd;
-	char		tmp[128];
+	rtl8150_t *dev;
+	int cmd;
 
 	dev = netdev->priv;
-	if (get_user(cmd, (int *)uaddr))
+	if (get_user(cmd, (int *) uaddr))
 		return -EFAULT;
 
 	switch (cmd) {
-	case ETHTOOL_GDRVINFO: {
-		struct ethtool_drvinfo info = {ETHTOOL_GDRVINFO};
-		
+	case ETHTOOL_GDRVINFO:{
+		struct ethtool_drvinfo info = { ETHTOOL_GDRVINFO };
+
 		strncpy(info.driver, DRIVER_DESC, ETHTOOL_BUSINFO_LEN);
 		strncpy(info.version, DRIVER_VERSION, ETHTOOL_BUSINFO_LEN);
-		sprintf(tmp, "usb%d:%d", dev->udev->bus->busnum,
-		        dev->udev->devnum);
-		strncpy(info.bus_info, tmp, ETHTOOL_BUSINFO_LEN);
+		usb_make_path(dev->udev, info.bus_info, sizeof info.bus_info);
 		if (copy_to_user(uaddr, &info, sizeof(info)))
 			return -EFAULT;
 		return 0;
-	}
-	case ETHTOOL_GSET: {
+		}
+	case ETHTOOL_GSET:{
 		struct ethtool_cmd ecmd;
-		short   lpa, bmcr;
+		short lpa, bmcr;
 
 		if (copy_from_user(&ecmd, uaddr, sizeof(ecmd)))
 			return -EFAULT;
 		ecmd.supported = (SUPPORTED_10baseT_Half |
-		                  SUPPORTED_10baseT_Full |
-		                  SUPPORTED_100baseT_Half |
-		                  SUPPORTED_100baseT_Full |
-		                  SUPPORTED_Autoneg |
-		                  SUPPORTED_TP |
-		                  SUPPORTED_MII);
+				  SUPPORTED_10baseT_Full |
+				  SUPPORTED_100baseT_Half |
+				  SUPPORTED_100baseT_Full |
+				  SUPPORTED_Autoneg |
+				  SUPPORTED_TP | SUPPORTED_MII);
 		ecmd.port = PORT_TP;
 		ecmd.transceiver = XCVR_INTERNAL;
 		ecmd.phy_address = dev->phy;
@@ -595,45 +650,44 @@ static int rtl8150_ethtool_ioctl(struct net_device *netdev, void *uaddr)
 			             SPEED_100 : SPEED_10;
 			if (ecmd.speed == SPEED_100)
 				ecmd.duplex = (lpa & LPA_100FULL) ?
-				              DUPLEX_FULL : DUPLEX_HALF;
+				    DUPLEX_FULL : DUPLEX_HALF;
 			else
 				ecmd.duplex = (lpa & LPA_10FULL) ?
-				              DUPLEX_FULL : DUPLEX_HALF;
+				    DUPLEX_FULL : DUPLEX_HALF;
 		} else {
 			ecmd.autoneg = AUTONEG_DISABLE;
 			ecmd.speed = (bmcr & BMCR_SPEED100) ?
-			             SPEED_100 : SPEED_10;
+			    SPEED_100 : SPEED_10;
 			ecmd.duplex = (bmcr & BMCR_FULLDPLX) ?
-			              DUPLEX_FULL : DUPLEX_HALF;
+			    DUPLEX_FULL : DUPLEX_HALF;
 		}
 		if (copy_to_user(uaddr, &ecmd, sizeof(ecmd)))
 			return -EFAULT;
 		return 0;
-	}
+		}
 	case ETHTOOL_SSET:
 		return -ENOTSUPP;
-	case ETHTOOL_GLINK: {
-		struct ethtool_value edata = {ETHTOOL_GLINK};
+	case ETHTOOL_GLINK:{
+		struct ethtool_value edata = { ETHTOOL_GLINK };
 
 		edata.data = netif_carrier_ok(netdev);
 		if (copy_to_user(uaddr, &edata, sizeof(edata)))
 			return -EFAULT;
 		return 0;
-	}
+		}
 	default:
 		return -EOPNOTSUPP;
 	}
 }
 
-
-static int rtl8150_ioctl (struct net_device *netdev, struct ifreq *rq, int cmd)
+static int rtl8150_ioctl(struct net_device *netdev, struct ifreq *rq, int cmd)
 {
 	rtl8150_t *dev;
-	u16	*data;
-	int	res;
+	u16 *data;
+	int res;
 
 	dev = netdev->priv;
-	data = (u16 *)&rq->ifr_data;
+	data = (u16 *) & rq->ifr_data;
 	res = 0;
 
 	down(&dev->sem);
@@ -643,10 +697,10 @@ static int rtl8150_ioctl (struct net_device *netdev, struct ifreq *rq, int cmd)
 		break;
 	case SIOCDEVPRIVATE:
 		data[0] = dev->phy;
-	case SIOCDEVPRIVATE+1:
+	case SIOCDEVPRIVATE + 1:
 		read_mii_word(dev, dev->phy, (data[1] & 0x1f), &data[3]);
 		break;
-	case SIOCDEVPRIVATE+2:
+	case SIOCDEVPRIVATE + 2:
 		if (!capable(CAP_NET_ADMIN)) {
 			up(&dev->sem);
 			return -EPERM;
@@ -660,27 +714,25 @@ static int rtl8150_ioctl (struct net_device *netdev, struct ifreq *rq, int cmd)
 	return res;
 }
 
-
-static void * rtl8150_probe(struct usb_device *udev, unsigned int ifnum,
-			    const struct usb_device_id *id)
+static void *rtl8150_probe(struct usb_device *udev, unsigned int ifnum,
+			   const struct usb_device_id *id)
 {
 	rtl8150_t *dev;
 	struct net_device *netdev;
 
-	udev->config[0].bConfigurationValue = 1;
 	if (usb_set_configuration(udev, udev->config[0].bConfigurationValue)) {
 		err("usb_set_configuration() failed");
 		return NULL;
 	}
 	if ((udev->descriptor.idVendor != VENDOR_ID_REALTEK) ||
 	    (udev->descriptor.idProduct != PRODUCT_ID_RTL8150)) {
-	    	err("Not the one we are interested about");
+		err("Not the one we are interested about");
 		return NULL;
 	}
 	dev = kmalloc(sizeof(rtl8150_t), GFP_KERNEL);
 	if (!dev) {
-		err ("Out of memory");
-		goto exit;
+		err("Out of memory");
+		return NULL;
 	} else
 		memset(dev, 0, sizeof(rtl8150_t));
 
@@ -688,11 +740,14 @@ static void * rtl8150_probe(struct usb_device *udev, unsigned int ifnum,
 	if (!netdev) {
 		kfree(dev);
 		err("Oh boy, out of memory again?!?");
-		dev = NULL;
-		goto exit;
+		return NULL;
 	}
-		
+
 	init_MUTEX(&dev->sem);
+	tasklet_init(&dev->tl, rx_fixup, (unsigned long)dev);
+	spin_lock_init(&dev->rx_pool_lock);
+	
+	down(&dev->sem);
 	dev->udev = udev;
 	dev->netdev = netdev;
 	SET_MODULE_OWNER(netdev);
@@ -708,23 +763,29 @@ static void * rtl8150_probe(struct usb_device *udev, unsigned int ifnum,
 	netdev->mtu = RTL8150_MTU;
 	dev->intr_interval = 100;	/* 100ms */
 
-	if (rtl8150_reset(dev) || !alloc_all_urbs(dev)) {
+	if (!alloc_all_urbs(dev)) {
+		err("out of memory");
+		goto err;
+	}
+	if (!rtl8150_reset(dev)) {
 		err("couldn't reset the device");
 		free_all_urbs(dev);
-		unregister_netdev(dev->netdev);
-		kfree(netdev);
-		kfree(dev);
-		dev = NULL;
-		goto exit;
+		goto err;
 	}
-
+	fill_skb_pool(dev);
 	set_ethernet_addr(dev);
 	info("%s: rtl8150 is detected", netdev->name);
-exit:
+	
+	up(&dev->sem);
 	return dev;
+err:
+	unregister_netdev(dev->netdev);
+	up(&dev->sem);
+	kfree(netdev);
+	kfree(dev);
+	return NULL;
 }
 
-
 static void rtl8150_disconnect(struct usb_device *udev, void *ptr)
 {
 	rtl8150_t *dev;
@@ -734,27 +795,26 @@ static void rtl8150_disconnect(struct usb_device *udev, void *ptr)
 	unregister_netdev(dev->netdev);
 	unlink_all_urbs(dev);
 	free_all_urbs(dev);
+	free_skb_pool(dev);
+	if (dev->rx_skb)
+		dev_kfree_skb(dev->rx_skb);
 	kfree(dev->netdev);
 	kfree(dev);
 	dev->netdev = NULL;
 	dev = NULL;
 }
 
-
-
 static int __init usb_rtl8150_init(void)
 {
 	info(DRIVER_DESC " " DRIVER_VERSION);
 	return usb_register(&rtl8150_driver);
 }
 
-
 static void __exit usb_rtl8150_exit(void)
 {
 	usb_deregister(&rtl8150_driver);
 }
 
-
 module_init(usb_rtl8150_init);
 module_exit(usb_rtl8150_exit);
 

drivers/usb/net/usbnet.c

@@ -538,25 +538,25 @@ static int genelink_rx_fixup (struct usbnet *dev, struct sk_buff *skb)
 
 		// allocate the skb for the individual packet
 		gl_skb = alloc_skb (size, GFP_ATOMIC);
-		if (gl_skb == 0)
-			return 0;
+		if (gl_skb) {
 
-		// copy the packet data to the new skb
-		memcpy (gl_skb->data, packet->packet_data, size);
+			// copy the packet data to the new skb
+			memcpy (gl_skb->data, packet->packet_data, size);
 
-		// set skb data size
-		gl_skb->len = size;
-		gl_skb->dev = &dev->net;
+			// set skb data size
+			gl_skb->len = size;
+			gl_skb->dev = &dev->net;
 
-		// determine the packet's protocol ID
-		gl_skb->protocol = eth_type_trans (gl_skb, &dev->net);
+			// determine the packet's protocol ID
+			gl_skb->protocol = eth_type_trans (gl_skb, &dev->net);
 
-		// update the status
-		dev->stats.rx_packets++;
-		dev->stats.rx_bytes += size;
+			// update the status
+			dev->stats.rx_packets++;
+			dev->stats.rx_bytes += size;
 
-		// notify os of the received packet
-		status = netif_rx (gl_skb);
+			// notify os of the received packet
+			status = netif_rx (gl_skb);
+		}
 
 		// advance to the next packet
 		packet = (struct gl_packet *)
@@ -834,10 +834,10 @@ static void nc_dump_registers (struct usbnet *dev)
 static inline void nc_dump_usbctl (struct usbnet *dev, u16 usbctl)
 {
 #ifdef DEBUG
-	devdbg (dev, "net1080 %03d/%03d usbctl 0x%x:%s%s%s%s%s;"
+	devdbg (dev, "net1080 %s-%s usbctl 0x%x:%s%s%s%s%s;"
 			" this%s%s;"
 			" other%s%s; r/o 0x%x",
-		dev->udev->bus->busnum, dev->udev->devnum,
+		dev->udev->bus->bus_name, dev->udev->devpath,
 		usbctl,
 		(usbctl & USBCTL_ENABLE_LANG) ? " lang" : "",
 		(usbctl & USBCTL_ENABLE_MFGR) ? " mfgr" : "",
@@ -879,10 +879,10 @@ static inline void nc_dump_usbctl (struct usbnet *dev, u16 usbctl)
 static inline void nc_dump_status (struct usbnet *dev, u16 status)
 {
 #ifdef DEBUG
-	devdbg (dev, "net1080 %03d/%03d status 0x%x:"
+	devdbg (dev, "net1080 %s-%s status 0x%x:"
 			" this (%c) PKT=%d%s%s%s;"
 			" other PKT=%d%s%s%s; unspec 0x%x",
-		dev->udev->bus->busnum, dev->udev->devnum,
+		dev->udev->bus->bus_name, dev->udev->devpath,
 		status,
 
 		// XXX the packet counts don't seem right
@@ -917,8 +917,8 @@ static inline void nc_dump_status (struct usbnet *dev, u16 status)
 static inline void nc_dump_ttl (struct usbnet *dev, u16 ttl)
 {
 #ifdef DEBUG
-	devdbg (dev, "net1080 %03d/%03d ttl 0x%x this = %d, other = %d",
-		dev->udev->bus->busnum, dev->udev->devnum,
+	devdbg (dev, "net1080 %s-%s ttl 0x%x this = %d, other = %d",
+		dev->udev->bus->bus_name, dev->udev->devpath,
 		ttl,
 
 		TTL_THIS (ttl),
@@ -941,7 +941,8 @@ static int net1080_reset (struct usbnet *dev)
 	// nc_dump_registers (dev);
 
 	if ((retval = nc_register_read (dev, REG_STATUS, vp)) < 0) {
-		dbg ("can't read dev %d status: %d", dev->udev->devnum, retval);
+		dbg ("can't read %s-%s status: %d",
+			dev->udev->bus->bus_name, dev->udev->devpath, retval);
 		goto done;
 	}
 	status = *vp;
@@ -1504,10 +1505,9 @@ static int usbnet_open (struct net_device *net)
 
 	// put into "known safe" state
 	if (info->reset && (retval = info->reset (dev)) < 0) {
-		devinfo (dev, "open reset fail (%d) usbnet bus%d%s, %s",
+		devinfo (dev, "open reset fail (%d) usbnet usb-%s-%s, %s",
 			retval,
-			// FIXME busnum is unstable
-			dev->udev->bus->busnum, dev->udev->devpath,
+			dev->udev->bus->bus_name, dev->udev->devpath,
 			info->description);
 		goto done;
 	}
@@ -1557,9 +1557,7 @@ static int usbnet_ethtool_ioctl (struct net_device *net, void *useraddr)
 		strncpy (info.version, DRIVER_VERSION, sizeof info.version);
 		strncpy (info.fw_version, dev->driver_info->description,
 			sizeof info.fw_version);
-		snprintf (info.bus_info, sizeof info.bus_info, "USB bus%d%s",
-			/* FIXME busnums are bogus/unstable IDs */
-			dev->udev->bus->busnum, dev->udev->devpath);
+		usb_make_path (dev->udev, info.bus_info, sizeof info.bus_info);
 		if (copy_to_user (useraddr, &info, sizeof (info)))
 			return -EFAULT;
 		return 0;
@@ -1847,9 +1845,8 @@ static void usbnet_disconnect (struct usb_device *udev, void *ptr)
 {
 	struct usbnet	*dev = (struct usbnet *) ptr;
 
-	devinfo (dev, "unregister usbnet bus%d%s, %s",
-		// FIXME busnum is unstable
-		udev->bus->busnum, udev->devpath,
+	devinfo (dev, "unregister usbnet usb-%s-%s, %s",
+		udev->bus->bus_name, udev->devpath,
 		dev->driver_info->description);
 	
 	unregister_netdev (&dev->net);
@@ -1938,9 +1935,8 @@ usbnet_probe (struct usb_device *udev, unsigned ifnum,
 	net->do_ioctl = usbnet_ioctl;
 
 	register_netdev (&dev->net);
-	devinfo (dev, "register usbnet bus%d%s, %s",
-		// FIXME busnum is unstable
-		udev->bus->busnum, udev->devpath,
+	devinfo (dev, "register usbnet usb-%s-%s, %s",
+		udev->bus->bus_name, udev->devpath,
 		dev->driver_info->description);
 
 	// ok, it's ready to go.

drivers/usb/storage/Makefile

@@ -10,16 +10,14 @@ EXTRA_CFLAGS	:= -I../../scsi/
 
 obj-$(CONFIG_USB_STORAGE)	+= usb-storage.o
 
-usb-storage-obj-$(CONFIG_USB_STORAGE_DEBUG)			+= debug.o
-usb-storage-obj-$(CONFIG_USB_STORAGE_HP8200e)			+= shuttle_usbat.o
-usb-storage-obj-$(CONFIG_USB_STORAGE_SDDR09)			+= sddr09.o
-usb-storage-obj-$(CONFIG_USB_STORAGE_FREECOM)			+= freecom.o
-usb-storage-obj-$(CONFIG_USB_STORAGE_SHUTTLE_SMARTMEDIA)	+= shuttle_sm.o
-usb-storage-obj-$(CONFIG_USB_STORAGE_SHUTTLE_COMPACTFLASH)	+= shuttle_cf.o
-usb-storage-obj-$(CONFIG_USB_STORAGE_DPCM)			+= dpcm.o
-usb-storage-obj-$(CONFIG_USB_STORAGE_ISD200)			+= isd200.o
-usb-storage-obj-$(CONFIG_USB_STORAGE_DATAFAB)			+= datafab.o
-usb-storage-obj-$(CONFIG_USB_STORAGE_JUMPSHOT)			+= jumpshot.o
+usb-storage-obj-$(CONFIG_USB_STORAGE_DEBUG)	+= debug.o
+usb-storage-obj-$(CONFIG_USB_STORAGE_HP8200e)	+= shuttle_usbat.o
+usb-storage-obj-$(CONFIG_USB_STORAGE_SDDR09)	+= sddr09.o
+usb-storage-obj-$(CONFIG_USB_STORAGE_FREECOM)	+= freecom.o
+usb-storage-obj-$(CONFIG_USB_STORAGE_DPCM)	+= dpcm.o
+usb-storage-obj-$(CONFIG_USB_STORAGE_ISD200)	+= isd200.o
+usb-storage-obj-$(CONFIG_USB_STORAGE_DATAFAB)	+= datafab.o
+usb-storage-obj-$(CONFIG_USB_STORAGE_JUMPSHOT)	+= jumpshot.o
 
 usb-storage-objs :=	scsiglue.o protocol.o transport.o usb.o \
 			initializers.o $(usb-storage-obj-y)

include/linux/usb.h

@@ -890,7 +890,6 @@ extern int usb_string(struct usb_device *dev, int index,
 	char *buf, size_t size);
 extern int usb_set_configuration(struct usb_device *dev, int configuration);
 extern int usb_set_interface(struct usb_device *dev, int ifnum, int alternate);
-extern int usb_make_path(struct usb_device *dev, char *buf, size_t size);
 
 /*
  * timeouts, in seconds, used for sending/receiving control messages
@@ -917,6 +916,7 @@ struct usb_operations;
  */
 struct usb_bus {
 	int busnum;			/* Bus number (in order of reg) */
+	char *bus_name;			/* stable id (PCI slot_name etc) */
 
 #ifdef DEVNUM_ROUND_ROBIN
 	int devnum_next;                /* Next open device number in round-robin allocation */
@@ -1087,6 +1087,37 @@ const struct usb_device_id *usb_match_id(struct usb_device *dev,
 					 struct usb_interface *interface,
 					 const struct usb_device_id *id);
 
+/**
+ * usb_make_path - returns stable device path in the usb tree
+ * @dev: the device whose path is being constructed
+ * @buf: where to put the string
+ * @size: how big is "buf"?
+ *
+ * Returns length of the string (> 0) or negative if size was too small.
+ *
+ * This identifier is intended to be "stable", reflecting physical paths in
+ * hardware such as physical bus addresses for host controllers or ports on
+ * USB hubs.  That makes it stay the same until systems are physically
+ * reconfigured, by re-cabling a tree of USB devices or by moving USB host
+ * controllers.  Adding and removing devices, including virtual root hubs
+ * in host controller driver modules, does not change these path identifers;
+ * neither does rebooting or re-enumerating.  These are more useful identifiers
+ * than changeable ("unstable") ones like bus numbers or device addresses.
+ * 
+ * With a partial exception for devices connected to USB 2.0 root hubs, these
+ * identifiers are also predictable:  so long as the device tree isn't changed,
+ * plugging any USB device into a given hub port always gives it the same path.
+ * Because of the use of "companion" controllers, devices connected to ports on
+ * USB 2.0 root hubs (EHCI host controllers) will get one path ID if they are
+ * high speed, and a different one if they are full or low speed.
+ */
+static inline int usb_make_path (struct usb_device *dev, char *buf, size_t size)
+{
+	int actual;
+	actual = snprintf (buf, size, "usb-%s-%s", dev->bus->bus_name, dev->devpath);
+	return (actual >= size) ? -1 : actual;
+}
+
 /* -------------------------------------------------------------------------- */
 
 /*