vudc_rx.c 5.4 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241
  1. // SPDX-License-Identifier: GPL-2.0+
  2. /*
  3. * Copyright (C) 2015 Karol Kosik <karo9@interia.eu>
  4. * Copyright (C) 2015-2016 Samsung Electronics
  5. * Igor Kotrasinski <i.kotrasinsk@samsung.com>
  6. */
  7. #include <net/sock.h>
  8. #include <linux/list.h>
  9. #include <linux/kthread.h>
  10. #include "usbip_common.h"
  11. #include "vudc.h"
  12. static int alloc_urb_from_cmd(struct urb **urbp,
  13. struct usbip_header *pdu, u8 type)
  14. {
  15. struct urb *urb;
  16. if (type == USB_ENDPOINT_XFER_ISOC)
  17. urb = usb_alloc_urb(pdu->u.cmd_submit.number_of_packets,
  18. GFP_KERNEL);
  19. else
  20. urb = usb_alloc_urb(0, GFP_KERNEL);
  21. if (!urb)
  22. goto err;
  23. usbip_pack_pdu(pdu, urb, USBIP_CMD_SUBMIT, 0);
  24. if (urb->transfer_buffer_length > 0) {
  25. urb->transfer_buffer = kzalloc(urb->transfer_buffer_length,
  26. GFP_KERNEL);
  27. if (!urb->transfer_buffer)
  28. goto free_urb;
  29. }
  30. urb->setup_packet = kmemdup(&pdu->u.cmd_submit.setup, 8,
  31. GFP_KERNEL);
  32. if (!urb->setup_packet)
  33. goto free_buffer;
  34. /*
  35. * FIXME - we only setup pipe enough for usbip functions
  36. * to behave nicely
  37. */
  38. urb->pipe |= pdu->base.direction == USBIP_DIR_IN ?
  39. USB_DIR_IN : USB_DIR_OUT;
  40. *urbp = urb;
  41. return 0;
  42. free_buffer:
  43. kfree(urb->transfer_buffer);
  44. urb->transfer_buffer = NULL;
  45. free_urb:
  46. usb_free_urb(urb);
  47. err:
  48. return -ENOMEM;
  49. }
  50. static int v_recv_cmd_unlink(struct vudc *udc,
  51. struct usbip_header *pdu)
  52. {
  53. unsigned long flags;
  54. struct urbp *urb_p;
  55. spin_lock_irqsave(&udc->lock, flags);
  56. list_for_each_entry(urb_p, &udc->urb_queue, urb_entry) {
  57. if (urb_p->seqnum != pdu->u.cmd_unlink.seqnum)
  58. continue;
  59. urb_p->urb->unlinked = -ECONNRESET;
  60. urb_p->seqnum = pdu->base.seqnum;
  61. v_kick_timer(udc, jiffies);
  62. spin_unlock_irqrestore(&udc->lock, flags);
  63. return 0;
  64. }
  65. /* Not found, completed / not queued */
  66. spin_lock(&udc->lock_tx);
  67. v_enqueue_ret_unlink(udc, pdu->base.seqnum, 0);
  68. wake_up(&udc->tx_waitq);
  69. spin_unlock(&udc->lock_tx);
  70. spin_unlock_irqrestore(&udc->lock, flags);
  71. return 0;
  72. }
  73. static int v_recv_cmd_submit(struct vudc *udc,
  74. struct usbip_header *pdu)
  75. {
  76. int ret = 0;
  77. struct urbp *urb_p;
  78. u8 address;
  79. unsigned long flags;
  80. urb_p = alloc_urbp();
  81. if (!urb_p) {
  82. usbip_event_add(&udc->ud, VUDC_EVENT_ERROR_MALLOC);
  83. return -ENOMEM;
  84. }
  85. /* base.ep is pipeendpoint(pipe) */
  86. address = pdu->base.ep;
  87. if (pdu->base.direction == USBIP_DIR_IN)
  88. address |= USB_DIR_IN;
  89. spin_lock_irq(&udc->lock);
  90. urb_p->ep = vudc_find_endpoint(udc, address);
  91. if (!urb_p->ep) {
  92. /* we don't know the type, there may be isoc data! */
  93. dev_err(&udc->pdev->dev, "request to nonexistent endpoint");
  94. spin_unlock_irq(&udc->lock);
  95. usbip_event_add(&udc->ud, VUDC_EVENT_ERROR_TCP);
  96. ret = -EPIPE;
  97. goto free_urbp;
  98. }
  99. urb_p->type = urb_p->ep->type;
  100. spin_unlock_irq(&udc->lock);
  101. urb_p->new = 1;
  102. urb_p->seqnum = pdu->base.seqnum;
  103. if (urb_p->ep->type == USB_ENDPOINT_XFER_ISOC) {
  104. /* validate packet size and number of packets */
  105. unsigned int maxp, packets, bytes;
  106. maxp = usb_endpoint_maxp(urb_p->ep->desc);
  107. maxp *= usb_endpoint_maxp_mult(urb_p->ep->desc);
  108. bytes = pdu->u.cmd_submit.transfer_buffer_length;
  109. packets = DIV_ROUND_UP(bytes, maxp);
  110. if (pdu->u.cmd_submit.number_of_packets < 0 ||
  111. pdu->u.cmd_submit.number_of_packets > packets) {
  112. dev_err(&udc->gadget.dev,
  113. "CMD_SUBMIT: isoc invalid num packets %d\n",
  114. pdu->u.cmd_submit.number_of_packets);
  115. ret = -EMSGSIZE;
  116. goto free_urbp;
  117. }
  118. }
  119. ret = alloc_urb_from_cmd(&urb_p->urb, pdu, urb_p->ep->type);
  120. if (ret) {
  121. usbip_event_add(&udc->ud, VUDC_EVENT_ERROR_MALLOC);
  122. ret = -ENOMEM;
  123. goto free_urbp;
  124. }
  125. urb_p->urb->status = -EINPROGRESS;
  126. /* FIXME: more pipe setup to please usbip_common */
  127. urb_p->urb->pipe &= ~(3 << 30);
  128. switch (urb_p->ep->type) {
  129. case USB_ENDPOINT_XFER_BULK:
  130. urb_p->urb->pipe |= (PIPE_BULK << 30);
  131. break;
  132. case USB_ENDPOINT_XFER_INT:
  133. urb_p->urb->pipe |= (PIPE_INTERRUPT << 30);
  134. break;
  135. case USB_ENDPOINT_XFER_CONTROL:
  136. urb_p->urb->pipe |= (PIPE_CONTROL << 30);
  137. break;
  138. case USB_ENDPOINT_XFER_ISOC:
  139. urb_p->urb->pipe |= (PIPE_ISOCHRONOUS << 30);
  140. break;
  141. }
  142. ret = usbip_recv_xbuff(&udc->ud, urb_p->urb);
  143. if (ret < 0)
  144. goto free_urbp;
  145. ret = usbip_recv_iso(&udc->ud, urb_p->urb);
  146. if (ret < 0)
  147. goto free_urbp;
  148. spin_lock_irqsave(&udc->lock, flags);
  149. v_kick_timer(udc, jiffies);
  150. list_add_tail(&urb_p->urb_entry, &udc->urb_queue);
  151. spin_unlock_irqrestore(&udc->lock, flags);
  152. return 0;
  153. free_urbp:
  154. free_urbp_and_urb(urb_p);
  155. return ret;
  156. }
  157. static int v_rx_pdu(struct usbip_device *ud)
  158. {
  159. int ret;
  160. struct usbip_header pdu;
  161. struct vudc *udc = container_of(ud, struct vudc, ud);
  162. memset(&pdu, 0, sizeof(pdu));
  163. ret = usbip_recv(ud->tcp_socket, &pdu, sizeof(pdu));
  164. if (ret != sizeof(pdu)) {
  165. usbip_event_add(ud, VUDC_EVENT_ERROR_TCP);
  166. if (ret >= 0)
  167. return -EPIPE;
  168. return ret;
  169. }
  170. usbip_header_correct_endian(&pdu, 0);
  171. spin_lock_irq(&ud->lock);
  172. ret = (ud->status == SDEV_ST_USED);
  173. spin_unlock_irq(&ud->lock);
  174. if (!ret) {
  175. usbip_event_add(ud, VUDC_EVENT_ERROR_TCP);
  176. return -EBUSY;
  177. }
  178. switch (pdu.base.command) {
  179. case USBIP_CMD_UNLINK:
  180. ret = v_recv_cmd_unlink(udc, &pdu);
  181. break;
  182. case USBIP_CMD_SUBMIT:
  183. ret = v_recv_cmd_submit(udc, &pdu);
  184. break;
  185. default:
  186. ret = -EPIPE;
  187. pr_err("rx: unknown command");
  188. break;
  189. }
  190. return ret;
  191. }
  192. int v_rx_loop(void *data)
  193. {
  194. struct usbip_device *ud = data;
  195. int ret = 0;
  196. while (!kthread_should_stop()) {
  197. if (usbip_event_happened(ud))
  198. break;
  199. ret = v_rx_pdu(ud);
  200. if (ret < 0) {
  201. pr_warn("v_rx exit with error %d", ret);
  202. break;
  203. }
  204. }
  205. return ret;
  206. }