1
2
3
4
5
6
7
8
9
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 * 12 ;
30 case USB_SPEED_FULL:
31 return 64 * 19 ;
32 case USB_SPEED_HIGH:
33 return 512 * 13 * 8 ;
34 case USB_SPEED_SUPER:
35
36 return 490000;
37 default:
38
39 return -1;
40 }
41
42}
43
44
45
46
47
48
49
50
51
52
53
54
55
56
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
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
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
152
153
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
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
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
198
199
200
201
202
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
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
237
238
239
240
241
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
262
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
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
288 rescan = 1;
289 }
290
291
292 if (urb->status != -EINPROGRESS)
293 break;
294
295
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 = from_timer(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) {
317 timer->state = VUDC_TR_IDLE;
318 spin_unlock_irqrestore(&udc->lock, flags);
319 return;
320 }
321
322 if (time_after(jiffies, timer->frame_start + msecs_to_jiffies(1))) {
323 timer->frame_limit = total;
324
325 timer->frame_start = jiffies;
326 } else {
327 total = timer->frame_limit;
328 }
329
330
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
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
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
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
398 urb->status = -EXDEV;
399 break;
400
401 case USB_ENDPOINT_XFER_INT:
402
403
404
405
406 limit += urb->transfer_buffer_length;
407
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
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
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
483 case VUDC_TR_STOPPED:
484
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
494 dev_dbg(&udc->pdev->dev, "timer stop");
495 t->state = VUDC_TR_STOPPED;
496}
497