Skip to content

L
linux
Commit 4daab117 authored by Greg Kroah-Hartman's avatar Greg Kroah-Hartman
Browse files
Options

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

into kroah.com:/home/greg/linux/BK/gregkh-2.5
parents 22e962f9 c031637c
Show whitespace changes
Inline Side-by-side
Showing with 412 additions and 1047 deletions
Documentation/usb/dc2xx.txt deleted 100644 → 0
View file @ 22e962f9
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
View file @ 4daab117
......@@ -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
View file @ 4daab117
......@@ -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
View file @ 4daab117
......@@ -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
View file @ 4daab117
......@@ -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
View file @ 4daab117
......@@ -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
View file @ 4daab117
......@@ -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
View file @ 4daab117
......@@ -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
View file @ 4daab117
......@@ -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
View file @ 4daab117
......@@ -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
View file @ 4daab117
......@@ -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
View file @ 4daab117
......@@ -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
View file @ 4daab117
......@@ -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
View file @ 4daab117
......@@ -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
View file @ 4daab117
......@@ -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
View file @ 4daab117
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
View file @ 4daab117
......@@ -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
View file @ 4daab117
......@@ -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 deleted 100644 → 0
View file @ 22e962f9
/*
* 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
View file @ 4daab117
......@@ -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
View file @ 4daab117
......@@ -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
View file @ 4daab117
......@@ -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,65 +50,65 @@
#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;
unsigned long flags;
struct usb_device *udev;
struct usb_interface *interface;
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 rx_buff[RTL8150_MAX_MTU];
u8 tx_buff[RTL8150_MAX_MTU];
u8 intr_buff[8];
u8 phy;
};
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,
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",
probe: rtl8150_probe,
......@@ -119,29 +116,25 @@ 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),
return usb_control_msg(dev->udev, usb_rcvctrlpipe(dev->udev, 0),
RTL8150_REQ_GET_REGS, RTL8150_REQT_READ,
indx, 0, data, size, HZ/2);
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),
return usb_control_msg(dev->udev, usb_sndctrlpipe(dev->udev, 0),
RTL8150_REQ_SET_REGS, RTL8150_REQT_WRITE,
indx, 0, data, size, HZ/2);
indx, 0, data, size, HZ / 2);
}
static void ctrl_callback(struct urb *urb)
{
rtl8150_t *dev;
......@@ -160,8 +153,7 @@ 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;
......@@ -174,9 +166,9 @@ static int async_set_registers(rtl8150_t *dev, u16 indx, u16 size, void *data)
dev->dr.wIndex = 0;
dev->dr.wLength = cpu_to_le16(size);
dev->ctrl_urb->transfer_buffer_length = size;
FILL_CONTROL_URB(dev->ctrl_urb, dev->udev, usb_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,8 +177,7 @@ 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;
......@@ -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,8 +201,7 @@ 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;
......@@ -225,16 +215,15 @@ 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];
......@@ -242,22 +231,20 @@ static inline void set_ethernet_addr(rtl8150_t *dev)
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,7 +287,6 @@ 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;
......@@ -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,27 +318,58 @@ 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)
{
......@@ -363,6 +378,7 @@ static void write_bulk_callback(struct urb *urb)
dev = urb->context;
if (!dev)
return;
dev_kfree_skb_irq(dev->tx_skb);
if (!netif_device_present(dev->netdev))
return;
if (urb->status)
......@@ -371,7 +387,6 @@ static void write_bulk_callback(struct urb *urb)
netif_wake_queue(dev->netdev);
}
void intr_callback(struct urb *urb)
{
rtl8150_t *dev;
......@@ -385,29 +400,81 @@ void intr_callback(struct urb *urb)
case -ENOENT:
return;
default:
info("%s: intr status %d", dev->netdev->name,
urb->status);
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;
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,8 +483,7 @@ 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;
......@@ -426,13 +492,11 @@ static void disable_net_traffic(rtl8150_t *dev)
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;
......@@ -446,7 +510,6 @@ 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;
......@@ -469,7 +532,6 @@ 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;
......@@ -479,11 +541,9 @@ static int rtl8150_start_xmit(struct sk_buff *skb, struct net_device *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,12 +553,10 @@ 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;
......@@ -509,15 +567,19 @@ static int rtl8150_open(struct net_device *netdev)
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),
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)))
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,35 +604,30 @@ 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];
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;
......@@ -582,8 +638,7 @@ static int rtl8150_ethtool_ioctl(struct net_device *netdev, void *uaddr)
SUPPORTED_100baseT_Half |
SUPPORTED_100baseT_Full |
SUPPORTED_Autoneg |
SUPPORTED_TP |
SUPPORTED_MII);
SUPPORTED_TP | SUPPORTED_MII);
ecmd.port = PORT_TP;
ecmd.transceiver = XCVR_INTERNAL;
ecmd.phy_address = dev->phy;
......@@ -612,8 +667,8 @@ static int rtl8150_ethtool_ioctl(struct net_device *netdev, void *uaddr)
}
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)))
......@@ -625,15 +680,14 @@ static int rtl8150_ethtool_ioctl(struct net_device *netdev, void *uaddr)
}
}
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;
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,14 +714,12 @@ 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,
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;
......@@ -679,8 +731,8 @@ static void * rtl8150_probe(struct usb_device *udev, unsigned int ifnum,
}
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
View file @ 4daab117
......@@ -538,8 +538,7 @@ 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);
......@@ -557,6 +556,7 @@ static int genelink_rx_fixup (struct usbnet *dev, struct sk_buff *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
View file @ 4daab117
......@@ -14,8 +14,6 @@ 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
......
include/linux/usb.h
View file @ 4daab117
......@@ -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;
}
/* -------------------------------------------------------------------------- */
/*
......
Markdown is supported
0% or
You are about to add 0 people to the discussion. Proceed with caution.
Finish editing this message first!
Please register or to comment
GitLab Nexedi Edition | About GitLab | About Nexedi | 沪ICP备2021021310号-2 | 沪ICP备2021021310号-7