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.
* 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);
}
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");
usbip_start_eh(&sdev->ud);
- udbg("register new interface\n");
+ usbip_udbg("register new interface\n");
return sdev;
}
return -EINVAL;
kfree(sdev);
- udbg("kfree udev ok\n");
+ usbip_udbg("kfree udev ok\n");
return 0;
}
}
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;
}
{
struct stub_device *sdev = usb_get_intfdata(interface);
- udbg("Enter\n");
+ usbip_udbg("Enter\n");
/* get stub_device */
if (!sdev) {
stub_device_free(sdev);
- udbg("bye\n");
+ usbip_udbg("bye\n");
}
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
{
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);
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;
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;
}
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);
* 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); */
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);
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");
}
/*
}
}
- 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
epnum = (ep->desc.bEndpointAddress & 0x7f);
if (epnum == epnum0) {
- /* uinfo("found epnum %d\n", epnum0); */
+ /* usbip_uinfo("found epnum %d\n", epnum0);*/
found = 1;
break;
}
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);
usbip_event_add(ud, SDEV_EVENT_ERROR_SUBMIT);
}
- dbg_stub_rx("Leave\n");
+ usbip_dbg_stub_rx("Leave\n");
return;
}
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));
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)) {
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);
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) {
/* 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. */
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 */
}
kfree(iso_buffer);
- dbg_stub_tx("send txdata\n");
+ usbip_dbg_stub_tx("send txdata\n");
total_size += txsize;
}
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);
}
- dbg_stub_tx("send txdata\n");
+ usbip_dbg_stub_tx("send txdata\n");
total_size += txsize;
}
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;
/*
#include <linux/file.h>
#include <linux/tcp.h>
#include <linux/in.h>
+#include <linux/kthread.h>
#include "usbip_common.h"
/* version information */
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");
}
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");
}
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);
{
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)
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);
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,
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,
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);
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);
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);
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",
}
- 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);
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;
} 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;
/* 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;
}
/* 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;
}
usbip_pack_iso(iso, &urb->iso_frame_desc[i], 0);
}
-
kfree(buff);
return ret;
*/
/**
- * 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 */
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 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 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_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 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 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),\
} 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)
#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)
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);
/* 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
*/
#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.
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);
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);
}
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);
{
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);
{
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); */
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;
}
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);
* 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);
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];
switch (typeReq) {
case ClearHubFeature:
- dbg_vhci_rh(" ClearHubFeature\n");
+ usbip_dbg_vhci_rh(" ClearHubFeature\n");
break;
case ClearPortFeature:
switch (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] |=
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);
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] |=
((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
#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] &=
/* 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;
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);
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);
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;
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 */
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);
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
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");
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);
ret = usb_hcd_check_unlink_urb(hcd, urb, status);
if (ret) {
spin_unlock_irqrestore(&the_controller->lock, flags);
- return 0;
+ return ret;
}
}
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;
/* 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);
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
}
- /*
- * 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);
spin_unlock_irqrestore(&the_controller->lock, flags);
- dbg_vhci_hc("leave\n");
+ usbip_dbg_vhci_hc("leave\n");
return 0;
}
/* 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);
*/
rh_port_disconnect(vdev->rhport);
- uinfo("disconnect device\n");
+ usbip_uinfo("disconnect device\n");
}
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 */
/* 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;
}
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 */
}
- 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;
}
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) {
*/
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;
}
*/
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;
}
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);
}
{
int ret;
- dbg_vhci_hc("enter\n");
+ usbip_dbg_vhci_hc("enter\n");
if (usb_disabled())
return -ENODEV;
if (ret < 0)
goto err_platform_device_register;
- dbg_vhci_hc("bye\n");
+ usbip_dbg_vhci_hc("bye\n");
return ret;
/* error occurred */
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);
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 */
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;
}
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);
usb_hcd_giveback_urb(vhci_to_hcd(the_controller), urb, urb->status);
- dbg_vhci_rx("Leave\n");
+ usbip_dbg_vhci_rx("Leave\n");
return;
}
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);
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;
}
* 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);
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));
/* 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) {
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);
}
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);
{
struct vhci_device *vdev;
- dbg_vhci_sysfs("enter\n");
+ usbip_dbg_vhci_sysfs("enter\n");
/* lock */
spin_lock(&the_controller->lock);
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);
/* check rhport */
if (rhport >= VHCI_NPORTS) {
- uerr("invalid port %u\n", rhport);
+ usbip_uerr("invalid port %u\n", rhport);
return -EINVAL;
}
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);
{
/* check rhport */
if ((rhport < 0) || (rhport >= VHCI_NPORTS)) {
- uerr("port %u\n", rhport);
+ usbip_uerr("port %u\n", rhport);
return -EINVAL;
}
case USB_SPEED_VARIABLE:
break;
default:
- uerr("speed %d\n", speed);
+ usbip_uerr("speed %d\n", speed);
return -EINVAL;
}
*/
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 */
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;
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;
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 */
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;
}
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 */
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;
}
while (1) {
if (signal_pending(current)) {
- uinfo("vhci_tx signal catched\n");
+ usbip_uinfo("vhci_tx signal catched\n");
break;
}
(!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");
}
}
projects / openwrt / staging / blogic.git / commitdiff