projects/linux·blob master · refs

497 lines · 11.7 KiB

1// SPDX-License-Identifier: GPL-2.0+
2/*
3 * Copyright (C) 2015 Karol Kosik <[email protected]>
4 * Copyright (C) 2015-2016 Samsung Electronics
5 * Igor Kotrasinski <[email protected]>
6 *
7 * Based on dummy_hcd.c, which is:
8 * Copyright (C) 2003 David Brownell
9 * Copyright (C) 2003-2005 Alan Stern
10 */
11
12#include <linux/usb.h>
13#include <linux/timer.h>
14#include <linux/usb/ch9.h>
15
16#include "vudc.h"
17
18#define DEV_REQUEST (USB_TYPE_STANDARD | USB_RECIP_DEVICE)
19#define DEV_INREQUEST (DEV_REQUEST | USB_DIR_IN)
20#define INTF_REQUEST (USB_TYPE_STANDARD | USB_RECIP_INTERFACE)
21#define INTF_INREQUEST (INTF_REQUEST | USB_DIR_IN)
22#define EP_REQUEST (USB_TYPE_STANDARD | USB_RECIP_ENDPOINT)
23#define EP_INREQUEST (EP_REQUEST | USB_DIR_IN)
24
25static int get_frame_limit(enum usb_device_speed speed)
26{
27 switch (speed) {
28 case USB_SPEED_LOW:
29 return 8 /*bytes*/ * 12 /*packets*/;
30 case USB_SPEED_FULL:
31 return 64 /*bytes*/ * 19 /*packets*/;
32 case USB_SPEED_HIGH:
33 return 512 /*bytes*/ * 13 /*packets*/ * 8 /*uframes*/;
34 case USB_SPEED_SUPER:
35 /* Bus speed is 500000 bytes/ms, so use a little less */
36 return 490000;
37 default:
38 /* error */
39 return -1;
40 }
41
42}
43
44/*
45 * handle_control_request() - handles all control transfers
46 * @udc: pointer to vudc
47 * @urb: the urb request to handle
48 * @setup: pointer to the setup data for a USB device control
49 * request
50 * @status: pointer to request handling status
51 *
52 * Return 0 - if the request was handled
53 * 1 - if the request wasn't handles
54 * error code on error
55 *
56 * Adapted from drivers/usb/gadget/udc/dummy_hcd.c
57 */
58static int handle_control_request(struct vudc *udc, struct urb *urb,
59 struct usb_ctrlrequest *setup,
60 int *status)
61{
62 struct vep *ep2;
63 int ret_val = 1;
64 unsigned int w_index;
65 unsigned int w_value;
66
67 w_index = le16_to_cpu(setup->wIndex);
68 w_value = le16_to_cpu(setup->wValue);
69 switch (setup->bRequest) {
70 case USB_REQ_SET_ADDRESS:
71 if (setup->bRequestType != DEV_REQUEST)
72 break;
73 udc->address = w_value;
74 ret_val = 0;
75 *status = 0;
76 break;
77 case USB_REQ_SET_FEATURE:
78 if (setup->bRequestType == DEV_REQUEST) {
79 ret_val = 0;
80 switch (w_value) {
81 case USB_DEVICE_REMOTE_WAKEUP:
82 break;
83 case USB_DEVICE_B_HNP_ENABLE:
84 udc->gadget.b_hnp_enable = 1;
85 break;
86 case USB_DEVICE_A_HNP_SUPPORT:
87 udc->gadget.a_hnp_support = 1;
88 break;
89 case USB_DEVICE_A_ALT_HNP_SUPPORT:
90 udc->gadget.a_alt_hnp_support = 1;
91 break;
92 default:
93 ret_val = -EOPNOTSUPP;
94 }
95 if (ret_val == 0) {
96 udc->devstatus |= (1 << w_value);
97 *status = 0;
98 }
99 } else if (setup->bRequestType == EP_REQUEST) {
100 /* endpoint halt */
101 ep2 = vudc_find_endpoint(udc, w_index);
102 if (!ep2 || ep2->ep.name == udc->ep[0].ep.name) {
103 ret_val = -EOPNOTSUPP;
104 break;
105 }
106 ep2->halted = 1;
107 ret_val = 0;
108 *status = 0;
109 }
110 break;
111 case USB_REQ_CLEAR_FEATURE:
112 if (setup->bRequestType == DEV_REQUEST) {
113 ret_val = 0;
114 switch (w_value) {
115 case USB_DEVICE_REMOTE_WAKEUP:
116 w_value = USB_DEVICE_REMOTE_WAKEUP;
117 break;
118
119 case USB_DEVICE_U1_ENABLE:
120 case USB_DEVICE_U2_ENABLE:
121 case USB_DEVICE_LTM_ENABLE:
122 ret_val = -EOPNOTSUPP;
123 break;
124 default:
125 ret_val = -EOPNOTSUPP;
126 break;
127 }
128 if (ret_val == 0) {
129 udc->devstatus &= ~(1 << w_value);
130 *status = 0;
131 }
132 } else if (setup->bRequestType == EP_REQUEST) {
133 /* endpoint halt */
134 ep2 = vudc_find_endpoint(udc, w_index);
135 if (!ep2) {
136 ret_val = -EOPNOTSUPP;
137 break;
138 }
139 if (!ep2->wedged)
140 ep2->halted = 0;
141 ret_val = 0;
142 *status = 0;
143 }
144 break;
145 case USB_REQ_GET_STATUS:
146 if (setup->bRequestType == DEV_INREQUEST
147 || setup->bRequestType == INTF_INREQUEST
148 || setup->bRequestType == EP_INREQUEST) {
149 char *buf;
150 /*
151 * device: remote wakeup, selfpowered
152 * interface: nothing
153 * endpoint: halt
154 */
155 buf = (char *)urb->transfer_buffer;
156 if (urb->transfer_buffer_length > 0) {
157 if (setup->bRequestType == EP_INREQUEST) {
158 ep2 = vudc_find_endpoint(udc, w_index);
159 if (!ep2) {
160 ret_val = -EOPNOTSUPP;
161 break;
162 }
163 buf[0] = ep2->halted;
164 } else if (setup->bRequestType ==
165 DEV_INREQUEST) {
166 buf[0] = (u8)udc->devstatus;
167 } else
168 buf[0] = 0;
169 }
170 if (urb->transfer_buffer_length > 1)
171 buf[1] = 0;
172 urb->actual_length = min_t(u32, 2,
173 urb->transfer_buffer_length);
174 ret_val = 0;
175 *status = 0;
176 }
177 break;
178 }
179 return ret_val;
180}
181
182/* Adapted from dummy_hcd.c ; caller must hold lock */
183static int transfer(struct vudc *udc,
184 struct urb *urb, struct vep *ep, int limit)
185{
186 struct vrequest *req;
187 int sent = 0;
188top:
189 /* if there's no request queued, the device is NAKing; return */
190 list_for_each_entry(req, &ep->req_queue, req_entry) {
191 unsigned int host_len, dev_len, len;
192 void *ubuf_pos, *rbuf_pos;
193 int is_short, to_host;
194 int rescan = 0;
195
196 /*
197 * 1..N packets of ep->ep.maxpacket each ... the last one
198 * may be short (including zero length).
199 *
200 * writer can send a zlp explicitly (length 0) or implicitly
201 * (length mod maxpacket zero, and 'zero' flag); they always
202 * terminate reads.
203 */
204 host_len = urb->transfer_buffer_length - urb->actual_length;
205 dev_len = req->req.length - req->req.actual;
206 len = min(host_len, dev_len);
207
208 to_host = usb_pipein(urb->pipe);
209 if (unlikely(len == 0))
210 is_short = 1;
211 else {
212 /* send multiple of maxpacket first, then remainder */
213 if (len >= ep->ep.maxpacket) {
214 is_short = 0;
215 if (len % ep->ep.maxpacket > 0)
216 rescan = 1;
217 len -= len % ep->ep.maxpacket;
218 } else {
219 is_short = 1;
220 }
221
222 ubuf_pos = urb->transfer_buffer + urb->actual_length;
223 rbuf_pos = req->req.buf + req->req.actual;
224
225 if (urb->pipe & USB_DIR_IN)
226 memcpy(ubuf_pos, rbuf_pos, len);
227 else
228 memcpy(rbuf_pos, ubuf_pos, len);
229
230 urb->actual_length += len;
231 req->req.actual += len;
232 sent += len;
233 }
234
235 /*
236 * short packets terminate, maybe with overflow/underflow.
237 * it's only really an error to write too much.
238 *
239 * partially filling a buffer optionally blocks queue advances
240 * (so completion handlers can clean up the queue) but we don't
241 * need to emulate such data-in-flight.
242 */
243 if (is_short) {
244 if (host_len == dev_len) {
245 req->req.status = 0;
246 urb->status = 0;
247 } else if (to_host) {
248 req->req.status = 0;
249 if (dev_len > host_len)
250 urb->status = -EOVERFLOW;
251 else
252 urb->status = 0;
253 } else {
254 urb->status = 0;
255 if (host_len > dev_len)
256 req->req.status = -EOVERFLOW;
257 else
258 req->req.status = 0;
259 }
260
261 /* many requests terminate without a short packet */
262 /* also check if we need to send zlp */
263 } else {
264 if (req->req.length == req->req.actual) {
265 if (req->req.zero && to_host)
266 rescan = 1;
267 else
268 req->req.status = 0;
269 }
270 if (urb->transfer_buffer_length == urb->actual_length) {
271 if (urb->transfer_flags & URB_ZERO_PACKET &&
272 !to_host)
273 rescan = 1;
274 else
275 urb->status = 0;
276 }
277 }
278
279 /* device side completion --> continuable */
280 if (req->req.status != -EINPROGRESS) {
281
282 list_del_init(&req->req_entry);
283 spin_unlock(&udc->lock);
284 usb_gadget_giveback_request(&ep->ep, &req->req);
285 spin_lock(&udc->lock);
286
287 /* requests might have been unlinked... */
288 rescan = 1;
289 }
290
291 /* host side completion --> terminate */
292 if (urb->status != -EINPROGRESS)
293 break;
294
295 /* rescan to continue with any other queued i/o */
296 if (rescan)
297 goto top;
298 }
299 return sent;
300}
301
302static void v_timer(struct timer_list *t)
303{
304 struct vudc *udc = timer_container_of(udc, t, tr_timer.timer);
305 struct transfer_timer *timer = &udc->tr_timer;
306 struct urbp *urb_p, *tmp;
307 unsigned long flags;
308 struct usb_ep *_ep;
309 struct vep *ep;
310 int ret = 0;
311 int total, limit;
312
313 spin_lock_irqsave(&udc->lock, flags);
314
315 total = get_frame_limit(udc->gadget.speed);
316 if (total < 0) { /* unknown speed, or not set yet */
317 timer->state = VUDC_TR_IDLE;
318 spin_unlock_irqrestore(&udc->lock, flags);
319 return;
320 }
321 /* is it next frame now? */
322 if (time_after(jiffies, timer->frame_start + msecs_to_jiffies(1))) {
323 timer->frame_limit = total;
324 /* FIXME: how to make it accurate? */
325 timer->frame_start = jiffies;
326 } else {
327 total = timer->frame_limit;
328 }
329
330 /* We have to clear ep0 flags separately as it's not on the list */
331 udc->ep[0].already_seen = 0;
332 list_for_each_entry(_ep, &udc->gadget.ep_list, ep_list) {
333 ep = to_vep(_ep);
334 ep->already_seen = 0;
335 }
336
337restart:
338 list_for_each_entry_safe(urb_p, tmp, &udc->urb_queue, urb_entry) {
339 struct urb *urb = urb_p->urb;
340
341 ep = urb_p->ep;
342 if (urb->unlinked)
343 goto return_urb;
344 if (timer->state != VUDC_TR_RUNNING)
345 continue;
346
347 if (!ep) {
348 urb->status = -EPROTO;
349 goto return_urb;
350 }
351
352 /* Used up bandwidth? */
353 if (total <= 0 && ep->type == USB_ENDPOINT_XFER_BULK)
354 continue;
355
356 if (ep->already_seen)
357 continue;
358 ep->already_seen = 1;
359 if (ep == &udc->ep[0] && urb_p->new) {
360 ep->setup_stage = 1;
361 urb_p->new = 0;
362 }
363 if (ep->halted && !ep->setup_stage) {
364 urb->status = -EPIPE;
365 goto return_urb;
366 }
367
368 if (ep == &udc->ep[0] && ep->setup_stage) {
369 /* TODO - flush any stale requests */
370 ep->setup_stage = 0;
371 ep->halted = 0;
372
373 ret = handle_control_request(udc, urb,
374 (struct usb_ctrlrequest *) urb->setup_packet,
375 (&urb->status));
376 if (ret > 0) {
377 spin_unlock(&udc->lock);
378 ret = udc->driver->setup(&udc->gadget,
379 (struct usb_ctrlrequest *)
380 urb->setup_packet);
381 spin_lock(&udc->lock);
382 }
383 if (ret >= 0) {
384 /* no delays (max 64kb data stage) */
385 limit = 64 * 1024;
386 goto treat_control_like_bulk;
387 } else {
388 urb->status = -EPIPE;
389 urb->actual_length = 0;
390 goto return_urb;
391 }
392 }
393
394 limit = total;
395 switch (ep->type) {
396 case USB_ENDPOINT_XFER_ISOC:
397 /* TODO: support */
398 urb->status = -EXDEV;
399 break;
400
401 case USB_ENDPOINT_XFER_INT:
402 /*
403 * TODO: figure out bandwidth guarantees
404 * for now, give unlimited bandwidth
405 */
406 limit += urb->transfer_buffer_length;
407 fallthrough;
408 default:
409treat_control_like_bulk:
410 total -= transfer(udc, urb, ep, limit);
411 }
412 if (urb->status == -EINPROGRESS)
413 continue;
414
415return_urb:
416 if (ep)
417 ep->already_seen = ep->setup_stage = 0;
418
419 spin_lock(&udc->lock_tx);
420 list_del(&urb_p->urb_entry);
421 if (!urb->unlinked) {
422 v_enqueue_ret_submit(udc, urb_p);
423 } else {
424 v_enqueue_ret_unlink(udc, urb_p->seqnum,
425 urb->unlinked);
426 free_urbp_and_urb(urb_p);
427 }
428 wake_up(&udc->tx_waitq);
429 spin_unlock(&udc->lock_tx);
430
431 goto restart;
432 }
433
434 /* TODO - also wait on empty usb_request queues? */
435 if (list_empty(&udc->urb_queue))
436 timer->state = VUDC_TR_IDLE;
437 else
438 mod_timer(&timer->timer,
439 timer->frame_start + msecs_to_jiffies(1));
440
441 spin_unlock_irqrestore(&udc->lock, flags);
442}
443
444/* All timer functions are run with udc->lock held */
445
446void v_init_timer(struct vudc *udc)
447{
448 struct transfer_timer *t = &udc->tr_timer;
449
450 timer_setup(&t->timer, v_timer, 0);
451 t->state = VUDC_TR_STOPPED;
452}
453
454void v_start_timer(struct vudc *udc)
455{
456 struct transfer_timer *t = &udc->tr_timer;
457
458 dev_dbg(&udc->pdev->dev, "timer start");
459 switch (t->state) {
460 case VUDC_TR_RUNNING:
461 return;
462 case VUDC_TR_IDLE:
463 return v_kick_timer(udc, jiffies);
464 case VUDC_TR_STOPPED:
465 t->state = VUDC_TR_IDLE;
466 t->frame_start = jiffies;
467 t->frame_limit = get_frame_limit(udc->gadget.speed);
468 return v_kick_timer(udc, jiffies);
469 }
470}
471
472void v_kick_timer(struct vudc *udc, unsigned long time)
473{
474 struct transfer_timer *t = &udc->tr_timer;
475
476 dev_dbg(&udc->pdev->dev, "timer kick");
477 switch (t->state) {
478 case VUDC_TR_RUNNING:
479 return;
480 case VUDC_TR_IDLE:
481 t->state = VUDC_TR_RUNNING;
482 fallthrough;
483 case VUDC_TR_STOPPED:
484 /* we may want to kick timer to unqueue urbs */
485 mod_timer(&t->timer, time);
486 }
487}
488
489void v_stop_timer(struct vudc *udc)
490{
491 struct transfer_timer *t = &udc->tr_timer;
492
493 /* Delete the timer synchronously before teardown frees udc. */
494 dev_dbg(&udc->pdev->dev, "timer stop");
495 timer_delete_sync(&t->timer);
496 t->state = VUDC_TR_STOPPED;
497}