xref: /linux/drivers/usb/usbip/vudc_rx.c (revision e5c86679d5e864947a52fb31e45a425dea3e7fa9)
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