mirror of
https://github.com/adulau/aha.git
synced 2024-12-27 19:26:25 +00:00
Staging: USB-IP code cleanup
This includes fixes for all of the legit checkpatch.pl errors and warnings. I have also included several of the suggestions from the linux-kernel mailing list when the USB-IP code was first added. Signed-off-by: Brian G. Merrell <bgmerrell@novell.com> Signed-off-by: Greg Kroah-Hartman <gregkh@suse.de>
This commit is contained in:
Brian G. Merrell
Greg Kroah-Hartman
parent
1dd7def0b5
commit
b8868e45c5
12 changed files with 358 additions and 335 deletions
|
|
@ -6,7 +6,7 @@ config USB_IP_COMMON
|
|||
This enables pushing USB packets over IP to allow remote
|
||||
machines access to USB devices directly. For more details,
|
||||
and links to the userspace utility programs to let this work
|
||||
properly, see http://usbip.naist.jp/
|
||||
properly, see http://usbip.sourceforge.net/.
|
||||
|
||||
To compile this driver as a module, choose M here: the
|
||||
module will be called usbip_common_mod.
|
||||
|
|
|
|||
|
|
@ -211,7 +211,7 @@ static void stub_shutdown_connection(struct usbip_device *ud)
|
|||
* step 1?
|
||||
*/
|
||||
if (ud->tcp_socket) {
|
||||
udbg("shutdown tcp_socket %p\n", ud->tcp_socket);
|
||||
usbip_udbg("shutdown tcp_socket %p\n", ud->tcp_socket);
|
||||
kernel_sock_shutdown(ud->tcp_socket, SHUT_RDWR);
|
||||
}
|
||||
|
||||
|
|
@ -259,7 +259,7 @@ static void stub_device_reset(struct usbip_device *ud)
|
|||
struct usb_device *udev = interface_to_usbdev(sdev->interface);
|
||||
int ret;
|
||||
|
||||
udbg("device reset");
|
||||
usbip_udbg("device reset");
|
||||
ret = usb_lock_device_for_reset(udev, sdev->interface);
|
||||
if (ret < 0) {
|
||||
dev_err(&udev->dev, "lock for reset\n");
|
||||
|
|
@ -356,7 +356,7 @@ static struct stub_device *stub_device_alloc(struct usb_interface *interface)
|
|||
|
||||
usbip_start_eh(&sdev->ud);
|
||||
|
||||
udbg("register new interface\n");
|
||||
usbip_udbg("register new interface\n");
|
||||
return sdev;
|
||||
}
|
||||
|
||||
|
|
@ -366,7 +366,7 @@ static int stub_device_free(struct stub_device *sdev)
|
|||
return -EINVAL;
|
||||
|
||||
kfree(sdev);
|
||||
udbg("kfree udev ok\n");
|
||||
usbip_udbg("kfree udev ok\n");
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
|
@ -409,13 +409,13 @@ static int stub_probe(struct usb_interface *interface,
|
|||
}
|
||||
|
||||
if (udev->descriptor.bDeviceClass == USB_CLASS_HUB) {
|
||||
udbg("this device %s is a usb hub device. skip!\n",
|
||||
usbip_udbg("this device %s is a usb hub device. skip!\n",
|
||||
udev_busid);
|
||||
return -ENODEV;
|
||||
}
|
||||
|
||||
if (!strcmp(udev->bus->bus_name, "vhci_hcd")) {
|
||||
udbg("this device %s is attached on vhci_hcd. skip!\n",
|
||||
usbip_udbg("this device %s is attached on vhci_hcd. skip!\n",
|
||||
udev_busid);
|
||||
return -ENODEV;
|
||||
}
|
||||
|
|
@ -451,7 +451,7 @@ static void stub_disconnect(struct usb_interface *interface)
|
|||
{
|
||||
struct stub_device *sdev = usb_get_intfdata(interface);
|
||||
|
||||
udbg("Enter\n");
|
||||
usbip_udbg("Enter\n");
|
||||
|
||||
/* get stub_device */
|
||||
if (!sdev) {
|
||||
|
|
@ -479,5 +479,5 @@ static void stub_disconnect(struct usb_interface *interface)
|
|||
stub_device_free(sdev);
|
||||
|
||||
|
||||
udbg("bye\n");
|
||||
usbip_udbg("bye\n");
|
||||
}
|
||||
|
|
|
|||
|
|
@ -145,14 +145,14 @@ static ssize_t store_match_busid(struct device_driver *dev, const char *buf,
|
|||
if (add_match_busid(busid) < 0)
|
||||
return -ENOMEM;
|
||||
else {
|
||||
udbg("add busid %s\n", busid);
|
||||
usbip_udbg("add busid %s\n", busid);
|
||||
return count;
|
||||
}
|
||||
} else if (!strncmp(buf, "del ", 4)) {
|
||||
if (del_match_busid(busid) < 0)
|
||||
return -ENODEV;
|
||||
else {
|
||||
udbg("del busid %s\n", busid);
|
||||
usbip_udbg("del busid %s\n", busid);
|
||||
return count;
|
||||
}
|
||||
} else
|
||||
|
|
@ -213,12 +213,12 @@ void stub_device_cleanup_urbs(struct stub_device *sdev)
|
|||
{
|
||||
struct stub_priv *priv;
|
||||
|
||||
udbg("free sdev %p\n", sdev);
|
||||
usbip_udbg("free sdev %p\n", sdev);
|
||||
|
||||
while ((priv = stub_priv_pop(sdev))) {
|
||||
struct urb *urb = priv->urb;
|
||||
|
||||
udbg(" free urb %p\n", urb);
|
||||
usbip_udbg(" free urb %p\n", urb);
|
||||
usb_kill_urb(urb);
|
||||
|
||||
kmem_cache_free(stub_priv_cache, priv);
|
||||
|
|
|
|||
|
|
@ -65,8 +65,8 @@ static int is_reset_device_cmd(struct urb *urb)
|
|||
|
||||
if ((req->bRequest == USB_REQ_SET_FEATURE) &&
|
||||
(req->bRequestType == USB_RT_PORT) &&
|
||||
(value = USB_PORT_FEAT_RESET)) {
|
||||
dbg_stub_rx("reset_device_cmd, port %u\n", index);
|
||||
(value == USB_PORT_FEAT_RESET)) {
|
||||
usbip_dbg_stub_rx("reset_device_cmd, port %u\n", index);
|
||||
return 1;
|
||||
} else
|
||||
return 0;
|
||||
|
|
@ -99,11 +99,11 @@ static int tweak_clear_halt_cmd(struct urb *urb)
|
|||
|
||||
ret = usb_clear_halt(urb->dev, target_pipe);
|
||||
if (ret < 0)
|
||||
uinfo("clear_halt error: devnum %d endp %d, %d\n",
|
||||
urb->dev->devnum, target_endp, ret);
|
||||
usbip_uinfo("clear_halt error: devnum %d endp %d, %d\n",
|
||||
urb->dev->devnum, target_endp, ret);
|
||||
else
|
||||
uinfo("clear_halt done: devnum %d endp %d\n",
|
||||
urb->dev->devnum, target_endp);
|
||||
usbip_uinfo("clear_halt done: devnum %d endp %d\n",
|
||||
urb->dev->devnum, target_endp);
|
||||
|
||||
return ret;
|
||||
}
|
||||
|
|
@ -119,14 +119,15 @@ static int tweak_set_interface_cmd(struct urb *urb)
|
|||
alternate = le16_to_cpu(req->wValue);
|
||||
interface = le16_to_cpu(req->wIndex);
|
||||
|
||||
dbg_stub_rx("set_interface: inf %u alt %u\n", interface, alternate);
|
||||
usbip_dbg_stub_rx("set_interface: inf %u alt %u\n", interface,
|
||||
alternate);
|
||||
|
||||
ret = usb_set_interface(urb->dev, interface, alternate);
|
||||
if (ret < 0)
|
||||
uinfo("set_interface error: inf %u alt %u, %d\n",
|
||||
interface, alternate, ret);
|
||||
usbip_uinfo("set_interface error: inf %u alt %u, %d\n",
|
||||
interface, alternate, ret);
|
||||
else
|
||||
uinfo("set_interface done: inf %u alt %u\n",
|
||||
usbip_uinfo("set_interface done: inf %u alt %u\n",
|
||||
interface,
|
||||
alternate);
|
||||
|
||||
|
|
@ -157,8 +158,9 @@ static int tweak_set_configuration_cmd(struct urb *urb)
|
|||
* A user may need to set a special configuration value before
|
||||
* exporting the device.
|
||||
*/
|
||||
uinfo("set_configuration (%d) to %s\n", config, dev_name(&urb->dev->dev));
|
||||
uinfo("but, skip!\n");
|
||||
usbip_uinfo("set_configuration (%d) to %s\n", config,
|
||||
dev_name(&urb->dev->dev));
|
||||
usbip_uinfo("but, skip!\n");
|
||||
|
||||
return 0;
|
||||
/* return usb_driver_set_configuration(urb->dev, config); */
|
||||
|
|
@ -175,7 +177,8 @@ static int tweak_reset_device_cmd(struct urb *urb)
|
|||
value = le16_to_cpu(req->wValue);
|
||||
index = le16_to_cpu(req->wIndex);
|
||||
|
||||
uinfo("reset_device (port %d) to %s\n", index, dev_name(&urb->dev->dev));
|
||||
usbip_uinfo("reset_device (port %d) to %s\n", index,
|
||||
dev_name(&urb->dev->dev));
|
||||
|
||||
/* all interfaces should be owned by usbip driver, so just reset it. */
|
||||
ret = usb_lock_device_for_reset(urb->dev, NULL);
|
||||
|
|
@ -220,7 +223,7 @@ static void tweak_special_requests(struct urb *urb)
|
|||
else if (is_reset_device_cmd(urb))
|
||||
tweak_reset_device_cmd(urb);
|
||||
else
|
||||
dbg_stub_rx("no need to tweak\n");
|
||||
usbip_dbg_stub_rx("no need to tweak\n");
|
||||
}
|
||||
|
||||
/*
|
||||
|
|
@ -292,7 +295,8 @@ static int stub_recv_cmd_unlink(struct stub_device *sdev,
|
|||
}
|
||||
}
|
||||
|
||||
dbg_stub_rx("seqnum %d is not pending\n", pdu->u.cmd_unlink.seqnum);
|
||||
usbip_dbg_stub_rx("seqnum %d is not pending\n",
|
||||
pdu->u.cmd_unlink.seqnum);
|
||||
|
||||
/*
|
||||
* The urb of the unlink target is not found in priv_init queue. It was
|
||||
|
|
@ -383,7 +387,7 @@ static struct usb_host_endpoint *get_ep_from_epnum(struct usb_device *udev,
|
|||
epnum = (ep->desc.bEndpointAddress & 0x7f);
|
||||
|
||||
if (epnum == epnum0) {
|
||||
/* uinfo("found epnum %d\n", epnum0); */
|
||||
/* usbip_uinfo("found epnum %d\n", epnum0);*/
|
||||
found = 1;
|
||||
break;
|
||||
}
|
||||
|
|
@ -526,7 +530,8 @@ static void stub_recv_cmd_submit(struct stub_device *sdev,
|
|||
ret = usb_submit_urb(priv->urb, GFP_KERNEL);
|
||||
|
||||
if (ret == 0)
|
||||
dbg_stub_rx("submit urb ok, seqnum %u\n", pdu->base.seqnum);
|
||||
usbip_dbg_stub_rx("submit urb ok, seqnum %u\n",
|
||||
pdu->base.seqnum);
|
||||
else {
|
||||
dev_err(&sdev->interface->dev, "submit_urb error, %d\n", ret);
|
||||
usbip_dump_header(pdu);
|
||||
|
|
@ -539,7 +544,7 @@ static void stub_recv_cmd_submit(struct stub_device *sdev,
|
|||
usbip_event_add(ud, SDEV_EVENT_ERROR_SUBMIT);
|
||||
}
|
||||
|
||||
dbg_stub_rx("Leave\n");
|
||||
usbip_dbg_stub_rx("Leave\n");
|
||||
return;
|
||||
}
|
||||
|
||||
|
|
@ -551,7 +556,7 @@ static void stub_rx_pdu(struct usbip_device *ud)
|
|||
struct stub_device *sdev = container_of(ud, struct stub_device, ud);
|
||||
struct device *dev = &sdev->interface->dev;
|
||||
|
||||
dbg_stub_rx("Enter\n");
|
||||
usbip_dbg_stub_rx("Enter\n");
|
||||
|
||||
memset(&pdu, 0, sizeof(pdu));
|
||||
|
||||
|
|
@ -565,7 +570,7 @@ static void stub_rx_pdu(struct usbip_device *ud)
|
|||
|
||||
usbip_header_correct_endian(&pdu, 0);
|
||||
|
||||
if (dbg_flag_stub_rx)
|
||||
if (usbip_dbg_flag_stub_rx)
|
||||
usbip_dump_header(&pdu);
|
||||
|
||||
if (!valid_request(sdev, &pdu)) {
|
||||
|
|
@ -598,11 +603,11 @@ void stub_rx_loop(struct usbip_task *ut)
|
|||
|
||||
while (1) {
|
||||
if (signal_pending(current)) {
|
||||
dbg_stub_rx("signal caught!\n");
|
||||
usbip_dbg_stub_rx("signal caught!\n");
|
||||
break;
|
||||
}
|
||||
|
||||
if (usbip_event_happend(ud))
|
||||
if (usbip_event_happened(ud))
|
||||
break;
|
||||
|
||||
stub_rx_pdu(ud);
|
||||
|
|
|
|||
|
|
@ -66,7 +66,7 @@ void stub_complete(struct urb *urb)
|
|||
struct stub_device *sdev = priv->sdev;
|
||||
unsigned long flags;
|
||||
|
||||
dbg_stub_tx("complete! status %d\n", urb->status);
|
||||
usbip_dbg_stub_tx("complete! status %d\n", urb->status);
|
||||
|
||||
|
||||
switch (urb->status) {
|
||||
|
|
@ -74,20 +74,22 @@ void stub_complete(struct urb *urb)
|
|||
/* OK */
|
||||
break;
|
||||
case -ENOENT:
|
||||
uinfo("stopped by a call of usb_kill_urb() because of"
|
||||
usbip_uinfo("stopped by a call of usb_kill_urb() because of"
|
||||
"cleaning up a virtual connection\n");
|
||||
return;
|
||||
case -ECONNRESET:
|
||||
uinfo("unlinked by a call of usb_unlink_urb()\n");
|
||||
usbip_uinfo("unlinked by a call of usb_unlink_urb()\n");
|
||||
break;
|
||||
case -EPIPE:
|
||||
uinfo("endpoint %d is stalled\n", usb_pipeendpoint(urb->pipe));
|
||||
usbip_uinfo("endpoint %d is stalled\n",
|
||||
usb_pipeendpoint(urb->pipe));
|
||||
break;
|
||||
case -ESHUTDOWN:
|
||||
uinfo("device removed?\n");
|
||||
usbip_uinfo("device removed?\n");
|
||||
break;
|
||||
default:
|
||||
uinfo("urb completion with non-zero status %d\n", urb->status);
|
||||
usbip_uinfo("urb completion with non-zero status %d\n",
|
||||
urb->status);
|
||||
}
|
||||
|
||||
/* link a urb to the queue of tx. */
|
||||
|
|
@ -181,7 +183,7 @@ static int stub_send_ret_submit(struct stub_device *sdev)
|
|||
memset(&msg, 0, sizeof(msg));
|
||||
memset(&iov, 0, sizeof(iov));
|
||||
|
||||
dbg_stub_tx("setup txdata urb %p\n", urb);
|
||||
usbip_dbg_stub_tx("setup txdata urb %p\n", urb);
|
||||
|
||||
|
||||
/* 1. setup usbip_header */
|
||||
|
|
@ -227,7 +229,7 @@ static int stub_send_ret_submit(struct stub_device *sdev)
|
|||
}
|
||||
|
||||
kfree(iso_buffer);
|
||||
dbg_stub_tx("send txdata\n");
|
||||
usbip_dbg_stub_tx("send txdata\n");
|
||||
|
||||
total_size += txsize;
|
||||
}
|
||||
|
|
@ -287,7 +289,7 @@ static int stub_send_ret_unlink(struct stub_device *sdev)
|
|||
memset(&msg, 0, sizeof(msg));
|
||||
memset(&iov, 0, sizeof(iov));
|
||||
|
||||
dbg_stub_tx("setup ret unlink %lu\n", unlink->seqnum);
|
||||
usbip_dbg_stub_tx("setup ret unlink %lu\n", unlink->seqnum);
|
||||
|
||||
/* 1. setup usbip_header */
|
||||
setup_ret_unlink_pdu(&pdu_header, unlink);
|
||||
|
|
@ -308,7 +310,7 @@ static int stub_send_ret_unlink(struct stub_device *sdev)
|
|||
}
|
||||
|
||||
|
||||
dbg_stub_tx("send txdata\n");
|
||||
usbip_dbg_stub_tx("send txdata\n");
|
||||
|
||||
total_size += txsize;
|
||||
}
|
||||
|
|
@ -336,11 +338,11 @@ void stub_tx_loop(struct usbip_task *ut)
|
|||
|
||||
while (1) {
|
||||
if (signal_pending(current)) {
|
||||
dbg_stub_tx("signal catched\n");
|
||||
usbip_dbg_stub_tx("signal catched\n");
|
||||
break;
|
||||
}
|
||||
|
||||
if (usbip_event_happend(ud))
|
||||
if (usbip_event_happened(ud))
|
||||
break;
|
||||
|
||||
/*
|
||||
|
|
|
|||
|
|
@ -22,6 +22,7 @@
|
|||
#include <linux/file.h>
|
||||
#include <linux/tcp.h>
|
||||
#include <linux/in.h>
|
||||
#include <linux/kthread.h>
|
||||
#include "usbip_common.h"
|
||||
|
||||
/* version information */
|
||||
|
|
@ -70,27 +71,27 @@ static void usbip_dump_buffer(char *buff, int bufflen)
|
|||
if (bufflen > 128) {
|
||||
for (i = 0; i < 128; i++) {
|
||||
if (i%24 == 0)
|
||||
printk(" ");
|
||||
printk("%02x ", (unsigned char) buff[i]);
|
||||
printk(KERN_DEBUG " ");
|
||||
printk(KERN_DEBUG "%02x ", (unsigned char) buff[i]);
|
||||
if (i%4 == 3)
|
||||
printk("| ");
|
||||
printk(KERN_DEBUG "| ");
|
||||
if (i%24 == 23)
|
||||
printk("\n");
|
||||
printk(KERN_DEBUG "\n");
|
||||
}
|
||||
printk("... (%d byte)\n", bufflen);
|
||||
printk(KERN_DEBUG "... (%d byte)\n", bufflen);
|
||||
return;
|
||||
}
|
||||
|
||||
for (i = 0; i < bufflen; i++) {
|
||||
if (i%24 == 0)
|
||||
printk(" ");
|
||||
printk("%02x ", (unsigned char) buff[i]);
|
||||
printk(KERN_DEBUG " ");
|
||||
printk(KERN_DEBUG "%02x ", (unsigned char) buff[i]);
|
||||
if (i%4 == 3)
|
||||
printk("| ");
|
||||
printk(KERN_DEBUG "| ");
|
||||
if (i%24 == 23)
|
||||
printk("\n");
|
||||
printk(KERN_DEBUG "\n");
|
||||
}
|
||||
printk("\n");
|
||||
printk(KERN_DEBUG "\n");
|
||||
|
||||
}
|
||||
|
||||
|
|
@ -101,28 +102,28 @@ static void usbip_dump_pipe(unsigned int p)
|
|||
unsigned char dev = usb_pipedevice(p);
|
||||
unsigned char dir = usb_pipein(p);
|
||||
|
||||
printk("dev(%d) ", dev);
|
||||
printk("ep(%d) ", ep);
|
||||
printk("%s ", dir ? "IN" : "OUT");
|
||||
printk(KERN_DEBUG "dev(%d) ", dev);
|
||||
printk(KERN_DEBUG "ep(%d) ", ep);
|
||||
printk(KERN_DEBUG "%s ", dir ? "IN" : "OUT");
|
||||
|
||||
switch (type) {
|
||||
case PIPE_ISOCHRONOUS:
|
||||
printk("%s ", "ISO");
|
||||
printk(KERN_DEBUG "%s ", "ISO");
|
||||
break;
|
||||
case PIPE_INTERRUPT:
|
||||
printk("%s ", "INT");
|
||||
printk(KERN_DEBUG "%s ", "INT");
|
||||
break;
|
||||
case PIPE_CONTROL:
|
||||
printk("%s ", "CTL");
|
||||
printk(KERN_DEBUG "%s ", "CTL");
|
||||
break;
|
||||
case PIPE_BULK:
|
||||
printk("%s ", "BLK");
|
||||
printk(KERN_DEBUG "%s ", "BLK");
|
||||
break;
|
||||
default:
|
||||
printk("ERR");
|
||||
printk(KERN_DEBUG "ERR");
|
||||
}
|
||||
|
||||
printk("\n");
|
||||
printk(KERN_DEBUG "\n");
|
||||
|
||||
}
|
||||
|
||||
|
|
@ -136,55 +137,55 @@ static void usbip_dump_usb_device(struct usb_device *udev)
|
|||
|
||||
switch (udev->speed) {
|
||||
case USB_SPEED_HIGH:
|
||||
printk(" SPD_HIGH");
|
||||
printk(KERN_DEBUG " SPD_HIGH");
|
||||
break;
|
||||
case USB_SPEED_FULL:
|
||||
printk(" SPD_FULL");
|
||||
printk(KERN_DEBUG " SPD_FULL");
|
||||
break;
|
||||
case USB_SPEED_LOW:
|
||||
printk(" SPD_LOW");
|
||||
printk(KERN_DEBUG " SPD_LOW");
|
||||
break;
|
||||
case USB_SPEED_UNKNOWN:
|
||||
printk(" SPD_UNKNOWN");
|
||||
printk(KERN_DEBUG " SPD_UNKNOWN");
|
||||
break;
|
||||
default:
|
||||
printk(" SPD_ERROR");
|
||||
printk(KERN_DEBUG " SPD_ERROR");
|
||||
}
|
||||
|
||||
printk(" tt %p, ttport %d", udev->tt, udev->ttport);
|
||||
printk("\n");
|
||||
printk(KERN_DEBUG " tt %p, ttport %d", udev->tt, udev->ttport);
|
||||
printk(KERN_DEBUG "\n");
|
||||
|
||||
dev_dbg(dev, " ");
|
||||
for (i = 0; i < 16; i++)
|
||||
printk(" %2u", i);
|
||||
printk("\n");
|
||||
printk(KERN_DEBUG " %2u", i);
|
||||
printk(KERN_DEBUG "\n");
|
||||
|
||||
dev_dbg(dev, " toggle0(IN) :");
|
||||
for (i = 0; i < 16; i++)
|
||||
printk(" %2u", (udev->toggle[0] & (1 << i)) ? 1 : 0);
|
||||
printk("\n");
|
||||
printk(KERN_DEBUG " %2u", (udev->toggle[0] & (1 << i)) ? 1 : 0);
|
||||
printk(KERN_DEBUG "\n");
|
||||
|
||||
dev_dbg(dev, " toggle1(OUT):");
|
||||
for (i = 0; i < 16; i++)
|
||||
printk(" %2u", (udev->toggle[1] & (1 << i)) ? 1 : 0);
|
||||
printk("\n");
|
||||
printk(KERN_DEBUG " %2u", (udev->toggle[1] & (1 << i)) ? 1 : 0);
|
||||
printk(KERN_DEBUG "\n");
|
||||
|
||||
|
||||
dev_dbg(dev, " epmaxp_in :");
|
||||
for (i = 0; i < 16; i++) {
|
||||
if (udev->ep_in[i])
|
||||
printk(" %2u",
|
||||
printk(KERN_DEBUG " %2u",
|
||||
le16_to_cpu(udev->ep_in[i]->desc.wMaxPacketSize));
|
||||
}
|
||||
printk("\n");
|
||||
printk(KERN_DEBUG "\n");
|
||||
|
||||
dev_dbg(dev, " epmaxp_out :");
|
||||
for (i = 0; i < 16; i++) {
|
||||
if (udev->ep_out[i])
|
||||
printk(" %2u",
|
||||
printk(KERN_DEBUG " %2u",
|
||||
le16_to_cpu(udev->ep_out[i]->desc.wMaxPacketSize));
|
||||
}
|
||||
printk("\n");
|
||||
printk(KERN_DEBUG "\n");
|
||||
|
||||
dev_dbg(dev, "parent %p, bus %p\n", udev->parent, udev->bus);
|
||||
|
||||
|
|
@ -203,91 +204,91 @@ static void usbip_dump_request_type(__u8 rt)
|
|||
{
|
||||
switch (rt & USB_RECIP_MASK) {
|
||||
case USB_RECIP_DEVICE:
|
||||
printk("DEVICE");
|
||||
printk(KERN_DEBUG "DEVICE");
|
||||
break;
|
||||
case USB_RECIP_INTERFACE:
|
||||
printk("INTERF");
|
||||
printk(KERN_DEBUG "INTERF");
|
||||
break;
|
||||
case USB_RECIP_ENDPOINT:
|
||||
printk("ENDPOI");
|
||||
printk(KERN_DEBUG "ENDPOI");
|
||||
break;
|
||||
case USB_RECIP_OTHER:
|
||||
printk("OTHER ");
|
||||
printk(KERN_DEBUG "OTHER ");
|
||||
break;
|
||||
default:
|
||||
printk("------");
|
||||
printk(KERN_DEBUG "------");
|
||||
}
|
||||
}
|
||||
|
||||
static void usbip_dump_usb_ctrlrequest(struct usb_ctrlrequest *cmd)
|
||||
{
|
||||
if (!cmd) {
|
||||
printk(" %s : null pointer\n", __func__);
|
||||
printk(KERN_DEBUG " %s : null pointer\n", __func__);
|
||||
return;
|
||||
}
|
||||
|
||||
printk(" ");
|
||||
printk("bRequestType(%02X) ", cmd->bRequestType);
|
||||
printk("bRequest(%02X) " , cmd->bRequest);
|
||||
printk("wValue(%04X) ", cmd->wValue);
|
||||
printk("wIndex(%04X) ", cmd->wIndex);
|
||||
printk("wLength(%04X) ", cmd->wLength);
|
||||
printk(KERN_DEBUG " ");
|
||||
printk(KERN_DEBUG "bRequestType(%02X) ", cmd->bRequestType);
|
||||
printk(KERN_DEBUG "bRequest(%02X) " , cmd->bRequest);
|
||||
printk(KERN_DEBUG "wValue(%04X) ", cmd->wValue);
|
||||
printk(KERN_DEBUG "wIndex(%04X) ", cmd->wIndex);
|
||||
printk(KERN_DEBUG "wLength(%04X) ", cmd->wLength);
|
||||
|
||||
printk("\n ");
|
||||
printk(KERN_DEBUG "\n ");
|
||||
|
||||
if ((cmd->bRequestType & USB_TYPE_MASK) == USB_TYPE_STANDARD) {
|
||||
printk("STANDARD ");
|
||||
printk(KERN_DEBUG "STANDARD ");
|
||||
switch (cmd->bRequest) {
|
||||
case USB_REQ_GET_STATUS:
|
||||
printk("GET_STATUS");
|
||||
printk(KERN_DEBUG "GET_STATUS");
|
||||
break;
|
||||
case USB_REQ_CLEAR_FEATURE:
|
||||
printk("CLEAR_FEAT");
|
||||
printk(KERN_DEBUG "CLEAR_FEAT");
|
||||
break;
|
||||
case USB_REQ_SET_FEATURE:
|
||||
printk("SET_FEAT ");
|
||||
printk(KERN_DEBUG "SET_FEAT ");
|
||||
break;
|
||||
case USB_REQ_SET_ADDRESS:
|
||||
printk("SET_ADDRRS");
|
||||
printk(KERN_DEBUG "SET_ADDRRS");
|
||||
break;
|
||||
case USB_REQ_GET_DESCRIPTOR:
|
||||
printk("GET_DESCRI");
|
||||
printk(KERN_DEBUG "GET_DESCRI");
|
||||
break;
|
||||
case USB_REQ_SET_DESCRIPTOR:
|
||||
printk("SET_DESCRI");
|
||||
printk(KERN_DEBUG "SET_DESCRI");
|
||||
break;
|
||||
case USB_REQ_GET_CONFIGURATION:
|
||||
printk("GET_CONFIG");
|
||||
printk(KERN_DEBUG "GET_CONFIG");
|
||||
break;
|
||||
case USB_REQ_SET_CONFIGURATION:
|
||||
printk("SET_CONFIG");
|
||||
printk(KERN_DEBUG "SET_CONFIG");
|
||||
break;
|
||||
case USB_REQ_GET_INTERFACE:
|
||||
printk("GET_INTERF");
|
||||
printk(KERN_DEBUG "GET_INTERF");
|
||||
break;
|
||||
case USB_REQ_SET_INTERFACE:
|
||||
printk("SET_INTERF");
|
||||
printk(KERN_DEBUG "SET_INTERF");
|
||||
break;
|
||||
case USB_REQ_SYNCH_FRAME:
|
||||
printk("SYNC_FRAME");
|
||||
printk(KERN_DEBUG "SYNC_FRAME");
|
||||
break;
|
||||
default:
|
||||
printk("REQ(%02X) ", cmd->bRequest);
|
||||
printk(KERN_DEBUG "REQ(%02X) ", cmd->bRequest);
|
||||
}
|
||||
|
||||
printk(" ");
|
||||
printk(KERN_DEBUG " ");
|
||||
usbip_dump_request_type(cmd->bRequestType);
|
||||
|
||||
} else if ((cmd->bRequestType & USB_TYPE_MASK) == USB_TYPE_CLASS)
|
||||
printk("CLASS ");
|
||||
printk(KERN_DEBUG "CLASS ");
|
||||
|
||||
else if ((cmd->bRequestType & USB_TYPE_MASK) == USB_TYPE_VENDOR)
|
||||
printk("VENDOR ");
|
||||
printk(KERN_DEBUG "VENDOR ");
|
||||
|
||||
else if ((cmd->bRequestType & USB_TYPE_MASK) == USB_TYPE_RESERVED)
|
||||
printk("RESERVED");
|
||||
printk(KERN_DEBUG "RESERVED");
|
||||
|
||||
printk("\n");
|
||||
printk(KERN_DEBUG "\n");
|
||||
}
|
||||
|
||||
void usbip_dump_urb(struct urb *urb)
|
||||
|
|
@ -319,7 +320,8 @@ void usbip_dump_urb(struct urb *urb)
|
|||
dev_dbg(dev, " status :%d\n", urb->status);
|
||||
dev_dbg(dev, " transfer_flags :%08X\n", urb->transfer_flags);
|
||||
dev_dbg(dev, " transfer_buffer :%p\n", urb->transfer_buffer);
|
||||
dev_dbg(dev, " transfer_buffer_length:%d\n", urb->transfer_buffer_length);
|
||||
dev_dbg(dev, " transfer_buffer_length:%d\n",
|
||||
urb->transfer_buffer_length);
|
||||
dev_dbg(dev, " actual_length :%d\n", urb->actual_length);
|
||||
dev_dbg(dev, " setup_packet :%p\n", urb->setup_packet);
|
||||
|
||||
|
|
@ -338,7 +340,7 @@ EXPORT_SYMBOL_GPL(usbip_dump_urb);
|
|||
|
||||
void usbip_dump_header(struct usbip_header *pdu)
|
||||
{
|
||||
udbg("BASE: cmd %u seq %u devid %u dir %u ep %u\n",
|
||||
usbip_udbg("BASE: cmd %u seq %u devid %u dir %u ep %u\n",
|
||||
pdu->base.command,
|
||||
pdu->base.seqnum,
|
||||
pdu->base.devid,
|
||||
|
|
@ -347,7 +349,8 @@ void usbip_dump_header(struct usbip_header *pdu)
|
|||
|
||||
switch (pdu->base.command) {
|
||||
case USBIP_CMD_SUBMIT:
|
||||
udbg("CMD_SUBMIT: x_flags %u x_len %u sf %u #p %u iv %u\n",
|
||||
usbip_udbg("CMD_SUBMIT: "
|
||||
"x_flags %u x_len %u sf %u #p %u iv %u\n",
|
||||
pdu->u.cmd_submit.transfer_flags,
|
||||
pdu->u.cmd_submit.transfer_buffer_length,
|
||||
pdu->u.cmd_submit.start_frame,
|
||||
|
|
@ -355,20 +358,20 @@ void usbip_dump_header(struct usbip_header *pdu)
|
|||
pdu->u.cmd_submit.interval);
|
||||
break;
|
||||
case USBIP_CMD_UNLINK:
|
||||
udbg("CMD_UNLINK: seq %u\n", pdu->u.cmd_unlink.seqnum);
|
||||
usbip_udbg("CMD_UNLINK: seq %u\n", pdu->u.cmd_unlink.seqnum);
|
||||
break;
|
||||
case USBIP_RET_SUBMIT:
|
||||
udbg("RET_SUBMIT: st %d al %u sf %d ec %d\n",
|
||||
usbip_udbg("RET_SUBMIT: st %d al %u sf %d ec %d\n",
|
||||
pdu->u.ret_submit.status,
|
||||
pdu->u.ret_submit.actual_length,
|
||||
pdu->u.ret_submit.start_frame,
|
||||
pdu->u.ret_submit.error_count);
|
||||
case USBIP_RET_UNLINK:
|
||||
udbg("RET_UNLINK: status %d\n", pdu->u.ret_unlink.status);
|
||||
usbip_udbg("RET_UNLINK: status %d\n", pdu->u.ret_unlink.status);
|
||||
break;
|
||||
default:
|
||||
/* NOT REACHED */
|
||||
udbg("UNKNOWN\n");
|
||||
usbip_udbg("UNKNOWN\n");
|
||||
}
|
||||
}
|
||||
EXPORT_SYMBOL_GPL(usbip_dump_header);
|
||||
|
|
@ -402,29 +405,30 @@ int usbip_thread(void *param)
|
|||
complete_and_exit(&ut->thread_done, 0);
|
||||
}
|
||||
|
||||
void usbip_start_threads(struct usbip_device *ud)
|
||||
int usbip_start_threads(struct usbip_device *ud)
|
||||
{
|
||||
/*
|
||||
* threads are invoked per one device (per one connection).
|
||||
*/
|
||||
int retval;
|
||||
struct task_struct *th;
|
||||
|
||||
retval = kernel_thread(usbip_thread, (void *)&ud->tcp_rx, 0);
|
||||
if (retval < 0) {
|
||||
printk(KERN_ERR "Creating tcp_rx thread for ud %p failed.\n",
|
||||
ud);
|
||||
return;
|
||||
th = kthread_run(usbip_thread, (void *)&ud->tcp_rx, "usbip");
|
||||
if (IS_ERR(th)) {
|
||||
printk(KERN_WARNING
|
||||
"Unable to start control thread\n");
|
||||
return PTR_ERR(th);
|
||||
}
|
||||
retval = kernel_thread(usbip_thread, (void *)&ud->tcp_tx, 0);
|
||||
if (retval < 0) {
|
||||
printk(KERN_ERR "Creating tcp_tx thread for ud %p failed.\n",
|
||||
ud);
|
||||
return;
|
||||
th = kthread_run(usbip_thread, (void *)&ud->tcp_tx, "usbip");
|
||||
if (IS_ERR(th)) {
|
||||
printk(KERN_WARNING
|
||||
"Unable to start control thread\n");
|
||||
return PTR_ERR(th);
|
||||
}
|
||||
|
||||
/* confirm threads are starting */
|
||||
wait_for_completion(&ud->tcp_rx.thread_done);
|
||||
wait_for_completion(&ud->tcp_tx.thread_done);
|
||||
return 0;
|
||||
}
|
||||
EXPORT_SYMBOL_GPL(usbip_start_threads);
|
||||
|
||||
|
|
@ -434,13 +438,13 @@ void usbip_stop_threads(struct usbip_device *ud)
|
|||
if (ud->tcp_rx.thread != NULL) {
|
||||
send_sig(SIGKILL, ud->tcp_rx.thread, 1);
|
||||
wait_for_completion(&ud->tcp_rx.thread_done);
|
||||
udbg("rx_thread for ud %p has finished\n", ud);
|
||||
usbip_udbg("rx_thread for ud %p has finished\n", ud);
|
||||
}
|
||||
|
||||
if (ud->tcp_tx.thread != NULL) {
|
||||
send_sig(SIGKILL, ud->tcp_tx.thread, 1);
|
||||
wait_for_completion(&ud->tcp_tx.thread_done);
|
||||
udbg("tx_thread for ud %p has finished\n", ud);
|
||||
usbip_udbg("tx_thread for ud %p has finished\n", ud);
|
||||
}
|
||||
}
|
||||
EXPORT_SYMBOL_GPL(usbip_stop_threads);
|
||||
|
|
@ -468,11 +472,11 @@ int usbip_xmit(int send, struct socket *sock, char *buf,
|
|||
struct kvec iov;
|
||||
int total = 0;
|
||||
|
||||
/* for blocks of if (dbg_flag_xmit) */
|
||||
/* for blocks of if (usbip_dbg_flag_xmit) */
|
||||
char *bp = buf;
|
||||
int osize = size;
|
||||
|
||||
dbg_xmit("enter\n");
|
||||
usbip_dbg_xmit("enter\n");
|
||||
|
||||
if (!sock || !buf || !size) {
|
||||
printk(KERN_ERR "%s: invalid arg, sock %p buff %p size %d\n",
|
||||
|
|
@ -481,14 +485,14 @@ int usbip_xmit(int send, struct socket *sock, char *buf,
|
|||
}
|
||||
|
||||
|
||||
if (dbg_flag_xmit) {
|
||||
if (usbip_dbg_flag_xmit) {
|
||||
if (send) {
|
||||
if (!in_interrupt())
|
||||
printk(KERN_DEBUG "%-10s:", current->comm);
|
||||
else
|
||||
printk(KERN_DEBUG "interupt :");
|
||||
printk(KERN_DEBUG "interrupt :");
|
||||
|
||||
printk("%s: sending... , sock %p, buf %p, "
|
||||
printk(KERN_DEBUG "%s: sending... , sock %p, buf %p, "
|
||||
"size %d, msg_flags %d\n", __func__,
|
||||
sock, buf, size, msg_flags);
|
||||
usbip_dump_buffer(buf, size);
|
||||
|
|
@ -514,8 +518,8 @@ int usbip_xmit(int send, struct socket *sock, char *buf,
|
|||
MSG_WAITALL);
|
||||
|
||||
if (result <= 0) {
|
||||
udbg("usbip_xmit: %s sock %p buf %p size %u ret %d"
|
||||
" total %d\n",
|
||||
usbip_udbg("usbip_xmit: %s sock %p buf %p size %u ret "
|
||||
"%d total %d\n",
|
||||
send ? "send" : "receive", sock, buf,
|
||||
size, result, total);
|
||||
goto err;
|
||||
|
|
@ -528,22 +532,23 @@ int usbip_xmit(int send, struct socket *sock, char *buf,
|
|||
} while (size > 0);
|
||||
|
||||
|
||||
if (dbg_flag_xmit) {
|
||||
if (usbip_dbg_flag_xmit) {
|
||||
if (!send) {
|
||||
if (!in_interrupt())
|
||||
printk(KERN_DEBUG "%-10s:", current->comm);
|
||||
else
|
||||
printk(KERN_DEBUG "interupt :");
|
||||
printk(KERN_DEBUG "interrupt :");
|
||||
|
||||
printk("usbip_xmit: receiving....\n");
|
||||
printk(KERN_DEBUG "usbip_xmit: receiving....\n");
|
||||
usbip_dump_buffer(bp, osize);
|
||||
printk("usbip_xmit: received, osize %d ret %d size %d "
|
||||
"total %d\n", osize, result, size,
|
||||
total);
|
||||
printk(KERN_DEBUG "usbip_xmit: received, osize %d ret "
|
||||
"%d size %d total %d\n", osize, result,
|
||||
size, total);
|
||||
}
|
||||
|
||||
if (send)
|
||||
printk("usbip_xmit: send, total %d\n", total);
|
||||
printk(KERN_DEBUG "usbip_xmit: send, total %d\n",
|
||||
total);
|
||||
}
|
||||
|
||||
return total;
|
||||
|
|
@ -638,19 +643,7 @@ EXPORT_SYMBOL_GPL(sockfd_to_socket);
|
|||
/* there may be more cases to tweak the flags. */
|
||||
static unsigned int tweak_transfer_flags(unsigned int flags)
|
||||
{
|
||||
|
||||
if (flags & URB_NO_TRANSFER_DMA_MAP)
|
||||
/*
|
||||
* vhci_hcd does not provide DMA-mapped I/O. The upper
|
||||
* driver does not need to set this flag. The remote
|
||||
* usbip.ko does not still perform DMA-mapped I/O for
|
||||
* DMA-caplable host controllers. So, clear this flag.
|
||||
*/
|
||||
flags &= ~URB_NO_TRANSFER_DMA_MAP;
|
||||
|
||||
if (flags & URB_NO_SETUP_DMA_MAP)
|
||||
flags &= ~URB_NO_SETUP_DMA_MAP;
|
||||
|
||||
flags &= ~(URB_NO_TRANSFER_DMA_MAP|URB_NO_SETUP_DMA_MAP);
|
||||
return flags;
|
||||
}
|
||||
|
||||
|
|
@ -904,7 +897,7 @@ int usbip_recv_iso(struct usbip_device *ud, struct urb *urb)
|
|||
|
||||
/* my Bluetooth dongle gets ISO URBs which are np = 0 */
|
||||
if (np == 0) {
|
||||
/* uinfo("iso np == 0\n"); */
|
||||
/* usbip_uinfo("iso np == 0\n"); */
|
||||
/* usbip_dump_urb(urb); */
|
||||
return 0;
|
||||
}
|
||||
|
|
@ -934,7 +927,6 @@ int usbip_recv_iso(struct usbip_device *ud, struct urb *urb)
|
|||
usbip_pack_iso(iso, &urb->iso_frame_desc[i], 0);
|
||||
}
|
||||
|
||||
|
||||
kfree(buff);
|
||||
|
||||
return ret;
|
||||
|
|
|
|||
|
|
@ -33,23 +33,23 @@
|
|||
*/
|
||||
|
||||
/**
|
||||
* udbg - print debug messages if CONFIG_USB_DEBUG is defined
|
||||
* usbip_udbg - print debug messages if CONFIG_USB_DEBUG is defined
|
||||
* @fmt:
|
||||
* @args:
|
||||
*/
|
||||
|
||||
#ifdef CONFIG_USB_DEBUG
|
||||
|
||||
#define udbg(fmt, args...) \
|
||||
#define usbip_udbg(fmt, args...) \
|
||||
do { \
|
||||
printk(KERN_DEBUG "%-10s:(%s,%d) %s: " fmt, \
|
||||
(in_interrupt() ? "interrupt" : (current)->comm),\
|
||||
__FILE__, __LINE__, __func__, ##args); \
|
||||
__FILE__, __LINE__, __func__, ##args); \
|
||||
} while (0)
|
||||
|
||||
#else /* CONFIG_USB_DEBUG */
|
||||
|
||||
#define udbg(fmt, args...) do { } while (0)
|
||||
#define usbip_udbg(fmt, args...) do { } while (0)
|
||||
|
||||
#endif /* CONFIG_USB_DEBUG */
|
||||
|
||||
|
|
@ -72,58 +72,58 @@ enum {
|
|||
usbip_debug_vhci_sysfs = (1 << 12)
|
||||
};
|
||||
|
||||
#define dbg_flag_xmit (usbip_debug_flag & usbip_debug_xmit)
|
||||
#define dbg_flag_vhci_rh (usbip_debug_flag & usbip_debug_vhci_rh)
|
||||
#define dbg_flag_vhci_hc (usbip_debug_flag & usbip_debug_vhci_hc)
|
||||
#define dbg_flag_vhci_rx (usbip_debug_flag & usbip_debug_vhci_rx)
|
||||
#define dbg_flag_vhci_tx (usbip_debug_flag & usbip_debug_vhci_tx)
|
||||
#define dbg_flag_vhci_sysfs (usbip_debug_flag & usbip_debug_vhci_sysfs)
|
||||
#define dbg_flag_stub_rx (usbip_debug_flag & usbip_debug_stub_rx)
|
||||
#define dbg_flag_stub_tx (usbip_debug_flag & usbip_debug_stub_tx)
|
||||
#define usbip_dbg_flag_xmit (usbip_debug_flag & usbip_debug_xmit)
|
||||
#define usbip_dbg_flag_vhci_rh (usbip_debug_flag & usbip_debug_vhci_rh)
|
||||
#define usbip_dbg_flag_vhci_hc (usbip_debug_flag & usbip_debug_vhci_hc)
|
||||
#define usbip_dbg_flag_vhci_rx (usbip_debug_flag & usbip_debug_vhci_rx)
|
||||
#define usbip_dbg_flag_vhci_tx (usbip_debug_flag & usbip_debug_vhci_tx)
|
||||
#define usbip_dbg_flag_stub_rx (usbip_debug_flag & usbip_debug_stub_rx)
|
||||
#define usbip_dbg_flag_stub_tx (usbip_debug_flag & usbip_debug_stub_tx)
|
||||
#define usbip_dbg_flag_vhci_sysfs (usbip_debug_flag & usbip_debug_vhci_sysfs)
|
||||
|
||||
extern unsigned long usbip_debug_flag;
|
||||
extern struct device_attribute dev_attr_usbip_debug;
|
||||
|
||||
#define dbg_with_flag(flag, fmt, args...) \
|
||||
#define usbip_dbg_with_flag(flag, fmt, args...) \
|
||||
do { \
|
||||
if (flag & usbip_debug_flag) \
|
||||
udbg(fmt , ##args); \
|
||||
usbip_udbg(fmt , ##args); \
|
||||
} while (0)
|
||||
|
||||
#define dbg_sysfs(fmt, args...) \
|
||||
dbg_with_flag(usbip_debug_sysfs, fmt , ##args)
|
||||
#define dbg_xmit(fmt, args...) \
|
||||
dbg_with_flag(usbip_debug_xmit, fmt , ##args)
|
||||
#define dbg_urb(fmt, args...) \
|
||||
dbg_with_flag(usbip_debug_urb, fmt , ##args)
|
||||
#define dbg_eh(fmt, args...) \
|
||||
dbg_with_flag(usbip_debug_eh, fmt , ##args)
|
||||
#define usbip_dbg_sysfs(fmt, args...) \
|
||||
usbip_dbg_with_flag(usbip_debug_sysfs, fmt , ##args)
|
||||
#define usbip_dbg_xmit(fmt, args...) \
|
||||
usbip_dbg_with_flag(usbip_debug_xmit, fmt , ##args)
|
||||
#define usbip_dbg_urb(fmt, args...) \
|
||||
usbip_dbg_with_flag(usbip_debug_urb, fmt , ##args)
|
||||
#define usbip_dbg_eh(fmt, args...) \
|
||||
usbip_dbg_with_flag(usbip_debug_eh, fmt , ##args)
|
||||
|
||||
#define dbg_vhci_rh(fmt, args...) \
|
||||
dbg_with_flag(usbip_debug_vhci_rh, fmt , ##args)
|
||||
#define dbg_vhci_hc(fmt, args...) \
|
||||
dbg_with_flag(usbip_debug_vhci_hc, fmt , ##args)
|
||||
#define dbg_vhci_rx(fmt, args...) \
|
||||
dbg_with_flag(usbip_debug_vhci_rx, fmt , ##args)
|
||||
#define dbg_vhci_tx(fmt, args...) \
|
||||
dbg_with_flag(usbip_debug_vhci_tx, fmt , ##args)
|
||||
#define dbg_vhci_sysfs(fmt, args...) \
|
||||
dbg_with_flag(usbip_debug_vhci_sysfs, fmt , ##args)
|
||||
#define usbip_dbg_vhci_rh(fmt, args...) \
|
||||
usbip_dbg_with_flag(usbip_debug_vhci_rh, fmt , ##args)
|
||||
#define usbip_dbg_vhci_hc(fmt, args...) \
|
||||
usbip_dbg_with_flag(usbip_debug_vhci_hc, fmt , ##args)
|
||||
#define usbip_dbg_vhci_rx(fmt, args...) \
|
||||
usbip_dbg_with_flag(usbip_debug_vhci_rx, fmt , ##args)
|
||||
#define usbip_dbg_vhci_tx(fmt, args...) \
|
||||
usbip_dbg_with_flag(usbip_debug_vhci_tx, fmt , ##args)
|
||||
#define usbip_dbg_vhci_sysfs(fmt, args...) \
|
||||
usbip_dbg_with_flag(usbip_debug_vhci_sysfs, fmt , ##args)
|
||||
|
||||
#define dbg_stub_cmp(fmt, args...) \
|
||||
dbg_with_flag(usbip_debug_stub_cmp, fmt , ##args)
|
||||
#define dbg_stub_rx(fmt, args...) \
|
||||
dbg_with_flag(usbip_debug_stub_rx, fmt , ##args)
|
||||
#define dbg_stub_tx(fmt, args...) \
|
||||
dbg_with_flag(usbip_debug_stub_tx, fmt , ##args)
|
||||
#define usbip_dbg_stub_cmp(fmt, args...) \
|
||||
usbip_dbg_with_flag(usbip_debug_stub_cmp, fmt , ##args)
|
||||
#define usbip_dbg_stub_rx(fmt, args...) \
|
||||
usbip_dbg_with_flag(usbip_debug_stub_rx, fmt , ##args)
|
||||
#define usbip_dbg_stub_tx(fmt, args...) \
|
||||
usbip_dbg_with_flag(usbip_debug_stub_tx, fmt , ##args)
|
||||
|
||||
|
||||
/**
|
||||
* uerr - print error messages
|
||||
* usbip_uerr - print error messages
|
||||
* @fmt:
|
||||
* @args:
|
||||
*/
|
||||
#define uerr(fmt, args...) \
|
||||
#define usbip_uerr(fmt, args...) \
|
||||
do { \
|
||||
printk(KERN_ERR "%-10s: ***ERROR*** (%s,%d) %s: " fmt, \
|
||||
(in_interrupt() ? "interrupt" : (current)->comm),\
|
||||
|
|
@ -131,11 +131,11 @@ extern struct device_attribute dev_attr_usbip_debug;
|
|||
} while (0)
|
||||
|
||||
/**
|
||||
* uinfo - print information messages
|
||||
* usbip_uinfo - print information messages
|
||||
* @fmt:
|
||||
* @args:
|
||||
*/
|
||||
#define uinfo(fmt, args...) \
|
||||
#define usbip_uinfo(fmt, args...) \
|
||||
do { \
|
||||
printk(KERN_INFO "usbip: " fmt , ## args); \
|
||||
} while (0)
|
||||
|
|
@ -355,7 +355,7 @@ struct usbip_device {
|
|||
#define USBIP_EH_RESET (1 << 2)
|
||||
#define USBIP_EH_UNUSABLE (1 << 3)
|
||||
|
||||
#define SDEV_EVENT_REMOVED (USBIP_EH_SHUTDOWN | USBIP_EH_RESET | USBIP_EH_BYE)
|
||||
#define SDEV_EVENT_REMOVED (USBIP_EH_SHUTDOWN | USBIP_EH_RESET | USBIP_EH_BYE)
|
||||
#define SDEV_EVENT_DOWN (USBIP_EH_SHUTDOWN | USBIP_EH_RESET)
|
||||
#define SDEV_EVENT_ERROR_TCP (USBIP_EH_SHUTDOWN | USBIP_EH_RESET)
|
||||
#define SDEV_EVENT_ERROR_SUBMIT (USBIP_EH_SHUTDOWN | USBIP_EH_RESET)
|
||||
|
|
@ -381,7 +381,7 @@ struct usbip_device {
|
|||
void usbip_task_init(struct usbip_task *ut, char *,
|
||||
void (*loop_ops)(struct usbip_task *));
|
||||
|
||||
void usbip_start_threads(struct usbip_device *ud);
|
||||
int usbip_start_threads(struct usbip_device *ud);
|
||||
void usbip_stop_threads(struct usbip_device *ud);
|
||||
int usbip_thread(void *param);
|
||||
|
||||
|
|
@ -397,10 +397,10 @@ void *usbip_alloc_iso_desc_pdu(struct urb *urb, ssize_t *bufflen);
|
|||
|
||||
|
||||
/* usbip_event.c */
|
||||
void usbip_start_eh(struct usbip_device *ud);
|
||||
int usbip_start_eh(struct usbip_device *ud);
|
||||
void usbip_stop_eh(struct usbip_device *ud);
|
||||
void usbip_event_add(struct usbip_device *ud, unsigned long event);
|
||||
int usbip_event_happend(struct usbip_device *ud);
|
||||
int usbip_event_happened(struct usbip_device *ud);
|
||||
|
||||
|
||||
#endif
|
||||
|
|
|
|||
|
|
@ -18,16 +18,17 @@
|
|||
*/
|
||||
|
||||
#include "usbip_common.h"
|
||||
#include <linux/kthread.h>
|
||||
|
||||
static int event_handler(struct usbip_device *ud)
|
||||
{
|
||||
dbg_eh("enter\n");
|
||||
usbip_dbg_eh("enter\n");
|
||||
|
||||
/*
|
||||
* Events are handled by only this thread.
|
||||
*/
|
||||
while (usbip_event_happend(ud)) {
|
||||
dbg_eh("pending event %lx\n", ud->event);
|
||||
while (usbip_event_happened(ud)) {
|
||||
usbip_dbg_eh("pending event %lx\n", ud->event);
|
||||
|
||||
/*
|
||||
* NOTE: shutdown must come first.
|
||||
|
|
@ -77,30 +78,38 @@ static void event_handler_loop(struct usbip_task *ut)
|
|||
|
||||
while (1) {
|
||||
if (signal_pending(current)) {
|
||||
dbg_eh("signal catched!\n");
|
||||
usbip_dbg_eh("signal catched!\n");
|
||||
break;
|
||||
}
|
||||
|
||||
if (event_handler(ud) < 0)
|
||||
break;
|
||||
|
||||
wait_event_interruptible(ud->eh_waitq, usbip_event_happend(ud));
|
||||
dbg_eh("wakeup\n");
|
||||
wait_event_interruptible(ud->eh_waitq,
|
||||
usbip_event_happened(ud));
|
||||
usbip_dbg_eh("wakeup\n");
|
||||
}
|
||||
}
|
||||
|
||||
void usbip_start_eh(struct usbip_device *ud)
|
||||
int usbip_start_eh(struct usbip_device *ud)
|
||||
{
|
||||
struct usbip_task *eh = &ud->eh;
|
||||
struct task_struct *th;
|
||||
|
||||
init_waitqueue_head(&ud->eh_waitq);
|
||||
ud->event = 0;
|
||||
|
||||
usbip_task_init(eh, "usbip_eh", event_handler_loop);
|
||||
|
||||
kernel_thread(usbip_thread, (void *)eh, 0);
|
||||
th = kthread_run(usbip_thread, (void *)eh, "usbip");
|
||||
if (IS_ERR(th)) {
|
||||
printk(KERN_WARNING
|
||||
"Unable to start control thread\n");
|
||||
return PTR_ERR(th);
|
||||
}
|
||||
|
||||
wait_for_completion(&eh->thread_done);
|
||||
return 0;
|
||||
}
|
||||
EXPORT_SYMBOL_GPL(usbip_start_eh);
|
||||
|
||||
|
|
@ -109,7 +118,7 @@ void usbip_stop_eh(struct usbip_device *ud)
|
|||
struct usbip_task *eh = &ud->eh;
|
||||
|
||||
wait_for_completion(&eh->thread_done);
|
||||
dbg_eh("usbip_eh has finished\n");
|
||||
usbip_dbg_eh("usbip_eh has finished\n");
|
||||
}
|
||||
EXPORT_SYMBOL_GPL(usbip_stop_eh);
|
||||
|
||||
|
|
@ -125,17 +134,17 @@ void usbip_event_add(struct usbip_device *ud, unsigned long event)
|
|||
}
|
||||
EXPORT_SYMBOL_GPL(usbip_event_add);
|
||||
|
||||
int usbip_event_happend(struct usbip_device *ud)
|
||||
int usbip_event_happened(struct usbip_device *ud)
|
||||
{
|
||||
int happend = 0;
|
||||
int happened = 0;
|
||||
|
||||
spin_lock(&ud->lock);
|
||||
|
||||
if (ud->event != 0)
|
||||
happend = 1;
|
||||
happened = 1;
|
||||
|
||||
spin_unlock(&ud->lock);
|
||||
|
||||
return happend;
|
||||
return happened;
|
||||
}
|
||||
EXPORT_SYMBOL_GPL(usbip_event_happend);
|
||||
EXPORT_SYMBOL_GPL(usbip_event_happened);
|
||||
|
|
|
|||
|
|
@ -115,7 +115,7 @@ void rh_port_connect(int rhport, enum usb_device_speed speed)
|
|||
{
|
||||
unsigned long flags;
|
||||
|
||||
dbg_vhci_rh("rh_port_connect %d\n", rhport);
|
||||
usbip_dbg_vhci_rh("rh_port_connect %d\n", rhport);
|
||||
|
||||
spin_lock_irqsave(&the_controller->lock, flags);
|
||||
|
||||
|
|
@ -148,7 +148,7 @@ void rh_port_disconnect(int rhport)
|
|||
{
|
||||
unsigned long flags;
|
||||
|
||||
dbg_vhci_rh("rh_port_disconnect %d\n", rhport);
|
||||
usbip_dbg_vhci_rh("rh_port_disconnect %d\n", rhport);
|
||||
|
||||
spin_lock_irqsave(&the_controller->lock, flags);
|
||||
/* stop_activity(dum, driver); */
|
||||
|
|
@ -215,7 +215,7 @@ static int vhci_hub_status(struct usb_hcd *hcd, char *buf)
|
|||
|
||||
spin_lock_irqsave(&vhci->lock, flags);
|
||||
if (!test_bit(HCD_FLAG_HW_ACCESSIBLE, &hcd->flags)) {
|
||||
dbg_vhci_rh("hw accessible flag in on?\n");
|
||||
usbip_dbg_vhci_rh("hw accessible flag in on?\n");
|
||||
goto done;
|
||||
}
|
||||
|
||||
|
|
@ -223,14 +223,14 @@ static int vhci_hub_status(struct usb_hcd *hcd, char *buf)
|
|||
for (rhport = 0; rhport < VHCI_NPORTS; rhport++) {
|
||||
if ((vhci->port_status[rhport] & PORT_C_MASK)) {
|
||||
/* The status of a port has been changed, */
|
||||
dbg_vhci_rh("port %d is changed\n", rhport);
|
||||
usbip_dbg_vhci_rh("port %d is changed\n", rhport);
|
||||
|
||||
*event_bits |= 1 << (rhport + 1);
|
||||
changed = 1;
|
||||
}
|
||||
}
|
||||
|
||||
uinfo("changed %d\n", changed);
|
||||
usbip_uinfo("changed %d\n", changed);
|
||||
|
||||
if (hcd->state == HC_STATE_SUSPENDED)
|
||||
usb_hcd_resume_root_hub(hcd);
|
||||
|
|
@ -275,10 +275,11 @@ static int vhci_hub_control(struct usb_hcd *hcd, u16 typeReq, u16 wValue,
|
|||
* NOTE:
|
||||
* wIndex shows the port number and begins from 1.
|
||||
*/
|
||||
dbg_vhci_rh("typeReq %x wValue %x wIndex %x\n", typeReq, wValue,
|
||||
usbip_dbg_vhci_rh("typeReq %x wValue %x wIndex %x\n", typeReq, wValue,
|
||||
wIndex);
|
||||
if (wIndex > VHCI_NPORTS)
|
||||
printk(KERN_ERR "%s: invalid port number %d\n", __func__, wIndex);
|
||||
printk(KERN_ERR "%s: invalid port number %d\n", __func__,
|
||||
wIndex);
|
||||
rhport = ((__u8)(wIndex & 0x00ff)) - 1;
|
||||
|
||||
dum = hcd_to_vhci(hcd);
|
||||
|
|
@ -286,7 +287,7 @@ static int vhci_hub_control(struct usb_hcd *hcd, u16 typeReq, u16 wValue,
|
|||
spin_lock_irqsave(&dum->lock, flags);
|
||||
|
||||
/* store old status and compare now and old later */
|
||||
if (dbg_flag_vhci_rh) {
|
||||
if (usbip_dbg_flag_vhci_rh) {
|
||||
int i = 0;
|
||||
for (i = 0; i < VHCI_NPORTS; i++)
|
||||
prev_port_status[i] = dum->port_status[i];
|
||||
|
|
@ -294,7 +295,7 @@ static int vhci_hub_control(struct usb_hcd *hcd, u16 typeReq, u16 wValue,
|
|||
|
||||
switch (typeReq) {
|
||||
case ClearHubFeature:
|
||||
dbg_vhci_rh(" ClearHubFeature\n");
|
||||
usbip_dbg_vhci_rh(" ClearHubFeature\n");
|
||||
break;
|
||||
case ClearPortFeature:
|
||||
switch (wValue) {
|
||||
|
|
@ -307,15 +308,16 @@ static int vhci_hub_control(struct usb_hcd *hcd, u16 typeReq, u16 wValue,
|
|||
}
|
||||
break;
|
||||
case USB_PORT_FEAT_POWER:
|
||||
dbg_vhci_rh(" ClearPortFeature: USB_PORT_FEAT_POWER\n");
|
||||
usbip_dbg_vhci_rh(" ClearPortFeature: "
|
||||
"USB_PORT_FEAT_POWER\n");
|
||||
dum->port_status[rhport] = 0;
|
||||
/* dum->address = 0; */
|
||||
/* dum->hdev = 0; */
|
||||
dum->resuming = 0;
|
||||
break;
|
||||
case USB_PORT_FEAT_C_RESET:
|
||||
dbg_vhci_rh(" ClearPortFeature: "
|
||||
"USB_PORT_FEAT_C_RESET\n");
|
||||
usbip_dbg_vhci_rh(" ClearPortFeature: "
|
||||
"USB_PORT_FEAT_C_RESET\n");
|
||||
switch (dum->vdev[rhport].speed) {
|
||||
case USB_SPEED_HIGH:
|
||||
dum->port_status[rhport] |=
|
||||
|
|
@ -329,20 +331,21 @@ static int vhci_hub_control(struct usb_hcd *hcd, u16 typeReq, u16 wValue,
|
|||
break;
|
||||
}
|
||||
default:
|
||||
dbg_vhci_rh(" ClearPortFeature: default %x\n", wValue);
|
||||
usbip_dbg_vhci_rh(" ClearPortFeature: default %x\n",
|
||||
wValue);
|
||||
dum->port_status[rhport] &= ~(1 << wValue);
|
||||
}
|
||||
break;
|
||||
case GetHubDescriptor:
|
||||
dbg_vhci_rh(" GetHubDescriptor\n");
|
||||
usbip_dbg_vhci_rh(" GetHubDescriptor\n");
|
||||
hub_descriptor((struct usb_hub_descriptor *) buf);
|
||||
break;
|
||||
case GetHubStatus:
|
||||
dbg_vhci_rh(" GetHubStatus\n");
|
||||
usbip_dbg_vhci_rh(" GetHubStatus\n");
|
||||
*(__le32 *) buf = __constant_cpu_to_le32(0);
|
||||
break;
|
||||
case GetPortStatus:
|
||||
dbg_vhci_rh(" GetPortStatus port %x\n", wIndex);
|
||||
usbip_dbg_vhci_rh(" GetPortStatus port %x\n", wIndex);
|
||||
if (wIndex > VHCI_NPORTS || wIndex < 1) {
|
||||
printk(KERN_ERR "%s: invalid port number %d\n",
|
||||
__func__, wIndex);
|
||||
|
|
@ -379,7 +382,8 @@ static int vhci_hub_control(struct usb_hcd *hcd, u16 typeReq, u16 wValue,
|
|||
|
||||
if (dum->vdev[rhport].ud.status ==
|
||||
VDEV_ST_NOTASSIGNED) {
|
||||
dbg_vhci_rh(" enable rhport %d (status %u)\n",
|
||||
usbip_dbg_vhci_rh(" enable rhport %d "
|
||||
"(status %u)\n",
|
||||
rhport,
|
||||
dum->vdev[rhport].ud.status);
|
||||
dum->port_status[rhport] |=
|
||||
|
|
@ -415,17 +419,17 @@ static int vhci_hub_control(struct usb_hcd *hcd, u16 typeReq, u16 wValue,
|
|||
((u16 *) buf)[1] =
|
||||
cpu_to_le16(dum->port_status[rhport] >> 16);
|
||||
|
||||
dbg_vhci_rh(" GetPortStatus bye %x %x\n", ((u16 *)buf)[0],
|
||||
usbip_dbg_vhci_rh(" GetPortStatus bye %x %x\n", ((u16 *)buf)[0],
|
||||
((u16 *)buf)[1]);
|
||||
break;
|
||||
case SetHubFeature:
|
||||
dbg_vhci_rh(" SetHubFeature\n");
|
||||
usbip_dbg_vhci_rh(" SetHubFeature\n");
|
||||
retval = -EPIPE;
|
||||
break;
|
||||
case SetPortFeature:
|
||||
switch (wValue) {
|
||||
case USB_PORT_FEAT_SUSPEND:
|
||||
dbg_vhci_rh(" SetPortFeature: "
|
||||
usbip_dbg_vhci_rh(" SetPortFeature: "
|
||||
"USB_PORT_FEAT_SUSPEND\n");
|
||||
printk(KERN_ERR "%s: not yet\n", __func__);
|
||||
#if 0
|
||||
|
|
@ -439,7 +443,8 @@ static int vhci_hub_control(struct usb_hcd *hcd, u16 typeReq, u16 wValue,
|
|||
#endif
|
||||
break;
|
||||
case USB_PORT_FEAT_RESET:
|
||||
dbg_vhci_rh(" SetPortFeature: USB_PORT_FEAT_RESET\n");
|
||||
usbip_dbg_vhci_rh(" SetPortFeature: "
|
||||
"USB_PORT_FEAT_RESET\n");
|
||||
/* if it's already running, disconnect first */
|
||||
if (dum->port_status[rhport] & USB_PORT_STAT_ENABLE) {
|
||||
dum->port_status[rhport] &=
|
||||
|
|
@ -460,7 +465,8 @@ static int vhci_hub_control(struct usb_hcd *hcd, u16 typeReq, u16 wValue,
|
|||
|
||||
/* FALLTHROUGH */
|
||||
default:
|
||||
dbg_vhci_rh(" SetPortFeature: default %d\n", wValue);
|
||||
usbip_dbg_vhci_rh(" SetPortFeature: default %d\n",
|
||||
wValue);
|
||||
dum->port_status[rhport] |= (1 << wValue);
|
||||
}
|
||||
break;
|
||||
|
|
@ -475,12 +481,12 @@ static int vhci_hub_control(struct usb_hcd *hcd, u16 typeReq, u16 wValue,
|
|||
retval = -EPIPE;
|
||||
}
|
||||
|
||||
if (dbg_flag_vhci_rh) {
|
||||
if (usbip_dbg_flag_vhci_rh) {
|
||||
printk(KERN_DEBUG "port %d\n", rhport);
|
||||
dump_port_status(prev_port_status[rhport]);
|
||||
dump_port_status(dum->port_status[rhport]);
|
||||
}
|
||||
dbg_vhci_rh(" bye\n");
|
||||
usbip_dbg_vhci_rh(" bye\n");
|
||||
|
||||
spin_unlock_irqrestore(&dum->lock, flags);
|
||||
|
||||
|
|
@ -517,9 +523,10 @@ static void vhci_tx_urb(struct urb *urb)
|
|||
return;
|
||||
}
|
||||
|
||||
priv = kzalloc(sizeof(struct vhci_priv), GFP_ATOMIC);
|
||||
|
||||
spin_lock_irqsave(&vdev->priv_lock, flag);
|
||||
|
||||
priv = kzalloc(sizeof(struct vhci_priv), GFP_ATOMIC);
|
||||
if (!priv) {
|
||||
dev_err(&urb->dev->dev, "malloc vhci_priv\n");
|
||||
spin_unlock_irqrestore(&vdev->priv_lock, flag);
|
||||
|
|
@ -529,7 +536,7 @@ static void vhci_tx_urb(struct urb *urb)
|
|||
|
||||
priv->seqnum = atomic_inc_return(&the_controller->seqnum);
|
||||
if (priv->seqnum == 0xffff)
|
||||
uinfo("seqnum max\n");
|
||||
usbip_uinfo("seqnum max\n");
|
||||
|
||||
priv->vdev = vdev;
|
||||
priv->urb = urb;
|
||||
|
|
@ -550,7 +557,7 @@ static int vhci_urb_enqueue(struct usb_hcd *hcd, struct urb *urb,
|
|||
int ret = 0;
|
||||
unsigned long flags;
|
||||
|
||||
dbg_vhci_hc("enter, usb_hcd %p urb %p mem_flags %d\n",
|
||||
usbip_dbg_vhci_hc("enter, usb_hcd %p urb %p mem_flags %d\n",
|
||||
hcd, urb, mem_flags);
|
||||
|
||||
/* patch to usb_sg_init() is in 2.5.60 */
|
||||
|
|
@ -558,13 +565,6 @@ static int vhci_urb_enqueue(struct usb_hcd *hcd, struct urb *urb,
|
|||
|
||||
spin_lock_irqsave(&the_controller->lock, flags);
|
||||
|
||||
/* check HC is active or not */
|
||||
if (!HC_IS_RUNNING(hcd->state)) {
|
||||
dev_err(dev, "HC is not running\n");
|
||||
spin_unlock_irqrestore(&the_controller->lock, flags);
|
||||
return -ENODEV;
|
||||
}
|
||||
|
||||
if (urb->status != -EINPROGRESS) {
|
||||
dev_err(dev, "URB already unlinked!, status %d\n", urb->status);
|
||||
spin_unlock_irqrestore(&the_controller->lock, flags);
|
||||
|
|
@ -576,7 +576,7 @@ static int vhci_urb_enqueue(struct usb_hcd *hcd, struct urb *urb,
|
|||
goto no_need_unlink;
|
||||
|
||||
/*
|
||||
* The enumelation process is as follows;
|
||||
* The enumeration process is as follows;
|
||||
*
|
||||
* 1. Get_Descriptor request to DevAddrs(0) EndPoint(0)
|
||||
* to get max packet length of default pipe
|
||||
|
|
@ -620,7 +620,7 @@ static int vhci_urb_enqueue(struct usb_hcd *hcd, struct urb *urb,
|
|||
|
||||
case USB_REQ_GET_DESCRIPTOR:
|
||||
if (ctrlreq->wValue == (USB_DT_DEVICE << 8))
|
||||
dbg_vhci_hc("Not yet?: "
|
||||
usbip_dbg_vhci_hc("Not yet?: "
|
||||
"Get_Descriptor to device 0 "
|
||||
"(get max pipe size)\n");
|
||||
|
||||
|
|
@ -708,7 +708,7 @@ static int vhci_urb_dequeue(struct usb_hcd *hcd, struct urb *urb, int status)
|
|||
struct vhci_priv *priv;
|
||||
struct vhci_device *vdev;
|
||||
|
||||
uinfo("vhci_hcd: dequeue a urb %p\n", urb);
|
||||
usbip_uinfo("vhci_hcd: dequeue a urb %p\n", urb);
|
||||
|
||||
|
||||
spin_lock_irqsave(&the_controller->lock, flags);
|
||||
|
|
@ -726,7 +726,7 @@ static int vhci_urb_dequeue(struct usb_hcd *hcd, struct urb *urb, int status)
|
|||
ret = usb_hcd_check_unlink_urb(hcd, urb, status);
|
||||
if (ret) {
|
||||
spin_unlock_irqrestore(&the_controller->lock, flags);
|
||||
return 0;
|
||||
return ret;
|
||||
}
|
||||
}
|
||||
|
||||
|
|
@ -739,13 +739,29 @@ static int vhci_urb_dequeue(struct usb_hcd *hcd, struct urb *urb, int status)
|
|||
|
||||
spin_lock_irqsave(&vdev->priv_lock, flags2);
|
||||
|
||||
uinfo("vhci_hcd: device %p seems to be disconnected\n", vdev);
|
||||
usbip_uinfo("vhci_hcd: device %p seems to be disconnected\n",
|
||||
vdev);
|
||||
list_del(&priv->list);
|
||||
kfree(priv);
|
||||
urb->hcpriv = NULL;
|
||||
|
||||
spin_unlock_irqrestore(&vdev->priv_lock, flags2);
|
||||
|
||||
/*
|
||||
* If tcp connection is alive, we have sent CMD_UNLINK.
|
||||
* vhci_rx will receive RET_UNLINK and give back the URB.
|
||||
* Otherwise, we give back it here.
|
||||
*/
|
||||
usbip_uinfo("vhci_hcd: vhci_urb_dequeue() gives back urb %p\n",
|
||||
urb);
|
||||
|
||||
usb_hcd_unlink_urb_from_ep(hcd, urb);
|
||||
|
||||
spin_unlock_irqrestore(&the_controller->lock, flags);
|
||||
usb_hcd_giveback_urb(vhci_to_hcd(the_controller), urb,
|
||||
urb->status);
|
||||
spin_lock_irqsave(&the_controller->lock, flags);
|
||||
|
||||
} else {
|
||||
/* tcp connection is alive */
|
||||
unsigned long flags2;
|
||||
|
|
@ -756,7 +772,7 @@ static int vhci_urb_dequeue(struct usb_hcd *hcd, struct urb *urb, int status)
|
|||
/* setup CMD_UNLINK pdu */
|
||||
unlink = kzalloc(sizeof(struct vhci_unlink), GFP_ATOMIC);
|
||||
if (!unlink) {
|
||||
uerr("malloc vhci_unlink\n");
|
||||
usbip_uerr("malloc vhci_unlink\n");
|
||||
spin_unlock_irqrestore(&vdev->priv_lock, flags2);
|
||||
spin_unlock_irqrestore(&the_controller->lock, flags);
|
||||
usbip_event_add(&vdev->ud, VDEV_EVENT_ERROR_MALLOC);
|
||||
|
|
@ -765,11 +781,11 @@ static int vhci_urb_dequeue(struct usb_hcd *hcd, struct urb *urb, int status)
|
|||
|
||||
unlink->seqnum = atomic_inc_return(&the_controller->seqnum);
|
||||
if (unlink->seqnum == 0xffff)
|
||||
uinfo("seqnum max\n");
|
||||
usbip_uinfo("seqnum max\n");
|
||||
|
||||
unlink->unlink_seqnum = priv->seqnum;
|
||||
|
||||
uinfo("vhci_hcd: device %p seems to be still connected\n",
|
||||
usbip_uinfo("vhci_hcd: device %p seems to be still connected\n",
|
||||
vdev);
|
||||
|
||||
/* send cmd_unlink and try to cancel the pending URB in the
|
||||
|
|
@ -781,14 +797,10 @@ static int vhci_urb_dequeue(struct usb_hcd *hcd, struct urb *urb, int status)
|
|||
}
|
||||
|
||||
|
||||
/*
|
||||
* If tcp connection is alive, we have sent CMD_UNLINK.
|
||||
* vhci_rx will receive RET_UNLINK and give back the URB.
|
||||
* Otherwise, we give back it here.
|
||||
*/
|
||||
if (!vdev->ud.tcp_socket) {
|
||||
/* tcp connection is closed */
|
||||
uinfo("vhci_hcd: vhci_urb_dequeue() gives back urb %p\n", urb);
|
||||
usbip_uinfo("vhci_hcd: vhci_urb_dequeue() gives back urb %p\n",
|
||||
urb);
|
||||
|
||||
usb_hcd_unlink_urb_from_ep(hcd, urb);
|
||||
|
||||
|
|
@ -800,7 +812,7 @@ static int vhci_urb_dequeue(struct usb_hcd *hcd, struct urb *urb, int status)
|
|||
|
||||
spin_unlock_irqrestore(&the_controller->lock, flags);
|
||||
|
||||
dbg_vhci_hc("leave\n");
|
||||
usbip_dbg_vhci_hc("leave\n");
|
||||
return 0;
|
||||
}
|
||||
|
||||
|
|
@ -835,19 +847,19 @@ static void vhci_shutdown_connection(struct usbip_device *ud)
|
|||
|
||||
/* need this? see stub_dev.c */
|
||||
if (ud->tcp_socket) {
|
||||
udbg("shutdown tcp_socket %p\n", ud->tcp_socket);
|
||||
usbip_udbg("shutdown tcp_socket %p\n", ud->tcp_socket);
|
||||
kernel_sock_shutdown(ud->tcp_socket, SHUT_RDWR);
|
||||
}
|
||||
|
||||
usbip_stop_threads(&vdev->ud);
|
||||
uinfo("stop threads\n");
|
||||
usbip_uinfo("stop threads\n");
|
||||
|
||||
/* active connection is closed */
|
||||
if (vdev->ud.tcp_socket != NULL) {
|
||||
sock_release(vdev->ud.tcp_socket);
|
||||
vdev->ud.tcp_socket = NULL;
|
||||
}
|
||||
uinfo("release socket\n");
|
||||
usbip_uinfo("release socket\n");
|
||||
|
||||
vhci_device_unlink_cleanup(vdev);
|
||||
|
||||
|
|
@ -873,7 +885,7 @@ static void vhci_shutdown_connection(struct usbip_device *ud)
|
|||
*/
|
||||
rh_port_disconnect(vdev->rhport);
|
||||
|
||||
uinfo("disconnect device\n");
|
||||
usbip_uinfo("disconnect device\n");
|
||||
}
|
||||
|
||||
|
||||
|
|
@ -939,7 +951,7 @@ static int vhci_start(struct usb_hcd *hcd)
|
|||
int rhport;
|
||||
int err = 0;
|
||||
|
||||
dbg_vhci_hc("enter vhci_start\n");
|
||||
usbip_dbg_vhci_hc("enter vhci_start\n");
|
||||
|
||||
|
||||
/* initialize private data of usb_hcd */
|
||||
|
|
@ -963,7 +975,7 @@ static int vhci_start(struct usb_hcd *hcd)
|
|||
/* vhci_hcd is now ready to be controlled through sysfs */
|
||||
err = sysfs_create_group(&vhci_dev(vhci)->kobj, &dev_attr_group);
|
||||
if (err) {
|
||||
uerr("create sysfs files\n");
|
||||
usbip_uerr("create sysfs files\n");
|
||||
return err;
|
||||
}
|
||||
|
||||
|
|
@ -975,7 +987,7 @@ static void vhci_stop(struct usb_hcd *hcd)
|
|||
struct vhci_hcd *vhci = hcd_to_vhci(hcd);
|
||||
int rhport = 0;
|
||||
|
||||
dbg_vhci_hc("stop VHCI controller\n");
|
||||
usbip_dbg_vhci_hc("stop VHCI controller\n");
|
||||
|
||||
|
||||
/* 1. remove the userland interface of vhci_hcd */
|
||||
|
|
@ -990,14 +1002,14 @@ static void vhci_stop(struct usb_hcd *hcd)
|
|||
}
|
||||
|
||||
|
||||
uinfo("vhci_stop done\n");
|
||||
usbip_uinfo("vhci_stop done\n");
|
||||
}
|
||||
|
||||
/*----------------------------------------------------------------------*/
|
||||
|
||||
static int vhci_get_frame_number(struct usb_hcd *hcd)
|
||||
{
|
||||
uerr("Not yet implemented\n");
|
||||
usbip_uerr("Not yet implemented\n");
|
||||
return 0;
|
||||
}
|
||||
|
||||
|
|
@ -1077,9 +1089,9 @@ static int vhci_hcd_probe(struct platform_device *pdev)
|
|||
struct usb_hcd *hcd;
|
||||
int ret;
|
||||
|
||||
uinfo("proving...\n");
|
||||
usbip_uinfo("proving...\n");
|
||||
|
||||
dbg_vhci_hc("name %s id %d\n", pdev->name, pdev->id);
|
||||
usbip_dbg_vhci_hc("name %s id %d\n", pdev->name, pdev->id);
|
||||
|
||||
/* will be removed */
|
||||
if (pdev->dev.dma_mask) {
|
||||
|
|
@ -1093,7 +1105,7 @@ static int vhci_hcd_probe(struct platform_device *pdev)
|
|||
*/
|
||||
hcd = usb_create_hcd(&vhci_hc_driver, &pdev->dev, dev_name(&pdev->dev));
|
||||
if (!hcd) {
|
||||
uerr("create hcd failed\n");
|
||||
usbip_uerr("create hcd failed\n");
|
||||
return -ENOMEM;
|
||||
}
|
||||
|
||||
|
|
@ -1107,14 +1119,14 @@ static int vhci_hcd_probe(struct platform_device *pdev)
|
|||
*/
|
||||
ret = usb_add_hcd(hcd, 0, 0);
|
||||
if (ret != 0) {
|
||||
uerr("usb_add_hcd failed %d\n", ret);
|
||||
usbip_uerr("usb_add_hcd failed %d\n", ret);
|
||||
usb_put_hcd(hcd);
|
||||
the_controller = NULL;
|
||||
return ret;
|
||||
}
|
||||
|
||||
|
||||
dbg_vhci_hc("bye\n");
|
||||
usbip_dbg_vhci_hc("bye\n");
|
||||
return 0;
|
||||
}
|
||||
|
||||
|
|
@ -1166,11 +1178,11 @@ static int vhci_hcd_suspend(struct platform_device *pdev, pm_message_t state)
|
|||
spin_unlock(&the_controller->lock);
|
||||
|
||||
if (connected > 0) {
|
||||
uinfo("We have %d active connection%s. Do not suspend.\n",
|
||||
usbip_uinfo("We have %d active connection%s. Do not suspend.\n",
|
||||
connected, (connected == 1 ? "" : "s"));
|
||||
ret = -EBUSY;
|
||||
} else {
|
||||
uinfo("suspend vhci_hcd");
|
||||
usbip_uinfo("suspend vhci_hcd");
|
||||
clear_bit(HCD_FLAG_HW_ACCESSIBLE, &hcd->flags);
|
||||
}
|
||||
|
||||
|
|
@ -1235,7 +1247,7 @@ static int __init vhci_init(void)
|
|||
{
|
||||
int ret;
|
||||
|
||||
dbg_vhci_hc("enter\n");
|
||||
usbip_dbg_vhci_hc("enter\n");
|
||||
if (usb_disabled())
|
||||
return -ENODEV;
|
||||
|
||||
|
|
@ -1250,7 +1262,7 @@ static int __init vhci_init(void)
|
|||
if (ret < 0)
|
||||
goto err_platform_device_register;
|
||||
|
||||
dbg_vhci_hc("bye\n");
|
||||
usbip_dbg_vhci_hc("bye\n");
|
||||
return ret;
|
||||
|
||||
/* error occurred */
|
||||
|
|
@ -1258,18 +1270,18 @@ err_platform_device_register:
|
|||
platform_driver_unregister(&vhci_driver);
|
||||
|
||||
err_driver_register:
|
||||
dbg_vhci_hc("bye\n");
|
||||
usbip_dbg_vhci_hc("bye\n");
|
||||
return ret;
|
||||
}
|
||||
module_init(vhci_init);
|
||||
|
||||
static void __exit vhci_cleanup(void)
|
||||
{
|
||||
dbg_vhci_hc("enter\n");
|
||||
usbip_dbg_vhci_hc("enter\n");
|
||||
|
||||
platform_device_unregister(&the_pdev);
|
||||
platform_driver_unregister(&vhci_driver);
|
||||
|
||||
dbg_vhci_hc("bye\n");
|
||||
usbip_dbg_vhci_hc("bye\n");
|
||||
}
|
||||
module_exit(vhci_cleanup);
|
||||
|
|
|
|||
|
|
@ -36,7 +36,7 @@ static struct urb *pickup_urb_and_free_priv(struct vhci_device *vdev,
|
|||
urb = priv->urb;
|
||||
status = urb->status;
|
||||
|
||||
dbg_vhci_rx("find urb %p vurb %p seqnum %u\n",
|
||||
usbip_dbg_vhci_rx("find urb %p vurb %p seqnum %u\n",
|
||||
urb, priv, seqnum);
|
||||
|
||||
/* TODO: fix logic here to improve indent situtation */
|
||||
|
|
@ -77,8 +77,10 @@ static void vhci_recv_ret_submit(struct vhci_device *vdev,
|
|||
|
||||
|
||||
if (!urb) {
|
||||
uerr("cannot find a urb of seqnum %u\n", pdu->base.seqnum);
|
||||
uinfo("max seqnum %d\n", atomic_read(&the_controller->seqnum));
|
||||
usbip_uerr("cannot find a urb of seqnum %u\n",
|
||||
pdu->base.seqnum);
|
||||
usbip_uinfo("max seqnum %d\n",
|
||||
atomic_read(&the_controller->seqnum));
|
||||
usbip_event_add(ud, VDEV_EVENT_ERROR_TCP);
|
||||
return;
|
||||
}
|
||||
|
|
@ -98,11 +100,11 @@ static void vhci_recv_ret_submit(struct vhci_device *vdev,
|
|||
return;
|
||||
|
||||
|
||||
if (dbg_flag_vhci_rx)
|
||||
if (usbip_dbg_flag_vhci_rx)
|
||||
usbip_dump_urb(urb);
|
||||
|
||||
|
||||
dbg_vhci_rx("now giveback urb %p\n", urb);
|
||||
usbip_dbg_vhci_rx("now giveback urb %p\n", urb);
|
||||
|
||||
spin_lock(&the_controller->lock);
|
||||
usb_hcd_unlink_urb_from_ep(vhci_to_hcd(the_controller), urb);
|
||||
|
|
@ -111,7 +113,7 @@ static void vhci_recv_ret_submit(struct vhci_device *vdev,
|
|||
usb_hcd_giveback_urb(vhci_to_hcd(the_controller), urb, urb->status);
|
||||
|
||||
|
||||
dbg_vhci_rx("Leave\n");
|
||||
usbip_dbg_vhci_rx("Leave\n");
|
||||
|
||||
return;
|
||||
}
|
||||
|
|
@ -125,9 +127,9 @@ static struct vhci_unlink *dequeue_pending_unlink(struct vhci_device *vdev,
|
|||
spin_lock(&vdev->priv_lock);
|
||||
|
||||
list_for_each_entry_safe(unlink, tmp, &vdev->unlink_rx, list) {
|
||||
uinfo("unlink->seqnum %lu\n", unlink->seqnum);
|
||||
usbip_uinfo("unlink->seqnum %lu\n", unlink->seqnum);
|
||||
if (unlink->seqnum == pdu->base.seqnum) {
|
||||
dbg_vhci_rx("found pending unlink, %lu\n",
|
||||
usbip_dbg_vhci_rx("found pending unlink, %lu\n",
|
||||
unlink->seqnum);
|
||||
list_del(&unlink->list);
|
||||
|
||||
|
|
@ -152,7 +154,8 @@ static void vhci_recv_ret_unlink(struct vhci_device *vdev,
|
|||
|
||||
unlink = dequeue_pending_unlink(vdev, pdu);
|
||||
if (!unlink) {
|
||||
uinfo("cannot find the pending unlink %u\n", pdu->base.seqnum);
|
||||
usbip_uinfo("cannot find the pending unlink %u\n",
|
||||
pdu->base.seqnum);
|
||||
return;
|
||||
}
|
||||
|
||||
|
|
@ -163,14 +166,14 @@ static void vhci_recv_ret_unlink(struct vhci_device *vdev,
|
|||
* already received the result of its submit result and gave
|
||||
* back the URB.
|
||||
*/
|
||||
uinfo("the urb (seqnum %d) was already given backed\n",
|
||||
usbip_uinfo("the urb (seqnum %d) was already given backed\n",
|
||||
pdu->base.seqnum);
|
||||
} else {
|
||||
dbg_vhci_rx("now giveback urb %p\n", urb);
|
||||
usbip_dbg_vhci_rx("now giveback urb %p\n", urb);
|
||||
|
||||
/* If unlink is succeed, status is -ECONNRESET */
|
||||
urb->status = pdu->u.ret_unlink.status;
|
||||
uinfo("%d\n", urb->status);
|
||||
usbip_uinfo("%d\n", urb->status);
|
||||
|
||||
spin_lock(&the_controller->lock);
|
||||
usb_hcd_unlink_urb_from_ep(vhci_to_hcd(the_controller), urb);
|
||||
|
|
@ -193,7 +196,7 @@ static void vhci_rx_pdu(struct usbip_device *ud)
|
|||
struct vhci_device *vdev = container_of(ud, struct vhci_device, ud);
|
||||
|
||||
|
||||
dbg_vhci_rx("Enter\n");
|
||||
usbip_dbg_vhci_rx("Enter\n");
|
||||
|
||||
memset(&pdu, 0, sizeof(pdu));
|
||||
|
||||
|
|
@ -201,15 +204,15 @@ static void vhci_rx_pdu(struct usbip_device *ud)
|
|||
/* 1. receive a pdu header */
|
||||
ret = usbip_xmit(0, ud->tcp_socket, (char *) &pdu, sizeof(pdu), 0);
|
||||
if (ret != sizeof(pdu)) {
|
||||
uerr("receiving pdu failed! size is %d, should be %d\n",
|
||||
ret, (unsigned int)sizeof(pdu));
|
||||
usbip_uerr("receiving pdu failed! size is %d, should be %d\n",
|
||||
ret, (unsigned int)sizeof(pdu));
|
||||
usbip_event_add(ud, VDEV_EVENT_ERROR_TCP);
|
||||
return;
|
||||
}
|
||||
|
||||
usbip_header_correct_endian(&pdu, 0);
|
||||
|
||||
if (dbg_flag_vhci_rx)
|
||||
if (usbip_dbg_flag_vhci_rx)
|
||||
usbip_dump_header(&pdu);
|
||||
|
||||
switch (pdu.base.command) {
|
||||
|
|
@ -221,7 +224,7 @@ static void vhci_rx_pdu(struct usbip_device *ud)
|
|||
break;
|
||||
default:
|
||||
/* NOTREACHED */
|
||||
uerr("unknown pdu %u\n", pdu.base.command);
|
||||
usbip_uerr("unknown pdu %u\n", pdu.base.command);
|
||||
usbip_dump_header(&pdu);
|
||||
usbip_event_add(ud, VDEV_EVENT_ERROR_TCP);
|
||||
}
|
||||
|
|
@ -237,12 +240,12 @@ void vhci_rx_loop(struct usbip_task *ut)
|
|||
|
||||
while (1) {
|
||||
if (signal_pending(current)) {
|
||||
dbg_vhci_rx("signal catched!\n");
|
||||
usbip_dbg_vhci_rx("signal catched!\n");
|
||||
break;
|
||||
}
|
||||
|
||||
|
||||
if (usbip_event_happend(ud))
|
||||
if (usbip_event_happened(ud))
|
||||
break;
|
||||
|
||||
vhci_rx_pdu(ud);
|
||||
|
|
|
|||
|
|
@ -80,7 +80,7 @@ static int vhci_port_disconnect(__u32 rhport)
|
|||
{
|
||||
struct vhci_device *vdev;
|
||||
|
||||
dbg_vhci_sysfs("enter\n");
|
||||
usbip_dbg_vhci_sysfs("enter\n");
|
||||
|
||||
/* lock */
|
||||
spin_lock(&the_controller->lock);
|
||||
|
|
@ -89,7 +89,7 @@ static int vhci_port_disconnect(__u32 rhport)
|
|||
|
||||
spin_lock(&vdev->ud.lock);
|
||||
if (vdev->ud.status == VDEV_ST_NULL) {
|
||||
uerr("not connected %d\n", vdev->ud.status);
|
||||
usbip_uerr("not connected %d\n", vdev->ud.status);
|
||||
|
||||
/* unlock */
|
||||
spin_unlock(&vdev->ud.lock);
|
||||
|
|
@ -117,7 +117,7 @@ static ssize_t store_detach(struct device *dev, struct device_attribute *attr,
|
|||
|
||||
/* check rhport */
|
||||
if (rhport >= VHCI_NPORTS) {
|
||||
uerr("invalid port %u\n", rhport);
|
||||
usbip_uerr("invalid port %u\n", rhport);
|
||||
return -EINVAL;
|
||||
}
|
||||
|
||||
|
|
@ -125,7 +125,7 @@ static ssize_t store_detach(struct device *dev, struct device_attribute *attr,
|
|||
if (err < 0)
|
||||
return -EINVAL;
|
||||
|
||||
dbg_vhci_sysfs("Leave\n");
|
||||
usbip_dbg_vhci_sysfs("Leave\n");
|
||||
return count;
|
||||
}
|
||||
static DEVICE_ATTR(detach, S_IWUSR, NULL, store_detach);
|
||||
|
|
@ -135,7 +135,7 @@ static int valid_args(__u32 rhport, enum usb_device_speed speed)
|
|||
{
|
||||
/* check rhport */
|
||||
if ((rhport < 0) || (rhport >= VHCI_NPORTS)) {
|
||||
uerr("port %u\n", rhport);
|
||||
usbip_uerr("port %u\n", rhport);
|
||||
return -EINVAL;
|
||||
}
|
||||
|
||||
|
|
@ -147,7 +147,7 @@ static int valid_args(__u32 rhport, enum usb_device_speed speed)
|
|||
case USB_SPEED_VARIABLE:
|
||||
break;
|
||||
default:
|
||||
uerr("speed %d\n", speed);
|
||||
usbip_uerr("speed %d\n", speed);
|
||||
return -EINVAL;
|
||||
}
|
||||
|
||||
|
|
@ -181,8 +181,8 @@ static ssize_t store_attach(struct device *dev, struct device_attribute *attr,
|
|||
*/
|
||||
sscanf(buf, "%u %u %u %u", &rhport, &sockfd, &devid, &speed);
|
||||
|
||||
dbg_vhci_sysfs("rhport(%u) sockfd(%u) devid(%u) speed(%u)\n",
|
||||
rhport, sockfd, devid, speed);
|
||||
usbip_dbg_vhci_sysfs("rhport(%u) sockfd(%u) devid(%u) speed(%u)\n",
|
||||
rhport, sockfd, devid, speed);
|
||||
|
||||
|
||||
/* check received parameters */
|
||||
|
|
@ -208,12 +208,12 @@ static ssize_t store_attach(struct device *dev, struct device_attribute *attr,
|
|||
spin_unlock(&vdev->ud.lock);
|
||||
spin_unlock(&the_controller->lock);
|
||||
|
||||
uerr("port %d already used\n", rhport);
|
||||
usbip_uerr("port %d already used\n", rhport);
|
||||
return -EINVAL;
|
||||
}
|
||||
|
||||
uinfo("rhport(%u) sockfd(%d) devid(%u) speed(%u)\n",
|
||||
rhport, sockfd, devid, speed);
|
||||
usbip_uinfo("rhport(%u) sockfd(%d) devid(%u) speed(%u)\n",
|
||||
rhport, sockfd, devid, speed);
|
||||
|
||||
vdev->devid = devid;
|
||||
vdev->speed = speed;
|
||||
|
|
|
|||
|
|
@ -26,7 +26,7 @@ static void setup_cmd_submit_pdu(struct usbip_header *pdup, struct urb *urb)
|
|||
struct vhci_priv *priv = ((struct vhci_priv *)urb->hcpriv);
|
||||
struct vhci_device *vdev = priv->vdev;
|
||||
|
||||
dbg_vhci_tx("URB, local devnum %u, remote devid %u\n",
|
||||
usbip_dbg_vhci_tx("URB, local devnum %u, remote devid %u\n",
|
||||
usb_pipedevice(urb->pipe), vdev->devid);
|
||||
|
||||
pdup->base.command = USBIP_CMD_SUBMIT;
|
||||
|
|
@ -85,7 +85,7 @@ static int vhci_send_cmd_submit(struct vhci_device *vdev)
|
|||
memset(&msg, 0, sizeof(msg));
|
||||
memset(&iov, 0, sizeof(iov));
|
||||
|
||||
dbg_vhci_tx("setup txdata urb %p\n", urb);
|
||||
usbip_dbg_vhci_tx("setup txdata urb %p\n", urb);
|
||||
|
||||
|
||||
/* 1. setup usbip_header */
|
||||
|
|
@ -121,15 +121,15 @@ static int vhci_send_cmd_submit(struct vhci_device *vdev)
|
|||
|
||||
ret = kernel_sendmsg(vdev->ud.tcp_socket, &msg, iov, 3, txsize);
|
||||
if (ret != txsize) {
|
||||
uerr("sendmsg failed!, retval %d for %zd\n", ret,
|
||||
txsize);
|
||||
usbip_uerr("sendmsg failed!, retval %d for %zd\n", ret,
|
||||
txsize);
|
||||
kfree(iso_buffer);
|
||||
usbip_event_add(&vdev->ud, VDEV_EVENT_ERROR_TCP);
|
||||
return -1;
|
||||
}
|
||||
|
||||
kfree(iso_buffer);
|
||||
dbg_vhci_tx("send txdata\n");
|
||||
usbip_dbg_vhci_tx("send txdata\n");
|
||||
|
||||
total_size += txsize;
|
||||
}
|
||||
|
|
@ -177,7 +177,7 @@ static int vhci_send_cmd_unlink(struct vhci_device *vdev)
|
|||
memset(&msg, 0, sizeof(msg));
|
||||
memset(&iov, 0, sizeof(iov));
|
||||
|
||||
dbg_vhci_tx("setup cmd unlink, %lu \n", unlink->seqnum);
|
||||
usbip_dbg_vhci_tx("setup cmd unlink, %lu \n", unlink->seqnum);
|
||||
|
||||
|
||||
/* 1. setup usbip_header */
|
||||
|
|
@ -195,14 +195,14 @@ static int vhci_send_cmd_unlink(struct vhci_device *vdev)
|
|||
|
||||
ret = kernel_sendmsg(vdev->ud.tcp_socket, &msg, iov, 1, txsize);
|
||||
if (ret != txsize) {
|
||||
uerr("sendmsg failed!, retval %d for %zd\n", ret,
|
||||
txsize);
|
||||
usbip_uerr("sendmsg failed!, retval %d for %zd\n", ret,
|
||||
txsize);
|
||||
usbip_event_add(&vdev->ud, VDEV_EVENT_ERROR_TCP);
|
||||
return -1;
|
||||
}
|
||||
|
||||
|
||||
dbg_vhci_tx("send txdata\n");
|
||||
usbip_dbg_vhci_tx("send txdata\n");
|
||||
|
||||
total_size += txsize;
|
||||
}
|
||||
|
|
@ -220,7 +220,7 @@ void vhci_tx_loop(struct usbip_task *ut)
|
|||
|
||||
while (1) {
|
||||
if (signal_pending(current)) {
|
||||
uinfo("vhci_tx signal catched\n");
|
||||
usbip_uinfo("vhci_tx signal catched\n");
|
||||
break;
|
||||
}
|
||||
|
||||
|
|
@ -234,6 +234,6 @@ void vhci_tx_loop(struct usbip_task *ut)
|
|||
(!list_empty(&vdev->priv_tx) ||
|
||||
!list_empty(&vdev->unlink_tx)));
|
||||
|
||||
dbg_vhci_tx("pending urbs ?, now wake up\n");
|
||||
usbip_dbg_vhci_tx("pending urbs ?, now wake up\n");
|
||||
}
|
||||
}
|
||||
|
|
|
|||
Loading…
Reference in a new issue