Commit | Line | Data |
---|---|---|
79c02cb1 IK |
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 = 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 &= ~(11 << 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 | } |