1 /* 2 * Copyright (C) 2015 Karol Kosik <karo9@interia.eu> 3 * Copyright (C) 2015-2016 Samsung Electronics 4 * Igor Kotrasinski <i.kotrasinsk@samsung.com> 5 * 6 * This program is free software; you can redistribute it and/or modify 7 * it under the terms of the GNU General Public License as published by 8 * the Free Software Foundation; either version 2 of the License, or 9 * (at your option) any later version. 10 * 11 * This program is distributed in the hope that it will be useful, 12 * but WITHOUT ANY WARRANTY; without even the implied warranty of 13 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 14 * GNU General Public License for more details. 15 * 16 * You should have received a copy of the GNU General Public License 17 * along with this program. If not, see <http://www.gnu.org/licenses/>. 18 */ 19 20 #include <net/sock.h> 21 #include <linux/list.h> 22 #include <linux/kthread.h> 23 24 #include "usbip_common.h" 25 #include "vudc.h" 26 27 static int alloc_urb_from_cmd(struct urb **urbp, 28 struct usbip_header *pdu, u8 type) 29 { 30 struct urb *urb; 31 32 if (type == USB_ENDPOINT_XFER_ISOC) 33 urb = usb_alloc_urb(pdu->u.cmd_submit.number_of_packets, 34 GFP_KERNEL); 35 else 36 urb = usb_alloc_urb(0, GFP_KERNEL); 37 38 if (!urb) 39 goto err; 40 41 usbip_pack_pdu(pdu, urb, USBIP_CMD_SUBMIT, 0); 42 43 if (urb->transfer_buffer_length > 0) { 44 urb->transfer_buffer = kzalloc(urb->transfer_buffer_length, 45 GFP_KERNEL); 46 if (!urb->transfer_buffer) 47 goto free_urb; 48 } 49 50 urb->setup_packet = kmemdup(&pdu->u.cmd_submit.setup, 8, 51 GFP_KERNEL); 52 if (!urb->setup_packet) 53 goto free_buffer; 54 55 /* 56 * FIXME - we only setup pipe enough for usbip functions 57 * to behave nicely 58 */ 59 urb->pipe |= pdu->base.direction == USBIP_DIR_IN ? 60 USB_DIR_IN : USB_DIR_OUT; 61 62 *urbp = urb; 63 return 0; 64 65 free_buffer: 66 kfree(urb->transfer_buffer); 67 urb->transfer_buffer = NULL; 68 free_urb: 69 usb_free_urb(urb); 70 err: 71 return -ENOMEM; 72 } 73 74 static int v_recv_cmd_unlink(struct vudc *udc, 75 struct usbip_header *pdu) 76 { 77 unsigned long flags; 78 struct urbp *urb_p; 79 80 spin_lock_irqsave(&udc->lock, flags); 81 list_for_each_entry(urb_p, &udc->urb_queue, urb_entry) { 82 if (urb_p->seqnum != pdu->u.cmd_unlink.seqnum) 83 continue; 84 urb_p->urb->unlinked = -ECONNRESET; 85 urb_p->seqnum = pdu->base.seqnum; 86 v_kick_timer(udc, jiffies); 87 spin_unlock_irqrestore(&udc->lock, flags); 88 return 0; 89 } 90 /* Not found, completed / not queued */ 91 spin_lock(&udc->lock_tx); 92 v_enqueue_ret_unlink(udc, pdu->base.seqnum, 0); 93 wake_up(&udc->tx_waitq); 94 spin_unlock(&udc->lock_tx); 95 spin_unlock_irqrestore(&udc->lock, flags); 96 97 return 0; 98 } 99 100 static int v_recv_cmd_submit(struct vudc *udc, 101 struct usbip_header *pdu) 102 { 103 int ret = 0; 104 struct urbp *urb_p; 105 u8 address; 106 unsigned long flags; 107 108 urb_p = alloc_urbp(); 109 if (!urb_p) { 110 usbip_event_add(&udc->ud, VUDC_EVENT_ERROR_MALLOC); 111 return -ENOMEM; 112 } 113 114 /* base.ep is pipeendpoint(pipe) */ 115 address = pdu->base.ep; 116 if (pdu->base.direction == USBIP_DIR_IN) 117 address |= USB_DIR_IN; 118 119 spin_lock_irq(&udc->lock); 120 urb_p->ep = vudc_find_endpoint(udc, address); 121 if (!urb_p->ep) { 122 /* we don't know the type, there may be isoc data! */ 123 dev_err(&udc->pdev->dev, "request to nonexistent endpoint"); 124 spin_unlock_irq(&udc->lock); 125 usbip_event_add(&udc->ud, VUDC_EVENT_ERROR_TCP); 126 ret = -EPIPE; 127 goto free_urbp; 128 } 129 urb_p->type = urb_p->ep->type; 130 spin_unlock_irq(&udc->lock); 131 132 urb_p->new = 1; 133 urb_p->seqnum = pdu->base.seqnum; 134 135 ret = alloc_urb_from_cmd(&urb_p->urb, pdu, urb_p->ep->type); 136 if (ret) { 137 usbip_event_add(&udc->ud, VUDC_EVENT_ERROR_MALLOC); 138 ret = -ENOMEM; 139 goto free_urbp; 140 } 141 142 urb_p->urb->status = -EINPROGRESS; 143 144 /* FIXME: more pipe setup to please usbip_common */ 145 urb_p->urb->pipe &= ~(3 << 30); 146 switch (urb_p->ep->type) { 147 case USB_ENDPOINT_XFER_BULK: 148 urb_p->urb->pipe |= (PIPE_BULK << 30); 149 break; 150 case USB_ENDPOINT_XFER_INT: 151 urb_p->urb->pipe |= (PIPE_INTERRUPT << 30); 152 break; 153 case USB_ENDPOINT_XFER_CONTROL: 154 urb_p->urb->pipe |= (PIPE_CONTROL << 30); 155 break; 156 case USB_ENDPOINT_XFER_ISOC: 157 urb_p->urb->pipe |= (PIPE_ISOCHRONOUS << 30); 158 break; 159 } 160 ret = usbip_recv_xbuff(&udc->ud, urb_p->urb); 161 if (ret < 0) 162 goto free_urbp; 163 164 ret = usbip_recv_iso(&udc->ud, urb_p->urb); 165 if (ret < 0) 166 goto free_urbp; 167 168 spin_lock_irqsave(&udc->lock, flags); 169 v_kick_timer(udc, jiffies); 170 list_add_tail(&urb_p->urb_entry, &udc->urb_queue); 171 spin_unlock_irqrestore(&udc->lock, flags); 172 173 return 0; 174 175 free_urbp: 176 free_urbp_and_urb(urb_p); 177 return ret; 178 } 179 180 static int v_rx_pdu(struct usbip_device *ud) 181 { 182 int ret; 183 struct usbip_header pdu; 184 struct vudc *udc = container_of(ud, struct vudc, ud); 185 186 memset(&pdu, 0, sizeof(pdu)); 187 ret = usbip_recv(ud->tcp_socket, &pdu, sizeof(pdu)); 188 if (ret != sizeof(pdu)) { 189 usbip_event_add(ud, VUDC_EVENT_ERROR_TCP); 190 if (ret >= 0) 191 return -EPIPE; 192 return ret; 193 } 194 usbip_header_correct_endian(&pdu, 0); 195 196 spin_lock_irq(&ud->lock); 197 ret = (ud->status == SDEV_ST_USED); 198 spin_unlock_irq(&ud->lock); 199 if (!ret) { 200 usbip_event_add(ud, VUDC_EVENT_ERROR_TCP); 201 return -EBUSY; 202 } 203 204 switch (pdu.base.command) { 205 case USBIP_CMD_UNLINK: 206 ret = v_recv_cmd_unlink(udc, &pdu); 207 break; 208 case USBIP_CMD_SUBMIT: 209 ret = v_recv_cmd_submit(udc, &pdu); 210 break; 211 default: 212 ret = -EPIPE; 213 pr_err("rx: unknown command"); 214 break; 215 } 216 return ret; 217 } 218 219 int v_rx_loop(void *data) 220 { 221 struct usbip_device *ud = data; 222 int ret = 0; 223 224 while (!kthread_should_stop()) { 225 if (usbip_event_happened(ud)) 226 break; 227 ret = v_rx_pdu(ud); 228 if (ret < 0) { 229 pr_warn("v_rx exit with error %d", ret); 230 break; 231 } 232 } 233 return ret; 234 } 235