1 /* 2 * Copyright (C) 2003-2008 Takahiro Hirofuchi 3 * 4 * This is free software; you can redistribute it and/or modify 5 * it under the terms of the GNU General Public License as published by 6 * the Free Software Foundation; either version 2 of the License, or 7 * (at your option) any later version. 8 * 9 * This is distributed in the hope that it will be useful, 10 * but WITHOUT ANY WARRANTY; without even the implied warranty of 11 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 12 * GNU General Public License for more details. 13 * 14 * You should have received a copy of the GNU General Public License 15 * along with this program; if not, write to the Free Software 16 * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, 17 * USA. 18 */ 19 20 #include <linux/kthread.h> 21 #include <linux/slab.h> 22 23 #include "usbip_common.h" 24 #include "vhci.h" 25 26 static void setup_cmd_submit_pdu(struct usbip_header *pdup, struct urb *urb) 27 { 28 struct vhci_priv *priv = ((struct vhci_priv *)urb->hcpriv); 29 struct vhci_device *vdev = priv->vdev; 30 31 usbip_dbg_vhci_tx("URB, local devnum %u, remote devid %u\n", 32 usb_pipedevice(urb->pipe), vdev->devid); 33 34 pdup->base.command = USBIP_CMD_SUBMIT; 35 pdup->base.seqnum = priv->seqnum; 36 pdup->base.devid = vdev->devid; 37 pdup->base.direction = usb_pipein(urb->pipe) ? 38 USBIP_DIR_IN : USBIP_DIR_OUT; 39 pdup->base.ep = usb_pipeendpoint(urb->pipe); 40 41 usbip_pack_pdu(pdup, urb, USBIP_CMD_SUBMIT, 1); 42 43 if (urb->setup_packet) 44 memcpy(pdup->u.cmd_submit.setup, urb->setup_packet, 8); 45 } 46 47 static struct vhci_priv *dequeue_from_priv_tx(struct vhci_device *vdev) 48 { 49 struct vhci_priv *priv, *tmp; 50 unsigned long flags; 51 52 spin_lock_irqsave(&vdev->priv_lock, flags); 53 54 list_for_each_entry_safe(priv, tmp, &vdev->priv_tx, list) { 55 list_move_tail(&priv->list, &vdev->priv_rx); 56 spin_unlock_irqrestore(&vdev->priv_lock, flags); 57 return priv; 58 } 59 60 spin_unlock_irqrestore(&vdev->priv_lock, flags); 61 62 return NULL; 63 } 64 65 static int vhci_send_cmd_submit(struct vhci_device *vdev) 66 { 67 struct vhci_priv *priv = NULL; 68 69 struct msghdr msg; 70 struct kvec iov[3]; 71 size_t txsize; 72 73 size_t total_size = 0; 74 75 while ((priv = dequeue_from_priv_tx(vdev)) != NULL) { 76 int ret; 77 struct urb *urb = priv->urb; 78 struct usbip_header pdu_header; 79 struct usbip_iso_packet_descriptor *iso_buffer = NULL; 80 81 txsize = 0; 82 memset(&pdu_header, 0, sizeof(pdu_header)); 83 memset(&msg, 0, sizeof(msg)); 84 memset(&iov, 0, sizeof(iov)); 85 86 usbip_dbg_vhci_tx("setup txdata urb %p\n", urb); 87 88 /* 1. setup usbip_header */ 89 setup_cmd_submit_pdu(&pdu_header, urb); 90 usbip_header_correct_endian(&pdu_header, 1); 91 92 iov[0].iov_base = &pdu_header; 93 iov[0].iov_len = sizeof(pdu_header); 94 txsize += sizeof(pdu_header); 95 96 /* 2. setup transfer buffer */ 97 if (!usb_pipein(urb->pipe) && urb->transfer_buffer_length > 0) { 98 iov[1].iov_base = urb->transfer_buffer; 99 iov[1].iov_len = urb->transfer_buffer_length; 100 txsize += urb->transfer_buffer_length; 101 } 102 103 /* 3. setup iso_packet_descriptor */ 104 if (usb_pipetype(urb->pipe) == PIPE_ISOCHRONOUS) { 105 ssize_t len = 0; 106 107 iso_buffer = usbip_alloc_iso_desc_pdu(urb, &len); 108 if (!iso_buffer) { 109 usbip_event_add(&vdev->ud, 110 SDEV_EVENT_ERROR_MALLOC); 111 return -1; 112 } 113 114 iov[2].iov_base = iso_buffer; 115 iov[2].iov_len = len; 116 txsize += len; 117 } 118 119 ret = kernel_sendmsg(vdev->ud.tcp_socket, &msg, iov, 3, txsize); 120 if (ret != txsize) { 121 pr_err("sendmsg failed!, ret=%d for %zd\n", ret, 122 txsize); 123 kfree(iso_buffer); 124 usbip_event_add(&vdev->ud, VDEV_EVENT_ERROR_TCP); 125 return -1; 126 } 127 128 kfree(iso_buffer); 129 usbip_dbg_vhci_tx("send txdata\n"); 130 131 total_size += txsize; 132 } 133 134 return total_size; 135 } 136 137 static struct vhci_unlink *dequeue_from_unlink_tx(struct vhci_device *vdev) 138 { 139 struct vhci_unlink *unlink, *tmp; 140 unsigned long flags; 141 142 spin_lock_irqsave(&vdev->priv_lock, flags); 143 144 list_for_each_entry_safe(unlink, tmp, &vdev->unlink_tx, list) { 145 list_move_tail(&unlink->list, &vdev->unlink_rx); 146 spin_unlock_irqrestore(&vdev->priv_lock, flags); 147 return unlink; 148 } 149 150 spin_unlock_irqrestore(&vdev->priv_lock, flags); 151 152 return NULL; 153 } 154 155 static int vhci_send_cmd_unlink(struct vhci_device *vdev) 156 { 157 struct vhci_unlink *unlink = NULL; 158 159 struct msghdr msg; 160 struct kvec iov[3]; 161 size_t txsize; 162 163 size_t total_size = 0; 164 165 while ((unlink = dequeue_from_unlink_tx(vdev)) != NULL) { 166 int ret; 167 struct usbip_header pdu_header; 168 169 txsize = 0; 170 memset(&pdu_header, 0, sizeof(pdu_header)); 171 memset(&msg, 0, sizeof(msg)); 172 memset(&iov, 0, sizeof(iov)); 173 174 usbip_dbg_vhci_tx("setup cmd unlink, %lu\n", unlink->seqnum); 175 176 /* 1. setup usbip_header */ 177 pdu_header.base.command = USBIP_CMD_UNLINK; 178 pdu_header.base.seqnum = unlink->seqnum; 179 pdu_header.base.devid = vdev->devid; 180 pdu_header.base.ep = 0; 181 pdu_header.u.cmd_unlink.seqnum = unlink->unlink_seqnum; 182 183 usbip_header_correct_endian(&pdu_header, 1); 184 185 iov[0].iov_base = &pdu_header; 186 iov[0].iov_len = sizeof(pdu_header); 187 txsize += sizeof(pdu_header); 188 189 ret = kernel_sendmsg(vdev->ud.tcp_socket, &msg, iov, 1, txsize); 190 if (ret != txsize) { 191 pr_err("sendmsg failed!, ret=%d for %zd\n", ret, 192 txsize); 193 usbip_event_add(&vdev->ud, VDEV_EVENT_ERROR_TCP); 194 return -1; 195 } 196 197 usbip_dbg_vhci_tx("send txdata\n"); 198 199 total_size += txsize; 200 } 201 202 return total_size; 203 } 204 205 int vhci_tx_loop(void *data) 206 { 207 struct usbip_device *ud = data; 208 struct vhci_device *vdev = container_of(ud, struct vhci_device, ud); 209 210 while (!kthread_should_stop()) { 211 if (vhci_send_cmd_submit(vdev) < 0) 212 break; 213 214 if (vhci_send_cmd_unlink(vdev) < 0) 215 break; 216 217 wait_event_interruptible(vdev->waitq_tx, 218 (!list_empty(&vdev->priv_tx) || 219 !list_empty(&vdev->unlink_tx) || 220 kthread_should_stop())); 221 222 usbip_dbg_vhci_tx("pending urbs ?, now wake up\n"); 223 } 224 225 return 0; 226 } 227