1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26#include <linux/module.h>
27#include <linux/kernel.h>
28#include <linux/delay.h>
29#include <linux/ioport.h>
30#include <linux/slab.h>
31#include <linux/errno.h>
32#include <linux/init.h>
33#include <linux/timer.h>
34#include <linux/list.h>
35#include <linux/interrupt.h>
36#include <linux/platform_device.h>
37#include <linux/usb.h>
38#include <linux/usb/gadget.h>
39#include <linux/usb/hcd.h>
40#include <linux/scatterlist.h>
41
42#include <asm/byteorder.h>
43#include <linux/io.h>
44#include <asm/irq.h>
45#include <asm/unaligned.h>
46
47#define DRIVER_DESC "USB Host+Gadget Emulator"
48#define DRIVER_VERSION "02 May 2005"
49
50#define POWER_BUDGET 500
51
52static const char driver_name[] = "dummy_hcd";
53static const char driver_desc[] = "USB Host+Gadget Emulator";
54
55static const char gadget_name[] = "dummy_udc";
56
57MODULE_DESCRIPTION(DRIVER_DESC);
58MODULE_AUTHOR("David Brownell");
59MODULE_LICENSE("GPL");
60
61struct dummy_hcd_module_parameters {
62 bool is_super_speed;
63 bool is_high_speed;
64 unsigned int num;
65};
66
67static struct dummy_hcd_module_parameters mod_data = {
68 .is_super_speed = false,
69 .is_high_speed = true,
70 .num = 1,
71};
72module_param_named(is_super_speed, mod_data.is_super_speed, bool, S_IRUGO);
73MODULE_PARM_DESC(is_super_speed, "true to simulate SuperSpeed connection");
74module_param_named(is_high_speed, mod_data.is_high_speed, bool, S_IRUGO);
75MODULE_PARM_DESC(is_high_speed, "true to simulate HighSpeed connection");
76module_param_named(num, mod_data.num, uint, S_IRUGO);
77MODULE_PARM_DESC(num, "number of emulated controllers");
78
79
80
81struct dummy_ep {
82 struct list_head queue;
83 unsigned long last_io;
84 struct usb_gadget *gadget;
85 const struct usb_endpoint_descriptor *desc;
86 struct usb_ep ep;
87 unsigned halted:1;
88 unsigned wedged:1;
89 unsigned already_seen:1;
90 unsigned setup_stage:1;
91 unsigned stream_en:1;
92};
93
94struct dummy_request {
95 struct list_head queue;
96 struct usb_request req;
97};
98
99static inline struct dummy_ep *usb_ep_to_dummy_ep(struct usb_ep *_ep)
100{
101 return container_of(_ep, struct dummy_ep, ep);
102}
103
104static inline struct dummy_request *usb_request_to_dummy_request
105 (struct usb_request *_req)
106{
107 return container_of(_req, struct dummy_request, req);
108}
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126static const char ep0name[] = "ep0";
127
128static const struct {
129 const char *name;
130 const struct usb_ep_caps caps;
131} ep_info[] = {
132#define EP_INFO(_name, _caps) \
133 { \
134 .name = _name, \
135 .caps = _caps, \
136 }
137
138
139#define TYPE_BULK_OR_INT (USB_EP_CAPS_TYPE_BULK | USB_EP_CAPS_TYPE_INT)
140
141
142 EP_INFO(ep0name,
143 USB_EP_CAPS(USB_EP_CAPS_TYPE_CONTROL, USB_EP_CAPS_DIR_ALL)),
144
145 EP_INFO("ep1in-bulk",
146 USB_EP_CAPS(USB_EP_CAPS_TYPE_BULK, USB_EP_CAPS_DIR_IN)),
147 EP_INFO("ep2out-bulk",
148 USB_EP_CAPS(USB_EP_CAPS_TYPE_BULK, USB_EP_CAPS_DIR_OUT)),
149
150
151
152
153
154
155 EP_INFO("ep5in-int",
156 USB_EP_CAPS(USB_EP_CAPS_TYPE_INT, USB_EP_CAPS_DIR_IN)),
157 EP_INFO("ep6in-bulk",
158 USB_EP_CAPS(USB_EP_CAPS_TYPE_BULK, USB_EP_CAPS_DIR_IN)),
159 EP_INFO("ep7out-bulk",
160 USB_EP_CAPS(USB_EP_CAPS_TYPE_BULK, USB_EP_CAPS_DIR_OUT)),
161
162
163
164
165
166
167 EP_INFO("ep10in-int",
168 USB_EP_CAPS(USB_EP_CAPS_TYPE_INT, USB_EP_CAPS_DIR_IN)),
169 EP_INFO("ep11in-bulk",
170 USB_EP_CAPS(USB_EP_CAPS_TYPE_BULK, USB_EP_CAPS_DIR_IN)),
171 EP_INFO("ep12out-bulk",
172 USB_EP_CAPS(USB_EP_CAPS_TYPE_BULK, USB_EP_CAPS_DIR_OUT)),
173
174
175
176
177
178
179 EP_INFO("ep15in-int",
180 USB_EP_CAPS(USB_EP_CAPS_TYPE_INT, USB_EP_CAPS_DIR_IN)),
181
182
183 EP_INFO("ep1out-bulk",
184 USB_EP_CAPS(USB_EP_CAPS_TYPE_BULK, USB_EP_CAPS_DIR_OUT)),
185 EP_INFO("ep2in-bulk",
186 USB_EP_CAPS(USB_EP_CAPS_TYPE_BULK, USB_EP_CAPS_DIR_IN)),
187
188
189 EP_INFO("ep3out",
190 USB_EP_CAPS(TYPE_BULK_OR_INT, USB_EP_CAPS_DIR_OUT)),
191 EP_INFO("ep4in",
192 USB_EP_CAPS(TYPE_BULK_OR_INT, USB_EP_CAPS_DIR_IN)),
193 EP_INFO("ep5out",
194 USB_EP_CAPS(TYPE_BULK_OR_INT, USB_EP_CAPS_DIR_OUT)),
195 EP_INFO("ep6out",
196 USB_EP_CAPS(TYPE_BULK_OR_INT, USB_EP_CAPS_DIR_OUT)),
197 EP_INFO("ep7in",
198 USB_EP_CAPS(TYPE_BULK_OR_INT, USB_EP_CAPS_DIR_IN)),
199 EP_INFO("ep8out",
200 USB_EP_CAPS(TYPE_BULK_OR_INT, USB_EP_CAPS_DIR_OUT)),
201 EP_INFO("ep9in",
202 USB_EP_CAPS(TYPE_BULK_OR_INT, USB_EP_CAPS_DIR_IN)),
203 EP_INFO("ep10out",
204 USB_EP_CAPS(TYPE_BULK_OR_INT, USB_EP_CAPS_DIR_OUT)),
205 EP_INFO("ep11out",
206 USB_EP_CAPS(TYPE_BULK_OR_INT, USB_EP_CAPS_DIR_OUT)),
207 EP_INFO("ep12in",
208 USB_EP_CAPS(TYPE_BULK_OR_INT, USB_EP_CAPS_DIR_IN)),
209 EP_INFO("ep13out",
210 USB_EP_CAPS(TYPE_BULK_OR_INT, USB_EP_CAPS_DIR_OUT)),
211 EP_INFO("ep14in",
212 USB_EP_CAPS(TYPE_BULK_OR_INT, USB_EP_CAPS_DIR_IN)),
213 EP_INFO("ep15out",
214 USB_EP_CAPS(TYPE_BULK_OR_INT, USB_EP_CAPS_DIR_OUT)),
215
216#undef EP_INFO
217};
218
219#define DUMMY_ENDPOINTS ARRAY_SIZE(ep_info)
220
221
222
223#define FIFO_SIZE 64
224
225struct urbp {
226 struct urb *urb;
227 struct list_head urbp_list;
228 struct sg_mapping_iter miter;
229 u32 miter_started;
230};
231
232
233enum dummy_rh_state {
234 DUMMY_RH_RESET,
235 DUMMY_RH_SUSPENDED,
236 DUMMY_RH_RUNNING
237};
238
239struct dummy_hcd {
240 struct dummy *dum;
241 enum dummy_rh_state rh_state;
242 struct timer_list timer;
243 u32 port_status;
244 u32 old_status;
245 unsigned long re_timeout;
246
247 struct usb_device *udev;
248 struct list_head urbp_list;
249 struct urbp *next_frame_urbp;
250
251 u32 stream_en_ep;
252 u8 num_stream[30 / 2];
253
254 unsigned active:1;
255 unsigned old_active:1;
256 unsigned resuming:1;
257};
258
259struct dummy {
260 spinlock_t lock;
261
262
263
264
265 struct dummy_ep ep[DUMMY_ENDPOINTS];
266 int address;
267 int callback_usage;
268 struct usb_gadget gadget;
269 struct usb_gadget_driver *driver;
270 struct dummy_request fifo_req;
271 u8 fifo_buf[FIFO_SIZE];
272 u16 devstatus;
273 unsigned ints_enabled:1;
274 unsigned udc_suspended:1;
275 unsigned pullup:1;
276
277
278
279
280 struct dummy_hcd *hs_hcd;
281 struct dummy_hcd *ss_hcd;
282};
283
284static inline struct dummy_hcd *hcd_to_dummy_hcd(struct usb_hcd *hcd)
285{
286 return (struct dummy_hcd *) (hcd->hcd_priv);
287}
288
289static inline struct usb_hcd *dummy_hcd_to_hcd(struct dummy_hcd *dum)
290{
291 return container_of((void *) dum, struct usb_hcd, hcd_priv);
292}
293
294static inline struct device *dummy_dev(struct dummy_hcd *dum)
295{
296 return dummy_hcd_to_hcd(dum)->self.controller;
297}
298
299static inline struct device *udc_dev(struct dummy *dum)
300{
301 return dum->gadget.dev.parent;
302}
303
304static inline struct dummy *ep_to_dummy(struct dummy_ep *ep)
305{
306 return container_of(ep->gadget, struct dummy, gadget);
307}
308
309static inline struct dummy_hcd *gadget_to_dummy_hcd(struct usb_gadget *gadget)
310{
311 struct dummy *dum = container_of(gadget, struct dummy, gadget);
312 if (dum->gadget.speed == USB_SPEED_SUPER)
313 return dum->ss_hcd;
314 else
315 return dum->hs_hcd;
316}
317
318static inline struct dummy *gadget_dev_to_dummy(struct device *dev)
319{
320 return container_of(dev, struct dummy, gadget.dev);
321}
322
323
324
325
326
327
328static void nuke(struct dummy *dum, struct dummy_ep *ep)
329{
330 while (!list_empty(&ep->queue)) {
331 struct dummy_request *req;
332
333 req = list_entry(ep->queue.next, struct dummy_request, queue);
334 list_del_init(&req->queue);
335 req->req.status = -ESHUTDOWN;
336
337 spin_unlock(&dum->lock);
338 usb_gadget_giveback_request(&ep->ep, &req->req);
339 spin_lock(&dum->lock);
340 }
341}
342
343
344static void stop_activity(struct dummy *dum)
345{
346 int i;
347
348
349 dum->address = 0;
350
351
352
353
354 for (i = 0; i < DUMMY_ENDPOINTS; ++i)
355 nuke(dum, &dum->ep[i]);
356
357
358}
359
360
361
362
363
364
365
366
367
368static void set_link_state_by_speed(struct dummy_hcd *dum_hcd)
369{
370 struct dummy *dum = dum_hcd->dum;
371
372 if (dummy_hcd_to_hcd(dum_hcd)->speed == HCD_USB3) {
373 if ((dum_hcd->port_status & USB_SS_PORT_STAT_POWER) == 0) {
374 dum_hcd->port_status = 0;
375 } else if (!dum->pullup || dum->udc_suspended) {
376
377 dum_hcd->port_status &= ~(USB_PORT_STAT_CONNECTION |
378 USB_PORT_STAT_ENABLE);
379 if ((dum_hcd->old_status &
380 USB_PORT_STAT_CONNECTION) != 0)
381 dum_hcd->port_status |=
382 (USB_PORT_STAT_C_CONNECTION << 16);
383 } else {
384
385 dum_hcd->port_status |= (USB_PORT_STAT_CONNECTION |
386 USB_PORT_STAT_SPEED_5GBPS) ;
387 if ((dum_hcd->old_status &
388 USB_PORT_STAT_CONNECTION) == 0)
389 dum_hcd->port_status |=
390 (USB_PORT_STAT_C_CONNECTION << 16);
391 if ((dum_hcd->port_status & USB_PORT_STAT_ENABLE) &&
392 (dum_hcd->port_status &
393 USB_PORT_STAT_LINK_STATE) == USB_SS_PORT_LS_U0 &&
394 dum_hcd->rh_state != DUMMY_RH_SUSPENDED)
395 dum_hcd->active = 1;
396 }
397 } else {
398 if ((dum_hcd->port_status & USB_PORT_STAT_POWER) == 0) {
399 dum_hcd->port_status = 0;
400 } else if (!dum->pullup || dum->udc_suspended) {
401
402 dum_hcd->port_status &= ~(USB_PORT_STAT_CONNECTION |
403 USB_PORT_STAT_ENABLE |
404 USB_PORT_STAT_LOW_SPEED |
405 USB_PORT_STAT_HIGH_SPEED |
406 USB_PORT_STAT_SUSPEND);
407 if ((dum_hcd->old_status &
408 USB_PORT_STAT_CONNECTION) != 0)
409 dum_hcd->port_status |=
410 (USB_PORT_STAT_C_CONNECTION << 16);
411 } else {
412 dum_hcd->port_status |= USB_PORT_STAT_CONNECTION;
413 if ((dum_hcd->old_status &
414 USB_PORT_STAT_CONNECTION) == 0)
415 dum_hcd->port_status |=
416 (USB_PORT_STAT_C_CONNECTION << 16);
417 if ((dum_hcd->port_status & USB_PORT_STAT_ENABLE) == 0)
418 dum_hcd->port_status &= ~USB_PORT_STAT_SUSPEND;
419 else if ((dum_hcd->port_status &
420 USB_PORT_STAT_SUSPEND) == 0 &&
421 dum_hcd->rh_state != DUMMY_RH_SUSPENDED)
422 dum_hcd->active = 1;
423 }
424 }
425}
426
427
428static void set_link_state(struct dummy_hcd *dum_hcd)
429{
430 struct dummy *dum = dum_hcd->dum;
431 unsigned int power_bit;
432
433 dum_hcd->active = 0;
434 if (dum->pullup)
435 if ((dummy_hcd_to_hcd(dum_hcd)->speed == HCD_USB3 &&
436 dum->gadget.speed != USB_SPEED_SUPER) ||
437 (dummy_hcd_to_hcd(dum_hcd)->speed != HCD_USB3 &&
438 dum->gadget.speed == USB_SPEED_SUPER))
439 return;
440
441 set_link_state_by_speed(dum_hcd);
442 power_bit = (dummy_hcd_to_hcd(dum_hcd)->speed == HCD_USB3 ?
443 USB_SS_PORT_STAT_POWER : USB_PORT_STAT_POWER);
444
445 if ((dum_hcd->port_status & USB_PORT_STAT_ENABLE) == 0 ||
446 dum_hcd->active)
447 dum_hcd->resuming = 0;
448
449
450 if ((dum_hcd->port_status & power_bit) == 0 ||
451 (dum_hcd->port_status & USB_PORT_STAT_RESET) != 0) {
452 unsigned int disconnect = power_bit &
453 dum_hcd->old_status & (~dum_hcd->port_status);
454 unsigned int reset = USB_PORT_STAT_RESET &
455 (~dum_hcd->old_status) & dum_hcd->port_status;
456
457
458 if (dum->ints_enabled && (disconnect || reset)) {
459 stop_activity(dum);
460 ++dum->callback_usage;
461 spin_unlock(&dum->lock);
462 if (reset)
463 usb_gadget_udc_reset(&dum->gadget, dum->driver);
464 else
465 dum->driver->disconnect(&dum->gadget);
466 spin_lock(&dum->lock);
467 --dum->callback_usage;
468 }
469 } else if (dum_hcd->active != dum_hcd->old_active &&
470 dum->ints_enabled) {
471 ++dum->callback_usage;
472 spin_unlock(&dum->lock);
473 if (dum_hcd->old_active && dum->driver->suspend)
474 dum->driver->suspend(&dum->gadget);
475 else if (!dum_hcd->old_active && dum->driver->resume)
476 dum->driver->resume(&dum->gadget);
477 spin_lock(&dum->lock);
478 --dum->callback_usage;
479 }
480
481 dum_hcd->old_status = dum_hcd->port_status;
482 dum_hcd->old_active = dum_hcd->active;
483}
484
485
486
487
488
489
490
491
492
493
494#define is_enabled(dum) \
495 (dum->port_status & USB_PORT_STAT_ENABLE)
496
497static int dummy_enable(struct usb_ep *_ep,
498 const struct usb_endpoint_descriptor *desc)
499{
500 struct dummy *dum;
501 struct dummy_hcd *dum_hcd;
502 struct dummy_ep *ep;
503 unsigned max;
504 int retval;
505
506 ep = usb_ep_to_dummy_ep(_ep);
507 if (!_ep || !desc || ep->desc || _ep->name == ep0name
508 || desc->bDescriptorType != USB_DT_ENDPOINT)
509 return -EINVAL;
510 dum = ep_to_dummy(ep);
511 if (!dum->driver)
512 return -ESHUTDOWN;
513
514 dum_hcd = gadget_to_dummy_hcd(&dum->gadget);
515 if (!is_enabled(dum_hcd))
516 return -ESHUTDOWN;
517
518
519
520
521
522
523 max = usb_endpoint_maxp(desc);
524
525
526
527
528
529
530
531
532
533 retval = -EINVAL;
534 switch (usb_endpoint_type(desc)) {
535 case USB_ENDPOINT_XFER_BULK:
536 if (strstr(ep->ep.name, "-iso")
537 || strstr(ep->ep.name, "-int")) {
538 goto done;
539 }
540 switch (dum->gadget.speed) {
541 case USB_SPEED_SUPER:
542 if (max == 1024)
543 break;
544 goto done;
545 case USB_SPEED_HIGH:
546 if (max == 512)
547 break;
548 goto done;
549 case USB_SPEED_FULL:
550 if (max == 8 || max == 16 || max == 32 || max == 64)
551
552 break;
553
554 default:
555 goto done;
556 }
557 break;
558 case USB_ENDPOINT_XFER_INT:
559 if (strstr(ep->ep.name, "-iso"))
560 goto done;
561
562 switch (dum->gadget.speed) {
563 case USB_SPEED_SUPER:
564 case USB_SPEED_HIGH:
565 if (max <= 1024)
566 break;
567
568
569 case USB_SPEED_FULL:
570 if (max <= 64)
571 break;
572
573
574 default:
575 if (max <= 8)
576 break;
577 goto done;
578 }
579 break;
580 case USB_ENDPOINT_XFER_ISOC:
581 if (strstr(ep->ep.name, "-bulk")
582 || strstr(ep->ep.name, "-int"))
583 goto done;
584
585 switch (dum->gadget.speed) {
586 case USB_SPEED_SUPER:
587 case USB_SPEED_HIGH:
588 if (max <= 1024)
589 break;
590
591
592 case USB_SPEED_FULL:
593 if (max <= 1023)
594 break;
595
596 default:
597 goto done;
598 }
599 break;
600 default:
601
602 goto done;
603 }
604
605 _ep->maxpacket = max;
606 if (usb_ss_max_streams(_ep->comp_desc)) {
607 if (!usb_endpoint_xfer_bulk(desc)) {
608 dev_err(udc_dev(dum), "Can't enable stream support on "
609 "non-bulk ep %s\n", _ep->name);
610 return -EINVAL;
611 }
612 ep->stream_en = 1;
613 }
614 ep->desc = desc;
615
616 dev_dbg(udc_dev(dum), "enabled %s (ep%d%s-%s) maxpacket %d stream %s\n",
617 _ep->name,
618 desc->bEndpointAddress & 0x0f,
619 (desc->bEndpointAddress & USB_DIR_IN) ? "in" : "out",
620 usb_ep_type_string(usb_endpoint_type(desc)),
621 max, ep->stream_en ? "enabled" : "disabled");
622
623
624
625
626 ep->halted = ep->wedged = 0;
627 retval = 0;
628done:
629 return retval;
630}
631
632static int dummy_disable(struct usb_ep *_ep)
633{
634 struct dummy_ep *ep;
635 struct dummy *dum;
636 unsigned long flags;
637
638 ep = usb_ep_to_dummy_ep(_ep);
639 if (!_ep || !ep->desc || _ep->name == ep0name)
640 return -EINVAL;
641 dum = ep_to_dummy(ep);
642
643 spin_lock_irqsave(&dum->lock, flags);
644 ep->desc = NULL;
645 ep->stream_en = 0;
646 nuke(dum, ep);
647 spin_unlock_irqrestore(&dum->lock, flags);
648
649 dev_dbg(udc_dev(dum), "disabled %s\n", _ep->name);
650 return 0;
651}
652
653static struct usb_request *dummy_alloc_request(struct usb_ep *_ep,
654 gfp_t mem_flags)
655{
656 struct dummy_request *req;
657
658 if (!_ep)
659 return NULL;
660
661 req = kzalloc(sizeof(*req), mem_flags);
662 if (!req)
663 return NULL;
664 INIT_LIST_HEAD(&req->queue);
665 return &req->req;
666}
667
668static void dummy_free_request(struct usb_ep *_ep, struct usb_request *_req)
669{
670 struct dummy_request *req;
671
672 if (!_ep || !_req) {
673 WARN_ON(1);
674 return;
675 }
676
677 req = usb_request_to_dummy_request(_req);
678 WARN_ON(!list_empty(&req->queue));
679 kfree(req);
680}
681
682static void fifo_complete(struct usb_ep *ep, struct usb_request *req)
683{
684}
685
686static int dummy_queue(struct usb_ep *_ep, struct usb_request *_req,
687 gfp_t mem_flags)
688{
689 struct dummy_ep *ep;
690 struct dummy_request *req;
691 struct dummy *dum;
692 struct dummy_hcd *dum_hcd;
693 unsigned long flags;
694
695 req = usb_request_to_dummy_request(_req);
696 if (!_req || !list_empty(&req->queue) || !_req->complete)
697 return -EINVAL;
698
699 ep = usb_ep_to_dummy_ep(_ep);
700 if (!_ep || (!ep->desc && _ep->name != ep0name))
701 return -EINVAL;
702
703 dum = ep_to_dummy(ep);
704 dum_hcd = gadget_to_dummy_hcd(&dum->gadget);
705 if (!dum->driver || !is_enabled(dum_hcd))
706 return -ESHUTDOWN;
707
708#if 0
709 dev_dbg(udc_dev(dum), "ep %p queue req %p to %s, len %d buf %p\n",
710 ep, _req, _ep->name, _req->length, _req->buf);
711#endif
712 _req->status = -EINPROGRESS;
713 _req->actual = 0;
714 spin_lock_irqsave(&dum->lock, flags);
715
716
717 if (ep->desc && (ep->desc->bEndpointAddress & USB_DIR_IN) &&
718 list_empty(&dum->fifo_req.queue) &&
719 list_empty(&ep->queue) &&
720 _req->length <= FIFO_SIZE) {
721 req = &dum->fifo_req;
722 req->req = *_req;
723 req->req.buf = dum->fifo_buf;
724 memcpy(dum->fifo_buf, _req->buf, _req->length);
725 req->req.context = dum;
726 req->req.complete = fifo_complete;
727
728 list_add_tail(&req->queue, &ep->queue);
729 spin_unlock(&dum->lock);
730 _req->actual = _req->length;
731 _req->status = 0;
732 usb_gadget_giveback_request(_ep, _req);
733 spin_lock(&dum->lock);
734 } else
735 list_add_tail(&req->queue, &ep->queue);
736 spin_unlock_irqrestore(&dum->lock, flags);
737
738
739
740
741 return 0;
742}
743
744static int dummy_dequeue(struct usb_ep *_ep, struct usb_request *_req)
745{
746 struct dummy_ep *ep;
747 struct dummy *dum;
748 int retval = -EINVAL;
749 unsigned long flags;
750 struct dummy_request *req = NULL;
751
752 if (!_ep || !_req)
753 return retval;
754 ep = usb_ep_to_dummy_ep(_ep);
755 dum = ep_to_dummy(ep);
756
757 if (!dum->driver)
758 return -ESHUTDOWN;
759
760 local_irq_save(flags);
761 spin_lock(&dum->lock);
762 list_for_each_entry(req, &ep->queue, queue) {
763 if (&req->req == _req) {
764 list_del_init(&req->queue);
765 _req->status = -ECONNRESET;
766 retval = 0;
767 break;
768 }
769 }
770 spin_unlock(&dum->lock);
771
772 if (retval == 0) {
773 dev_dbg(udc_dev(dum),
774 "dequeued req %p from %s, len %d buf %p\n",
775 req, _ep->name, _req->length, _req->buf);
776 usb_gadget_giveback_request(_ep, _req);
777 }
778 local_irq_restore(flags);
779 return retval;
780}
781
782static int
783dummy_set_halt_and_wedge(struct usb_ep *_ep, int value, int wedged)
784{
785 struct dummy_ep *ep;
786 struct dummy *dum;
787
788 if (!_ep)
789 return -EINVAL;
790 ep = usb_ep_to_dummy_ep(_ep);
791 dum = ep_to_dummy(ep);
792 if (!dum->driver)
793 return -ESHUTDOWN;
794 if (!value)
795 ep->halted = ep->wedged = 0;
796 else if (ep->desc && (ep->desc->bEndpointAddress & USB_DIR_IN) &&
797 !list_empty(&ep->queue))
798 return -EAGAIN;
799 else {
800 ep->halted = 1;
801 if (wedged)
802 ep->wedged = 1;
803 }
804
805 return 0;
806}
807
808static int
809dummy_set_halt(struct usb_ep *_ep, int value)
810{
811 return dummy_set_halt_and_wedge(_ep, value, 0);
812}
813
814static int dummy_set_wedge(struct usb_ep *_ep)
815{
816 if (!_ep || _ep->name == ep0name)
817 return -EINVAL;
818 return dummy_set_halt_and_wedge(_ep, 1, 1);
819}
820
821static const struct usb_ep_ops dummy_ep_ops = {
822 .enable = dummy_enable,
823 .disable = dummy_disable,
824
825 .alloc_request = dummy_alloc_request,
826 .free_request = dummy_free_request,
827
828 .queue = dummy_queue,
829 .dequeue = dummy_dequeue,
830
831 .set_halt = dummy_set_halt,
832 .set_wedge = dummy_set_wedge,
833};
834
835
836
837
838static int dummy_g_get_frame(struct usb_gadget *_gadget)
839{
840 struct timespec64 ts64;
841
842 ktime_get_ts64(&ts64);
843 return ts64.tv_nsec / NSEC_PER_MSEC;
844}
845
846static int dummy_wakeup(struct usb_gadget *_gadget)
847{
848 struct dummy_hcd *dum_hcd;
849
850 dum_hcd = gadget_to_dummy_hcd(_gadget);
851 if (!(dum_hcd->dum->devstatus & ((1 << USB_DEVICE_B_HNP_ENABLE)
852 | (1 << USB_DEVICE_REMOTE_WAKEUP))))
853 return -EINVAL;
854 if ((dum_hcd->port_status & USB_PORT_STAT_CONNECTION) == 0)
855 return -ENOLINK;
856 if ((dum_hcd->port_status & USB_PORT_STAT_SUSPEND) == 0 &&
857 dum_hcd->rh_state != DUMMY_RH_SUSPENDED)
858 return -EIO;
859
860
861
862
863 dum_hcd->resuming = 1;
864 dum_hcd->re_timeout = jiffies + msecs_to_jiffies(20);
865 mod_timer(&dummy_hcd_to_hcd(dum_hcd)->rh_timer, dum_hcd->re_timeout);
866 return 0;
867}
868
869static int dummy_set_selfpowered(struct usb_gadget *_gadget, int value)
870{
871 struct dummy *dum;
872
873 _gadget->is_selfpowered = (value != 0);
874 dum = gadget_to_dummy_hcd(_gadget)->dum;
875 if (value)
876 dum->devstatus |= (1 << USB_DEVICE_SELF_POWERED);
877 else
878 dum->devstatus &= ~(1 << USB_DEVICE_SELF_POWERED);
879 return 0;
880}
881
882static void dummy_udc_update_ep0(struct dummy *dum)
883{
884 if (dum->gadget.speed == USB_SPEED_SUPER)
885 dum->ep[0].ep.maxpacket = 9;
886 else
887 dum->ep[0].ep.maxpacket = 64;
888}
889
890static int dummy_pullup(struct usb_gadget *_gadget, int value)
891{
892 struct dummy_hcd *dum_hcd;
893 struct dummy *dum;
894 unsigned long flags;
895
896 dum = gadget_dev_to_dummy(&_gadget->dev);
897 dum_hcd = gadget_to_dummy_hcd(_gadget);
898
899 spin_lock_irqsave(&dum->lock, flags);
900 dum->pullup = (value != 0);
901 set_link_state(dum_hcd);
902 spin_unlock_irqrestore(&dum->lock, flags);
903
904 usb_hcd_poll_rh_status(dummy_hcd_to_hcd(dum_hcd));
905 return 0;
906}
907
908static void dummy_udc_set_speed(struct usb_gadget *_gadget,
909 enum usb_device_speed speed)
910{
911 struct dummy *dum;
912
913 dum = gadget_dev_to_dummy(&_gadget->dev);
914 dum->gadget.speed = speed;
915 dummy_udc_update_ep0(dum);
916}
917
918static int dummy_udc_start(struct usb_gadget *g,
919 struct usb_gadget_driver *driver);
920static int dummy_udc_stop(struct usb_gadget *g);
921
922static const struct usb_gadget_ops dummy_ops = {
923 .get_frame = dummy_g_get_frame,
924 .wakeup = dummy_wakeup,
925 .set_selfpowered = dummy_set_selfpowered,
926 .pullup = dummy_pullup,
927 .udc_start = dummy_udc_start,
928 .udc_stop = dummy_udc_stop,
929 .udc_set_speed = dummy_udc_set_speed,
930};
931
932
933
934
935static ssize_t function_show(struct device *dev, struct device_attribute *attr,
936 char *buf)
937{
938 struct dummy *dum = gadget_dev_to_dummy(dev);
939
940 if (!dum->driver || !dum->driver->function)
941 return 0;
942 return scnprintf(buf, PAGE_SIZE, "%s\n", dum->driver->function);
943}
944static DEVICE_ATTR_RO(function);
945
946
947
948
949
950
951
952
953
954
955
956
957
958
959
960
961
962static int dummy_udc_start(struct usb_gadget *g,
963 struct usb_gadget_driver *driver)
964{
965 struct dummy_hcd *dum_hcd = gadget_to_dummy_hcd(g);
966 struct dummy *dum = dum_hcd->dum;
967
968 switch (g->speed) {
969
970 case USB_SPEED_LOW:
971 case USB_SPEED_FULL:
972 case USB_SPEED_HIGH:
973 case USB_SPEED_SUPER:
974 break;
975 default:
976 dev_err(dummy_dev(dum_hcd), "Unsupported driver max speed %d\n",
977 driver->max_speed);
978 return -EINVAL;
979 }
980
981
982
983
984
985
986 spin_lock_irq(&dum->lock);
987 dum->devstatus = 0;
988 dum->driver = driver;
989 dum->ints_enabled = 1;
990 spin_unlock_irq(&dum->lock);
991
992 return 0;
993}
994
995static int dummy_udc_stop(struct usb_gadget *g)
996{
997 struct dummy_hcd *dum_hcd = gadget_to_dummy_hcd(g);
998 struct dummy *dum = dum_hcd->dum;
999
1000 spin_lock_irq(&dum->lock);
1001 dum->ints_enabled = 0;
1002 stop_activity(dum);
1003
1004
1005 while (dum->callback_usage > 0) {
1006 spin_unlock_irq(&dum->lock);
1007 usleep_range(1000, 2000);
1008 spin_lock_irq(&dum->lock);
1009 }
1010
1011 dum->driver = NULL;
1012 spin_unlock_irq(&dum->lock);
1013
1014 return 0;
1015}
1016
1017#undef is_enabled
1018
1019
1020
1021static void init_dummy_udc_hw(struct dummy *dum)
1022{
1023 int i;
1024
1025 INIT_LIST_HEAD(&dum->gadget.ep_list);
1026 for (i = 0; i < DUMMY_ENDPOINTS; i++) {
1027 struct dummy_ep *ep = &dum->ep[i];
1028
1029 if (!ep_info[i].name)
1030 break;
1031 ep->ep.name = ep_info[i].name;
1032 ep->ep.caps = ep_info[i].caps;
1033 ep->ep.ops = &dummy_ep_ops;
1034 list_add_tail(&ep->ep.ep_list, &dum->gadget.ep_list);
1035 ep->halted = ep->wedged = ep->already_seen =
1036 ep->setup_stage = 0;
1037 usb_ep_set_maxpacket_limit(&ep->ep, ~0);
1038 ep->ep.max_streams = 16;
1039 ep->last_io = jiffies;
1040 ep->gadget = &dum->gadget;
1041 ep->desc = NULL;
1042 INIT_LIST_HEAD(&ep->queue);
1043 }
1044
1045 dum->gadget.ep0 = &dum->ep[0].ep;
1046 list_del_init(&dum->ep[0].ep.ep_list);
1047 INIT_LIST_HEAD(&dum->fifo_req.queue);
1048
1049#ifdef CONFIG_USB_OTG
1050 dum->gadget.is_otg = 1;
1051#endif
1052}
1053
1054static int dummy_udc_probe(struct platform_device *pdev)
1055{
1056 struct dummy *dum;
1057 int rc;
1058
1059 dum = *((void **)dev_get_platdata(&pdev->dev));
1060
1061 memzero_explicit(&dum->gadget, sizeof(struct usb_gadget));
1062 dum->gadget.name = gadget_name;
1063 dum->gadget.ops = &dummy_ops;
1064 if (mod_data.is_super_speed)
1065 dum->gadget.max_speed = USB_SPEED_SUPER;
1066 else if (mod_data.is_high_speed)
1067 dum->gadget.max_speed = USB_SPEED_HIGH;
1068 else
1069 dum->gadget.max_speed = USB_SPEED_FULL;
1070
1071 dum->gadget.dev.parent = &pdev->dev;
1072 init_dummy_udc_hw(dum);
1073
1074 rc = usb_add_gadget_udc(&pdev->dev, &dum->gadget);
1075 if (rc < 0)
1076 goto err_udc;
1077
1078 rc = device_create_file(&dum->gadget.dev, &dev_attr_function);
1079 if (rc < 0)
1080 goto err_dev;
1081 platform_set_drvdata(pdev, dum);
1082 return rc;
1083
1084err_dev:
1085 usb_del_gadget_udc(&dum->gadget);
1086err_udc:
1087 return rc;
1088}
1089
1090static int dummy_udc_remove(struct platform_device *pdev)
1091{
1092 struct dummy *dum = platform_get_drvdata(pdev);
1093
1094 device_remove_file(&dum->gadget.dev, &dev_attr_function);
1095 usb_del_gadget_udc(&dum->gadget);
1096 return 0;
1097}
1098
1099static void dummy_udc_pm(struct dummy *dum, struct dummy_hcd *dum_hcd,
1100 int suspend)
1101{
1102 spin_lock_irq(&dum->lock);
1103 dum->udc_suspended = suspend;
1104 set_link_state(dum_hcd);
1105 spin_unlock_irq(&dum->lock);
1106}
1107
1108static int dummy_udc_suspend(struct platform_device *pdev, pm_message_t state)
1109{
1110 struct dummy *dum = platform_get_drvdata(pdev);
1111 struct dummy_hcd *dum_hcd = gadget_to_dummy_hcd(&dum->gadget);
1112
1113 dev_dbg(&pdev->dev, "%s\n", __func__);
1114 dummy_udc_pm(dum, dum_hcd, 1);
1115 usb_hcd_poll_rh_status(dummy_hcd_to_hcd(dum_hcd));
1116 return 0;
1117}
1118
1119static int dummy_udc_resume(struct platform_device *pdev)
1120{
1121 struct dummy *dum = platform_get_drvdata(pdev);
1122 struct dummy_hcd *dum_hcd = gadget_to_dummy_hcd(&dum->gadget);
1123
1124 dev_dbg(&pdev->dev, "%s\n", __func__);
1125 dummy_udc_pm(dum, dum_hcd, 0);
1126 usb_hcd_poll_rh_status(dummy_hcd_to_hcd(dum_hcd));
1127 return 0;
1128}
1129
1130static struct platform_driver dummy_udc_driver = {
1131 .probe = dummy_udc_probe,
1132 .remove = dummy_udc_remove,
1133 .suspend = dummy_udc_suspend,
1134 .resume = dummy_udc_resume,
1135 .driver = {
1136 .name = (char *) gadget_name,
1137 },
1138};
1139
1140
1141
1142static unsigned int dummy_get_ep_idx(const struct usb_endpoint_descriptor *desc)
1143{
1144 unsigned int index;
1145
1146 index = usb_endpoint_num(desc) << 1;
1147 if (usb_endpoint_dir_in(desc))
1148 index |= 1;
1149 return index;
1150}
1151
1152
1153
1154
1155
1156
1157
1158
1159
1160
1161
1162
1163
1164static int dummy_ep_stream_en(struct dummy_hcd *dum_hcd, struct urb *urb)
1165{
1166 const struct usb_endpoint_descriptor *desc = &urb->ep->desc;
1167 u32 index;
1168
1169 if (!usb_endpoint_xfer_bulk(desc))
1170 return 0;
1171
1172 index = dummy_get_ep_idx(desc);
1173 return (1 << index) & dum_hcd->stream_en_ep;
1174}
1175
1176
1177
1178
1179
1180
1181
1182
1183static int get_max_streams_for_pipe(struct dummy_hcd *dum_hcd,
1184 unsigned int pipe)
1185{
1186 int max_streams;
1187
1188 max_streams = dum_hcd->num_stream[usb_pipeendpoint(pipe)];
1189 if (usb_pipeout(pipe))
1190 max_streams >>= 4;
1191 else
1192 max_streams &= 0xf;
1193 max_streams++;
1194 return max_streams;
1195}
1196
1197static void set_max_streams_for_pipe(struct dummy_hcd *dum_hcd,
1198 unsigned int pipe, unsigned int streams)
1199{
1200 int max_streams;
1201
1202 streams--;
1203 max_streams = dum_hcd->num_stream[usb_pipeendpoint(pipe)];
1204 if (usb_pipeout(pipe)) {
1205 streams <<= 4;
1206 max_streams &= 0xf;
1207 } else {
1208 max_streams &= 0xf0;
1209 }
1210 max_streams |= streams;
1211 dum_hcd->num_stream[usb_pipeendpoint(pipe)] = max_streams;
1212}
1213
1214static int dummy_validate_stream(struct dummy_hcd *dum_hcd, struct urb *urb)
1215{
1216 unsigned int max_streams;
1217 int enabled;
1218
1219 enabled = dummy_ep_stream_en(dum_hcd, urb);
1220 if (!urb->stream_id) {
1221 if (enabled)
1222 return -EINVAL;
1223 return 0;
1224 }
1225 if (!enabled)
1226 return -EINVAL;
1227
1228 max_streams = get_max_streams_for_pipe(dum_hcd,
1229 usb_pipeendpoint(urb->pipe));
1230 if (urb->stream_id > max_streams) {
1231 dev_err(dummy_dev(dum_hcd), "Stream id %d is out of range.\n",
1232 urb->stream_id);
1233 BUG();
1234 return -EINVAL;
1235 }
1236 return 0;
1237}
1238
1239static int dummy_urb_enqueue(
1240 struct usb_hcd *hcd,
1241 struct urb *urb,
1242 gfp_t mem_flags
1243) {
1244 struct dummy_hcd *dum_hcd;
1245 struct urbp *urbp;
1246 unsigned long flags;
1247 int rc;
1248
1249 urbp = kmalloc(sizeof *urbp, mem_flags);
1250 if (!urbp)
1251 return -ENOMEM;
1252 urbp->urb = urb;
1253 urbp->miter_started = 0;
1254
1255 dum_hcd = hcd_to_dummy_hcd(hcd);
1256 spin_lock_irqsave(&dum_hcd->dum->lock, flags);
1257
1258 rc = dummy_validate_stream(dum_hcd, urb);
1259 if (rc) {
1260 kfree(urbp);
1261 goto done;
1262 }
1263
1264 rc = usb_hcd_link_urb_to_ep(hcd, urb);
1265 if (rc) {
1266 kfree(urbp);
1267 goto done;
1268 }
1269
1270 if (!dum_hcd->udev) {
1271 dum_hcd->udev = urb->dev;
1272 usb_get_dev(dum_hcd->udev);
1273 } else if (unlikely(dum_hcd->udev != urb->dev))
1274 dev_err(dummy_dev(dum_hcd), "usb_device address has changed!\n");
1275
1276 list_add_tail(&urbp->urbp_list, &dum_hcd->urbp_list);
1277 urb->hcpriv = urbp;
1278 if (!dum_hcd->next_frame_urbp)
1279 dum_hcd->next_frame_urbp = urbp;
1280 if (usb_pipetype(urb->pipe) == PIPE_CONTROL)
1281 urb->error_count = 1;
1282
1283
1284 if (!timer_pending(&dum_hcd->timer))
1285 mod_timer(&dum_hcd->timer, jiffies + 1);
1286
1287 done:
1288 spin_unlock_irqrestore(&dum_hcd->dum->lock, flags);
1289 return rc;
1290}
1291
1292static int dummy_urb_dequeue(struct usb_hcd *hcd, struct urb *urb, int status)
1293{
1294 struct dummy_hcd *dum_hcd;
1295 unsigned long flags;
1296 int rc;
1297
1298
1299
1300 dum_hcd = hcd_to_dummy_hcd(hcd);
1301 spin_lock_irqsave(&dum_hcd->dum->lock, flags);
1302
1303 rc = usb_hcd_check_unlink_urb(hcd, urb, status);
1304 if (!rc && dum_hcd->rh_state != DUMMY_RH_RUNNING &&
1305 !list_empty(&dum_hcd->urbp_list))
1306 mod_timer(&dum_hcd->timer, jiffies);
1307
1308 spin_unlock_irqrestore(&dum_hcd->dum->lock, flags);
1309 return rc;
1310}
1311
1312static int dummy_perform_transfer(struct urb *urb, struct dummy_request *req,
1313 u32 len)
1314{
1315 void *ubuf, *rbuf;
1316 struct urbp *urbp = urb->hcpriv;
1317 int to_host;
1318 struct sg_mapping_iter *miter = &urbp->miter;
1319 u32 trans = 0;
1320 u32 this_sg;
1321 bool next_sg;
1322
1323 to_host = usb_pipein(urb->pipe);
1324 rbuf = req->req.buf + req->req.actual;
1325
1326 if (!urb->num_sgs) {
1327 ubuf = urb->transfer_buffer + urb->actual_length;
1328 if (to_host)
1329 memcpy(ubuf, rbuf, len);
1330 else
1331 memcpy(rbuf, ubuf, len);
1332 return len;
1333 }
1334
1335 if (!urbp->miter_started) {
1336 u32 flags = SG_MITER_ATOMIC;
1337
1338 if (to_host)
1339 flags |= SG_MITER_TO_SG;
1340 else
1341 flags |= SG_MITER_FROM_SG;
1342
1343 sg_miter_start(miter, urb->sg, urb->num_sgs, flags);
1344 urbp->miter_started = 1;
1345 }
1346 next_sg = sg_miter_next(miter);
1347 if (next_sg == false) {
1348 WARN_ON_ONCE(1);
1349 return -EINVAL;
1350 }
1351 do {
1352 ubuf = miter->addr;
1353 this_sg = min_t(u32, len, miter->length);
1354 miter->consumed = this_sg;
1355 trans += this_sg;
1356
1357 if (to_host)
1358 memcpy(ubuf, rbuf, this_sg);
1359 else
1360 memcpy(rbuf, ubuf, this_sg);
1361 len -= this_sg;
1362
1363 if (!len)
1364 break;
1365 next_sg = sg_miter_next(miter);
1366 if (next_sg == false) {
1367 WARN_ON_ONCE(1);
1368 return -EINVAL;
1369 }
1370
1371 rbuf += this_sg;
1372 } while (1);
1373
1374 sg_miter_stop(miter);
1375 return trans;
1376}
1377
1378
1379static int transfer(struct dummy_hcd *dum_hcd, struct urb *urb,
1380 struct dummy_ep *ep, int limit, int *status)
1381{
1382 struct dummy *dum = dum_hcd->dum;
1383 struct dummy_request *req;
1384 int sent = 0;
1385
1386top:
1387
1388 list_for_each_entry(req, &ep->queue, queue) {
1389 unsigned host_len, dev_len, len;
1390 int is_short, to_host;
1391 int rescan = 0;
1392
1393 if (dummy_ep_stream_en(dum_hcd, urb)) {
1394 if ((urb->stream_id != req->req.stream_id))
1395 continue;
1396 }
1397
1398
1399
1400
1401
1402
1403
1404
1405 host_len = urb->transfer_buffer_length - urb->actual_length;
1406 dev_len = req->req.length - req->req.actual;
1407 len = min(host_len, dev_len);
1408
1409
1410
1411 to_host = usb_pipein(urb->pipe);
1412 if (unlikely(len == 0))
1413 is_short = 1;
1414 else {
1415
1416 if (limit < ep->ep.maxpacket && limit < len)
1417 break;
1418 len = min_t(unsigned, len, limit);
1419 if (len == 0)
1420 break;
1421
1422
1423 if (len >= ep->ep.maxpacket) {
1424 is_short = 0;
1425 if (len % ep->ep.maxpacket)
1426 rescan = 1;
1427 len -= len % ep->ep.maxpacket;
1428 } else {
1429 is_short = 1;
1430 }
1431
1432 len = dummy_perform_transfer(urb, req, len);
1433
1434 ep->last_io = jiffies;
1435 if ((int)len < 0) {
1436 req->req.status = len;
1437 } else {
1438 limit -= len;
1439 sent += len;
1440 urb->actual_length += len;
1441 req->req.actual += len;
1442 }
1443 }
1444
1445
1446
1447
1448
1449
1450
1451
1452 if (is_short) {
1453 if (host_len == dev_len) {
1454 req->req.status = 0;
1455 *status = 0;
1456 } else if (to_host) {
1457 req->req.status = 0;
1458 if (dev_len > host_len)
1459 *status = -EOVERFLOW;
1460 else
1461 *status = 0;
1462 } else {
1463 *status = 0;
1464 if (host_len > dev_len)
1465 req->req.status = -EOVERFLOW;
1466 else
1467 req->req.status = 0;
1468 }
1469
1470
1471
1472
1473
1474 } else {
1475 if (req->req.length == req->req.actual) {
1476 if (req->req.zero && to_host)
1477 rescan = 1;
1478 else
1479 req->req.status = 0;
1480 }
1481 if (urb->transfer_buffer_length == urb->actual_length) {
1482 if (urb->transfer_flags & URB_ZERO_PACKET &&
1483 !to_host)
1484 rescan = 1;
1485 else
1486 *status = 0;
1487 }
1488 }
1489
1490
1491 if (req->req.status != -EINPROGRESS) {
1492 list_del_init(&req->queue);
1493
1494 spin_unlock(&dum->lock);
1495 usb_gadget_giveback_request(&ep->ep, &req->req);
1496 spin_lock(&dum->lock);
1497
1498
1499 rescan = 1;
1500 }
1501
1502
1503 if (*status != -EINPROGRESS)
1504 break;
1505
1506
1507 if (rescan)
1508 goto top;
1509 }
1510 return sent;
1511}
1512
1513static int periodic_bytes(struct dummy *dum, struct dummy_ep *ep)
1514{
1515 int limit = ep->ep.maxpacket;
1516
1517 if (dum->gadget.speed == USB_SPEED_HIGH) {
1518 int tmp;
1519
1520
1521 tmp = usb_endpoint_maxp_mult(ep->desc);
1522 tmp *= 8 ;
1523 limit += limit * tmp;
1524 }
1525 if (dum->gadget.speed == USB_SPEED_SUPER) {
1526 switch (usb_endpoint_type(ep->desc)) {
1527 case USB_ENDPOINT_XFER_ISOC:
1528
1529 limit = 3 * 16 * 1024 * 8;
1530 break;
1531 case USB_ENDPOINT_XFER_INT:
1532
1533 limit = 3 * 1024 * 8;
1534 break;
1535 case USB_ENDPOINT_XFER_BULK:
1536 default:
1537 break;
1538 }
1539 }
1540 return limit;
1541}
1542
1543#define is_active(dum_hcd) ((dum_hcd->port_status & \
1544 (USB_PORT_STAT_CONNECTION | USB_PORT_STAT_ENABLE | \
1545 USB_PORT_STAT_SUSPEND)) \
1546 == (USB_PORT_STAT_CONNECTION | USB_PORT_STAT_ENABLE))
1547
1548static struct dummy_ep *find_endpoint(struct dummy *dum, u8 address)
1549{
1550 int i;
1551
1552 if (!is_active((dum->gadget.speed == USB_SPEED_SUPER ?
1553 dum->ss_hcd : dum->hs_hcd)))
1554 return NULL;
1555 if (!dum->ints_enabled)
1556 return NULL;
1557 if ((address & ~USB_DIR_IN) == 0)
1558 return &dum->ep[0];
1559 for (i = 1; i < DUMMY_ENDPOINTS; i++) {
1560 struct dummy_ep *ep = &dum->ep[i];
1561
1562 if (!ep->desc)
1563 continue;
1564 if (ep->desc->bEndpointAddress == address)
1565 return ep;
1566 }
1567 return NULL;
1568}
1569
1570#undef is_active
1571
1572#define Dev_Request (USB_TYPE_STANDARD | USB_RECIP_DEVICE)
1573#define Dev_InRequest (Dev_Request | USB_DIR_IN)
1574#define Intf_Request (USB_TYPE_STANDARD | USB_RECIP_INTERFACE)
1575#define Intf_InRequest (Intf_Request | USB_DIR_IN)
1576#define Ep_Request (USB_TYPE_STANDARD | USB_RECIP_ENDPOINT)
1577#define Ep_InRequest (Ep_Request | USB_DIR_IN)
1578
1579
1580
1581
1582
1583
1584
1585
1586
1587
1588
1589
1590
1591
1592static int handle_control_request(struct dummy_hcd *dum_hcd, struct urb *urb,
1593 struct usb_ctrlrequest *setup,
1594 int *status)
1595{
1596 struct dummy_ep *ep2;
1597 struct dummy *dum = dum_hcd->dum;
1598 int ret_val = 1;
1599 unsigned w_index;
1600 unsigned w_value;
1601
1602 w_index = le16_to_cpu(setup->wIndex);
1603 w_value = le16_to_cpu(setup->wValue);
1604 switch (setup->bRequest) {
1605 case USB_REQ_SET_ADDRESS:
1606 if (setup->bRequestType != Dev_Request)
1607 break;
1608 dum->address = w_value;
1609 *status = 0;
1610 dev_dbg(udc_dev(dum), "set_address = %d\n",
1611 w_value);
1612 ret_val = 0;
1613 break;
1614 case USB_REQ_SET_FEATURE:
1615 if (setup->bRequestType == Dev_Request) {
1616 ret_val = 0;
1617 switch (w_value) {
1618 case USB_DEVICE_REMOTE_WAKEUP:
1619 break;
1620 case USB_DEVICE_B_HNP_ENABLE:
1621 dum->gadget.b_hnp_enable = 1;
1622 break;
1623 case USB_DEVICE_A_HNP_SUPPORT:
1624 dum->gadget.a_hnp_support = 1;
1625 break;
1626 case USB_DEVICE_A_ALT_HNP_SUPPORT:
1627 dum->gadget.a_alt_hnp_support = 1;
1628 break;
1629 case USB_DEVICE_U1_ENABLE:
1630 if (dummy_hcd_to_hcd(dum_hcd)->speed ==
1631 HCD_USB3)
1632 w_value = USB_DEV_STAT_U1_ENABLED;
1633 else
1634 ret_val = -EOPNOTSUPP;
1635 break;
1636 case USB_DEVICE_U2_ENABLE:
1637 if (dummy_hcd_to_hcd(dum_hcd)->speed ==
1638 HCD_USB3)
1639 w_value = USB_DEV_STAT_U2_ENABLED;
1640 else
1641 ret_val = -EOPNOTSUPP;
1642 break;
1643 case USB_DEVICE_LTM_ENABLE:
1644 if (dummy_hcd_to_hcd(dum_hcd)->speed ==
1645 HCD_USB3)
1646 w_value = USB_DEV_STAT_LTM_ENABLED;
1647 else
1648 ret_val = -EOPNOTSUPP;
1649 break;
1650 default:
1651 ret_val = -EOPNOTSUPP;
1652 }
1653 if (ret_val == 0) {
1654 dum->devstatus |= (1 << w_value);
1655 *status = 0;
1656 }
1657 } else if (setup->bRequestType == Ep_Request) {
1658
1659 ep2 = find_endpoint(dum, w_index);
1660 if (!ep2 || ep2->ep.name == ep0name) {
1661 ret_val = -EOPNOTSUPP;
1662 break;
1663 }
1664 ep2->halted = 1;
1665 ret_val = 0;
1666 *status = 0;
1667 }
1668 break;
1669 case USB_REQ_CLEAR_FEATURE:
1670 if (setup->bRequestType == Dev_Request) {
1671 ret_val = 0;
1672 switch (w_value) {
1673 case USB_DEVICE_REMOTE_WAKEUP:
1674 w_value = USB_DEVICE_REMOTE_WAKEUP;
1675 break;
1676 case USB_DEVICE_U1_ENABLE:
1677 if (dummy_hcd_to_hcd(dum_hcd)->speed ==
1678 HCD_USB3)
1679 w_value = USB_DEV_STAT_U1_ENABLED;
1680 else
1681 ret_val = -EOPNOTSUPP;
1682 break;
1683 case USB_DEVICE_U2_ENABLE:
1684 if (dummy_hcd_to_hcd(dum_hcd)->speed ==
1685 HCD_USB3)
1686 w_value = USB_DEV_STAT_U2_ENABLED;
1687 else
1688 ret_val = -EOPNOTSUPP;
1689 break;
1690 case USB_DEVICE_LTM_ENABLE:
1691 if (dummy_hcd_to_hcd(dum_hcd)->speed ==
1692 HCD_USB3)
1693 w_value = USB_DEV_STAT_LTM_ENABLED;
1694 else
1695 ret_val = -EOPNOTSUPP;
1696 break;
1697 default:
1698 ret_val = -EOPNOTSUPP;
1699 break;
1700 }
1701 if (ret_val == 0) {
1702 dum->devstatus &= ~(1 << w_value);
1703 *status = 0;
1704 }
1705 } else if (setup->bRequestType == Ep_Request) {
1706
1707 ep2 = find_endpoint(dum, w_index);
1708 if (!ep2) {
1709 ret_val = -EOPNOTSUPP;
1710 break;
1711 }
1712 if (!ep2->wedged)
1713 ep2->halted = 0;
1714 ret_val = 0;
1715 *status = 0;
1716 }
1717 break;
1718 case USB_REQ_GET_STATUS:
1719 if (setup->bRequestType == Dev_InRequest
1720 || setup->bRequestType == Intf_InRequest
1721 || setup->bRequestType == Ep_InRequest) {
1722 char *buf;
1723
1724
1725
1726
1727
1728 buf = (char *)urb->transfer_buffer;
1729 if (urb->transfer_buffer_length > 0) {
1730 if (setup->bRequestType == Ep_InRequest) {
1731 ep2 = find_endpoint(dum, w_index);
1732 if (!ep2) {
1733 ret_val = -EOPNOTSUPP;
1734 break;
1735 }
1736 buf[0] = ep2->halted;
1737 } else if (setup->bRequestType ==
1738 Dev_InRequest) {
1739 buf[0] = (u8)dum->devstatus;
1740 } else
1741 buf[0] = 0;
1742 }
1743 if (urb->transfer_buffer_length > 1)
1744 buf[1] = 0;
1745 urb->actual_length = min_t(u32, 2,
1746 urb->transfer_buffer_length);
1747 ret_val = 0;
1748 *status = 0;
1749 }
1750 break;
1751 }
1752 return ret_val;
1753}
1754
1755
1756
1757
1758static void dummy_timer(struct timer_list *t)
1759{
1760 struct dummy_hcd *dum_hcd = from_timer(dum_hcd, t, timer);
1761 struct dummy *dum = dum_hcd->dum;
1762 struct urbp *urbp, *tmp;
1763 unsigned long flags;
1764 int limit, total;
1765 int i;
1766
1767
1768
1769 switch (dum->gadget.speed) {
1770 case USB_SPEED_LOW:
1771 total = 8 * 12;
1772 break;
1773 case USB_SPEED_FULL:
1774 total = 64 * 19;
1775 break;
1776 case USB_SPEED_HIGH:
1777 total = 512 * 13 * 8;
1778 break;
1779 case USB_SPEED_SUPER:
1780
1781 total = 490000;
1782 break;
1783 default:
1784 dev_err(dummy_dev(dum_hcd), "bogus device speed\n");
1785 total = 0;
1786 break;
1787 }
1788
1789
1790
1791
1792 spin_lock_irqsave(&dum->lock, flags);
1793
1794 if (!dum_hcd->udev) {
1795 dev_err(dummy_dev(dum_hcd),
1796 "timer fired with no URBs pending?\n");
1797 spin_unlock_irqrestore(&dum->lock, flags);
1798 return;
1799 }
1800 dum_hcd->next_frame_urbp = NULL;
1801
1802 for (i = 0; i < DUMMY_ENDPOINTS; i++) {
1803 if (!ep_info[i].name)
1804 break;
1805 dum->ep[i].already_seen = 0;
1806 }
1807
1808restart:
1809 list_for_each_entry_safe(urbp, tmp, &dum_hcd->urbp_list, urbp_list) {
1810 struct urb *urb;
1811 struct dummy_request *req;
1812 u8 address;
1813 struct dummy_ep *ep = NULL;
1814 int status = -EINPROGRESS;
1815
1816
1817 if (urbp == dum_hcd->next_frame_urbp)
1818 break;
1819
1820 urb = urbp->urb;
1821 if (urb->unlinked)
1822 goto return_urb;
1823 else if (dum_hcd->rh_state != DUMMY_RH_RUNNING)
1824 continue;
1825
1826
1827 if (total <= 0)
1828 continue;
1829
1830
1831 address = usb_pipeendpoint (urb->pipe);
1832 if (usb_pipein(urb->pipe))
1833 address |= USB_DIR_IN;
1834 ep = find_endpoint(dum, address);
1835 if (!ep) {
1836
1837 dev_dbg(dummy_dev(dum_hcd),
1838 "no ep configured for urb %p\n",
1839 urb);
1840 status = -EPROTO;
1841 goto return_urb;
1842 }
1843
1844 if (ep->already_seen)
1845 continue;
1846 ep->already_seen = 1;
1847 if (ep == &dum->ep[0] && urb->error_count) {
1848 ep->setup_stage = 1;
1849 urb->error_count = 0;
1850 }
1851 if (ep->halted && !ep->setup_stage) {
1852
1853 dev_dbg(dummy_dev(dum_hcd), "ep %s halted, urb %p\n",
1854 ep->ep.name, urb);
1855 status = -EPIPE;
1856 goto return_urb;
1857 }
1858
1859
1860
1861 if (ep == &dum->ep[0] && ep->setup_stage) {
1862 struct usb_ctrlrequest setup;
1863 int value = 1;
1864
1865 setup = *(struct usb_ctrlrequest *) urb->setup_packet;
1866
1867 list_for_each_entry(req, &ep->queue, queue) {
1868 list_del_init(&req->queue);
1869 req->req.status = -EOVERFLOW;
1870 dev_dbg(udc_dev(dum), "stale req = %p\n",
1871 req);
1872
1873 spin_unlock(&dum->lock);
1874 usb_gadget_giveback_request(&ep->ep, &req->req);
1875 spin_lock(&dum->lock);
1876 ep->already_seen = 0;
1877 goto restart;
1878 }
1879
1880
1881
1882
1883
1884 ep->last_io = jiffies;
1885 ep->setup_stage = 0;
1886 ep->halted = 0;
1887
1888 value = handle_control_request(dum_hcd, urb, &setup,
1889 &status);
1890
1891
1892
1893
1894 if (value > 0) {
1895 ++dum->callback_usage;
1896 spin_unlock(&dum->lock);
1897 value = dum->driver->setup(&dum->gadget,
1898 &setup);
1899 spin_lock(&dum->lock);
1900 --dum->callback_usage;
1901
1902 if (value >= 0) {
1903
1904 limit = 64*1024;
1905 goto treat_control_like_bulk;
1906 }
1907
1908 }
1909
1910 if (value < 0) {
1911 if (value != -EOPNOTSUPP)
1912 dev_dbg(udc_dev(dum),
1913 "setup --> %d\n",
1914 value);
1915 status = -EPIPE;
1916 urb->actual_length = 0;
1917 }
1918
1919 goto return_urb;
1920 }
1921
1922
1923 limit = total;
1924 switch (usb_pipetype(urb->pipe)) {
1925 case PIPE_ISOCHRONOUS:
1926
1927
1928
1929
1930
1931
1932
1933
1934
1935 limit = max(limit, periodic_bytes(dum, ep));
1936 status = -EINVAL;
1937 break;
1938
1939 case PIPE_INTERRUPT:
1940
1941
1942
1943 limit = max(limit, periodic_bytes(dum, ep));
1944
1945
1946 default:
1947treat_control_like_bulk:
1948 ep->last_io = jiffies;
1949 total -= transfer(dum_hcd, urb, ep, limit, &status);
1950 break;
1951 }
1952
1953
1954 if (status == -EINPROGRESS)
1955 continue;
1956
1957return_urb:
1958 list_del(&urbp->urbp_list);
1959 kfree(urbp);
1960 if (ep)
1961 ep->already_seen = ep->setup_stage = 0;
1962
1963 usb_hcd_unlink_urb_from_ep(dummy_hcd_to_hcd(dum_hcd), urb);
1964 spin_unlock(&dum->lock);
1965 usb_hcd_giveback_urb(dummy_hcd_to_hcd(dum_hcd), urb, status);
1966 spin_lock(&dum->lock);
1967
1968 goto restart;
1969 }
1970
1971 if (list_empty(&dum_hcd->urbp_list)) {
1972 usb_put_dev(dum_hcd->udev);
1973 dum_hcd->udev = NULL;
1974 } else if (dum_hcd->rh_state == DUMMY_RH_RUNNING) {
1975
1976 mod_timer(&dum_hcd->timer, jiffies + msecs_to_jiffies(1));
1977 }
1978
1979 spin_unlock_irqrestore(&dum->lock, flags);
1980}
1981
1982
1983
1984#define PORT_C_MASK \
1985 ((USB_PORT_STAT_C_CONNECTION \
1986 | USB_PORT_STAT_C_ENABLE \
1987 | USB_PORT_STAT_C_SUSPEND \
1988 | USB_PORT_STAT_C_OVERCURRENT \
1989 | USB_PORT_STAT_C_RESET) << 16)
1990
1991static int dummy_hub_status(struct usb_hcd *hcd, char *buf)
1992{
1993 struct dummy_hcd *dum_hcd;
1994 unsigned long flags;
1995 int retval = 0;
1996
1997 dum_hcd = hcd_to_dummy_hcd(hcd);
1998
1999 spin_lock_irqsave(&dum_hcd->dum->lock, flags);
2000 if (!HCD_HW_ACCESSIBLE(hcd))
2001 goto done;
2002
2003 if (dum_hcd->resuming && time_after_eq(jiffies, dum_hcd->re_timeout)) {
2004 dum_hcd->port_status |= (USB_PORT_STAT_C_SUSPEND << 16);
2005 dum_hcd->port_status &= ~USB_PORT_STAT_SUSPEND;
2006 set_link_state(dum_hcd);
2007 }
2008
2009 if ((dum_hcd->port_status & PORT_C_MASK) != 0) {
2010 *buf = (1 << 1);
2011 dev_dbg(dummy_dev(dum_hcd), "port status 0x%08x has changes\n",
2012 dum_hcd->port_status);
2013 retval = 1;
2014 if (dum_hcd->rh_state == DUMMY_RH_SUSPENDED)
2015 usb_hcd_resume_root_hub(hcd);
2016 }
2017done:
2018 spin_unlock_irqrestore(&dum_hcd->dum->lock, flags);
2019 return retval;
2020}
2021
2022
2023static struct {
2024 struct usb_bos_descriptor bos;
2025 struct usb_ss_cap_descriptor ss_cap;
2026} __packed usb3_bos_desc = {
2027
2028 .bos = {
2029 .bLength = USB_DT_BOS_SIZE,
2030 .bDescriptorType = USB_DT_BOS,
2031 .wTotalLength = cpu_to_le16(sizeof(usb3_bos_desc)),
2032 .bNumDeviceCaps = 1,
2033 },
2034 .ss_cap = {
2035 .bLength = USB_DT_USB_SS_CAP_SIZE,
2036 .bDescriptorType = USB_DT_DEVICE_CAPABILITY,
2037 .bDevCapabilityType = USB_SS_CAP_TYPE,
2038 .wSpeedSupported = cpu_to_le16(USB_5GBPS_OPERATION),
2039 .bFunctionalitySupport = ilog2(USB_5GBPS_OPERATION),
2040 },
2041};
2042
2043static inline void
2044ss_hub_descriptor(struct usb_hub_descriptor *desc)
2045{
2046 memset(desc, 0, sizeof *desc);
2047 desc->bDescriptorType = USB_DT_SS_HUB;
2048 desc->bDescLength = 12;
2049 desc->wHubCharacteristics = cpu_to_le16(
2050 HUB_CHAR_INDV_PORT_LPSM |
2051 HUB_CHAR_COMMON_OCPM);
2052 desc->bNbrPorts = 1;
2053 desc->u.ss.bHubHdrDecLat = 0x04;
2054 desc->u.ss.DeviceRemovable = 0;
2055}
2056
2057static inline void hub_descriptor(struct usb_hub_descriptor *desc)
2058{
2059 memset(desc, 0, sizeof *desc);
2060 desc->bDescriptorType = USB_DT_HUB;
2061 desc->bDescLength = 9;
2062 desc->wHubCharacteristics = cpu_to_le16(
2063 HUB_CHAR_INDV_PORT_LPSM |
2064 HUB_CHAR_COMMON_OCPM);
2065 desc->bNbrPorts = 1;
2066 desc->u.hs.DeviceRemovable[0] = 0;
2067 desc->u.hs.DeviceRemovable[1] = 0xff;
2068}
2069
2070static int dummy_hub_control(
2071 struct usb_hcd *hcd,
2072 u16 typeReq,
2073 u16 wValue,
2074 u16 wIndex,
2075 char *buf,
2076 u16 wLength
2077) {
2078 struct dummy_hcd *dum_hcd;
2079 int retval = 0;
2080 unsigned long flags;
2081
2082 if (!HCD_HW_ACCESSIBLE(hcd))
2083 return -ETIMEDOUT;
2084
2085 dum_hcd = hcd_to_dummy_hcd(hcd);
2086
2087 spin_lock_irqsave(&dum_hcd->dum->lock, flags);
2088 switch (typeReq) {
2089 case ClearHubFeature:
2090 break;
2091 case ClearPortFeature:
2092 switch (wValue) {
2093 case USB_PORT_FEAT_SUSPEND:
2094 if (hcd->speed == HCD_USB3) {
2095 dev_dbg(dummy_dev(dum_hcd),
2096 "USB_PORT_FEAT_SUSPEND req not "
2097 "supported for USB 3.0 roothub\n");
2098 goto error;
2099 }
2100 if (dum_hcd->port_status & USB_PORT_STAT_SUSPEND) {
2101
2102 dum_hcd->resuming = 1;
2103 dum_hcd->re_timeout = jiffies +
2104 msecs_to_jiffies(20);
2105 }
2106 break;
2107 case USB_PORT_FEAT_POWER:
2108 dev_dbg(dummy_dev(dum_hcd), "power-off\n");
2109 if (hcd->speed == HCD_USB3)
2110 dum_hcd->port_status &= ~USB_SS_PORT_STAT_POWER;
2111 else
2112 dum_hcd->port_status &= ~USB_PORT_STAT_POWER;
2113 set_link_state(dum_hcd);
2114 break;
2115 default:
2116 dum_hcd->port_status &= ~(1 << wValue);
2117 set_link_state(dum_hcd);
2118 }
2119 break;
2120 case GetHubDescriptor:
2121 if (hcd->speed == HCD_USB3 &&
2122 (wLength < USB_DT_SS_HUB_SIZE ||
2123 wValue != (USB_DT_SS_HUB << 8))) {
2124 dev_dbg(dummy_dev(dum_hcd),
2125 "Wrong hub descriptor type for "
2126 "USB 3.0 roothub.\n");
2127 goto error;
2128 }
2129 if (hcd->speed == HCD_USB3)
2130 ss_hub_descriptor((struct usb_hub_descriptor *) buf);
2131 else
2132 hub_descriptor((struct usb_hub_descriptor *) buf);
2133 break;
2134
2135 case DeviceRequest | USB_REQ_GET_DESCRIPTOR:
2136 if (hcd->speed != HCD_USB3)
2137 goto error;
2138
2139 if ((wValue >> 8) != USB_DT_BOS)
2140 goto error;
2141
2142 memcpy(buf, &usb3_bos_desc, sizeof(usb3_bos_desc));
2143 retval = sizeof(usb3_bos_desc);
2144 break;
2145
2146 case GetHubStatus:
2147 *(__le32 *) buf = cpu_to_le32(0);
2148 break;
2149 case GetPortStatus:
2150 if (wIndex != 1)
2151 retval = -EPIPE;
2152
2153
2154
2155
2156 if (dum_hcd->resuming &&
2157 time_after_eq(jiffies, dum_hcd->re_timeout)) {
2158 dum_hcd->port_status |= (USB_PORT_STAT_C_SUSPEND << 16);
2159 dum_hcd->port_status &= ~USB_PORT_STAT_SUSPEND;
2160 }
2161 if ((dum_hcd->port_status & USB_PORT_STAT_RESET) != 0 &&
2162 time_after_eq(jiffies, dum_hcd->re_timeout)) {
2163 dum_hcd->port_status |= (USB_PORT_STAT_C_RESET << 16);
2164 dum_hcd->port_status &= ~USB_PORT_STAT_RESET;
2165 if (dum_hcd->dum->pullup) {
2166 dum_hcd->port_status |= USB_PORT_STAT_ENABLE;
2167
2168 if (hcd->speed < HCD_USB3) {
2169 switch (dum_hcd->dum->gadget.speed) {
2170 case USB_SPEED_HIGH:
2171 dum_hcd->port_status |=
2172 USB_PORT_STAT_HIGH_SPEED;
2173 break;
2174 case USB_SPEED_LOW:
2175 dum_hcd->dum->gadget.ep0->
2176 maxpacket = 8;
2177 dum_hcd->port_status |=
2178 USB_PORT_STAT_LOW_SPEED;
2179 break;
2180 default:
2181 break;
2182 }
2183 }
2184 }
2185 }
2186 set_link_state(dum_hcd);
2187 ((__le16 *) buf)[0] = cpu_to_le16(dum_hcd->port_status);
2188 ((__le16 *) buf)[1] = cpu_to_le16(dum_hcd->port_status >> 16);
2189 break;
2190 case SetHubFeature:
2191 retval = -EPIPE;
2192 break;
2193 case SetPortFeature:
2194 switch (wValue) {
2195 case USB_PORT_FEAT_LINK_STATE:
2196 if (hcd->speed != HCD_USB3) {
2197 dev_dbg(dummy_dev(dum_hcd),
2198 "USB_PORT_FEAT_LINK_STATE req not "
2199 "supported for USB 2.0 roothub\n");
2200 goto error;
2201 }
2202
2203
2204
2205
2206 break;
2207 case USB_PORT_FEAT_U1_TIMEOUT:
2208 case USB_PORT_FEAT_U2_TIMEOUT:
2209
2210 if (hcd->speed != HCD_USB3) {
2211 dev_dbg(dummy_dev(dum_hcd),
2212 "USB_PORT_FEAT_U1/2_TIMEOUT req not "
2213 "supported for USB 2.0 roothub\n");
2214 goto error;
2215 }
2216 break;
2217 case USB_PORT_FEAT_SUSPEND:
2218
2219 if (hcd->speed == HCD_USB3) {
2220 dev_dbg(dummy_dev(dum_hcd),
2221 "USB_PORT_FEAT_SUSPEND req not "
2222 "supported for USB 3.0 roothub\n");
2223 goto error;
2224 }
2225 if (dum_hcd->active) {
2226 dum_hcd->port_status |= USB_PORT_STAT_SUSPEND;
2227
2228
2229
2230
2231 set_link_state(dum_hcd);
2232 if (((1 << USB_DEVICE_B_HNP_ENABLE)
2233 & dum_hcd->dum->devstatus) != 0)
2234 dev_dbg(dummy_dev(dum_hcd),
2235 "no HNP yet!\n");
2236 }
2237 break;
2238 case USB_PORT_FEAT_POWER:
2239 if (hcd->speed == HCD_USB3)
2240 dum_hcd->port_status |= USB_SS_PORT_STAT_POWER;
2241 else
2242 dum_hcd->port_status |= USB_PORT_STAT_POWER;
2243 set_link_state(dum_hcd);
2244 break;
2245 case USB_PORT_FEAT_BH_PORT_RESET:
2246
2247 if (hcd->speed != HCD_USB3) {
2248 dev_dbg(dummy_dev(dum_hcd),
2249 "USB_PORT_FEAT_BH_PORT_RESET req not "
2250 "supported for USB 2.0 roothub\n");
2251 goto error;
2252 }
2253
2254 case USB_PORT_FEAT_RESET:
2255
2256 if (hcd->speed == HCD_USB3) {
2257 dum_hcd->port_status = 0;
2258 dum_hcd->port_status =
2259 (USB_SS_PORT_STAT_POWER |
2260 USB_PORT_STAT_CONNECTION |
2261 USB_PORT_STAT_RESET);
2262 } else
2263 dum_hcd->port_status &= ~(USB_PORT_STAT_ENABLE
2264 | USB_PORT_STAT_LOW_SPEED
2265 | USB_PORT_STAT_HIGH_SPEED);
2266
2267
2268
2269
2270 dum_hcd->dum->devstatus &=
2271 (1 << USB_DEVICE_SELF_POWERED);
2272
2273
2274
2275
2276 dum_hcd->re_timeout = jiffies + msecs_to_jiffies(50);
2277
2278 default:
2279 if (hcd->speed == HCD_USB3) {
2280 if ((dum_hcd->port_status &
2281 USB_SS_PORT_STAT_POWER) != 0) {
2282 dum_hcd->port_status |= (1 << wValue);
2283 }
2284 } else
2285 if ((dum_hcd->port_status &
2286 USB_PORT_STAT_POWER) != 0) {
2287 dum_hcd->port_status |= (1 << wValue);
2288 }
2289 set_link_state(dum_hcd);
2290 }
2291 break;
2292 case GetPortErrorCount:
2293 if (hcd->speed != HCD_USB3) {
2294 dev_dbg(dummy_dev(dum_hcd),
2295 "GetPortErrorCount req not "
2296 "supported for USB 2.0 roothub\n");
2297 goto error;
2298 }
2299
2300 *(__le32 *) buf = cpu_to_le32(0);
2301 break;
2302 case SetHubDepth:
2303 if (hcd->speed != HCD_USB3) {
2304 dev_dbg(dummy_dev(dum_hcd),
2305 "SetHubDepth req not supported for "
2306 "USB 2.0 roothub\n");
2307 goto error;
2308 }
2309 break;
2310 default:
2311 dev_dbg(dummy_dev(dum_hcd),
2312 "hub control req%04x v%04x i%04x l%d\n",
2313 typeReq, wValue, wIndex, wLength);
2314error:
2315
2316 retval = -EPIPE;
2317 }
2318 spin_unlock_irqrestore(&dum_hcd->dum->lock, flags);
2319
2320 if ((dum_hcd->port_status & PORT_C_MASK) != 0)
2321 usb_hcd_poll_rh_status(hcd);
2322 return retval;
2323}
2324
2325static int dummy_bus_suspend(struct usb_hcd *hcd)
2326{
2327 struct dummy_hcd *dum_hcd = hcd_to_dummy_hcd(hcd);
2328
2329 dev_dbg(&hcd->self.root_hub->dev, "%s\n", __func__);
2330
2331 spin_lock_irq(&dum_hcd->dum->lock);
2332 dum_hcd->rh_state = DUMMY_RH_SUSPENDED;
2333 set_link_state(dum_hcd);
2334 hcd->state = HC_STATE_SUSPENDED;
2335 spin_unlock_irq(&dum_hcd->dum->lock);
2336 return 0;
2337}
2338
2339static int dummy_bus_resume(struct usb_hcd *hcd)
2340{
2341 struct dummy_hcd *dum_hcd = hcd_to_dummy_hcd(hcd);
2342 int rc = 0;
2343
2344 dev_dbg(&hcd->self.root_hub->dev, "%s\n", __func__);
2345
2346 spin_lock_irq(&dum_hcd->dum->lock);
2347 if (!HCD_HW_ACCESSIBLE(hcd)) {
2348 rc = -ESHUTDOWN;
2349 } else {
2350 dum_hcd->rh_state = DUMMY_RH_RUNNING;
2351 set_link_state(dum_hcd);
2352 if (!list_empty(&dum_hcd->urbp_list))
2353 mod_timer(&dum_hcd->timer, jiffies);
2354 hcd->state = HC_STATE_RUNNING;
2355 }
2356 spin_unlock_irq(&dum_hcd->dum->lock);
2357 return rc;
2358}
2359
2360
2361
2362static inline ssize_t show_urb(char *buf, size_t size, struct urb *urb)
2363{
2364 int ep = usb_pipeendpoint(urb->pipe);
2365
2366 return scnprintf(buf, size,
2367 "urb/%p %s ep%d%s%s len %d/%d\n",
2368 urb,
2369 ({ char *s;
2370 switch (urb->dev->speed) {
2371 case USB_SPEED_LOW:
2372 s = "ls";
2373 break;
2374 case USB_SPEED_FULL:
2375 s = "fs";
2376 break;
2377 case USB_SPEED_HIGH:
2378 s = "hs";
2379 break;
2380 case USB_SPEED_SUPER:
2381 s = "ss";
2382 break;
2383 default:
2384 s = "?";
2385 break;
2386 } s; }),
2387 ep, ep ? (usb_pipein(urb->pipe) ? "in" : "out") : "",
2388 ({ char *s; \
2389 switch (usb_pipetype(urb->pipe)) { \
2390 case PIPE_CONTROL: \
2391 s = ""; \
2392 break; \
2393 case PIPE_BULK: \
2394 s = "-bulk"; \
2395 break; \
2396 case PIPE_INTERRUPT: \
2397 s = "-int"; \
2398 break; \
2399 default: \
2400 s = "-iso"; \
2401 break; \
2402 } s; }),
2403 urb->actual_length, urb->transfer_buffer_length);
2404}
2405
2406static ssize_t urbs_show(struct device *dev, struct device_attribute *attr,
2407 char *buf)
2408{
2409 struct usb_hcd *hcd = dev_get_drvdata(dev);
2410 struct dummy_hcd *dum_hcd = hcd_to_dummy_hcd(hcd);
2411 struct urbp *urbp;
2412 size_t size = 0;
2413 unsigned long flags;
2414
2415 spin_lock_irqsave(&dum_hcd->dum->lock, flags);
2416 list_for_each_entry(urbp, &dum_hcd->urbp_list, urbp_list) {
2417 size_t temp;
2418
2419 temp = show_urb(buf, PAGE_SIZE - size, urbp->urb);
2420 buf += temp;
2421 size += temp;
2422 }
2423 spin_unlock_irqrestore(&dum_hcd->dum->lock, flags);
2424
2425 return size;
2426}
2427static DEVICE_ATTR_RO(urbs);
2428
2429static int dummy_start_ss(struct dummy_hcd *dum_hcd)
2430{
2431 timer_setup(&dum_hcd->timer, dummy_timer, 0);
2432 dum_hcd->rh_state = DUMMY_RH_RUNNING;
2433 dum_hcd->stream_en_ep = 0;
2434 INIT_LIST_HEAD(&dum_hcd->urbp_list);
2435 dummy_hcd_to_hcd(dum_hcd)->power_budget = POWER_BUDGET;
2436 dummy_hcd_to_hcd(dum_hcd)->state = HC_STATE_RUNNING;
2437 dummy_hcd_to_hcd(dum_hcd)->uses_new_polling = 1;
2438#ifdef CONFIG_USB_OTG
2439 dummy_hcd_to_hcd(dum_hcd)->self.otg_port = 1;
2440#endif
2441 return 0;
2442
2443
2444 return device_create_file(dummy_dev(dum_hcd), &dev_attr_urbs);
2445}
2446
2447static int dummy_start(struct usb_hcd *hcd)
2448{
2449 struct dummy_hcd *dum_hcd = hcd_to_dummy_hcd(hcd);
2450
2451
2452
2453
2454
2455
2456 if (!usb_hcd_is_primary_hcd(hcd))
2457 return dummy_start_ss(dum_hcd);
2458
2459 spin_lock_init(&dum_hcd->dum->lock);
2460 timer_setup(&dum_hcd->timer, dummy_timer, 0);
2461 dum_hcd->rh_state = DUMMY_RH_RUNNING;
2462
2463 INIT_LIST_HEAD(&dum_hcd->urbp_list);
2464
2465 hcd->power_budget = POWER_BUDGET;
2466 hcd->state = HC_STATE_RUNNING;
2467 hcd->uses_new_polling = 1;
2468
2469#ifdef CONFIG_USB_OTG
2470 hcd->self.otg_port = 1;
2471#endif
2472
2473
2474 return device_create_file(dummy_dev(dum_hcd), &dev_attr_urbs);
2475}
2476
2477static void dummy_stop(struct usb_hcd *hcd)
2478{
2479 device_remove_file(dummy_dev(hcd_to_dummy_hcd(hcd)), &dev_attr_urbs);
2480 dev_info(dummy_dev(hcd_to_dummy_hcd(hcd)), "stopped\n");
2481}
2482
2483
2484
2485static int dummy_h_get_frame(struct usb_hcd *hcd)
2486{
2487 return dummy_g_get_frame(NULL);
2488}
2489
2490static int dummy_setup(struct usb_hcd *hcd)
2491{
2492 struct dummy *dum;
2493
2494 dum = *((void **)dev_get_platdata(hcd->self.controller));
2495 hcd->self.sg_tablesize = ~0;
2496 if (usb_hcd_is_primary_hcd(hcd)) {
2497 dum->hs_hcd = hcd_to_dummy_hcd(hcd);
2498 dum->hs_hcd->dum = dum;
2499
2500
2501
2502
2503
2504 hcd->speed = HCD_USB2;
2505 hcd->self.root_hub->speed = USB_SPEED_HIGH;
2506 } else {
2507 dum->ss_hcd = hcd_to_dummy_hcd(hcd);
2508 dum->ss_hcd->dum = dum;
2509 hcd->speed = HCD_USB3;
2510 hcd->self.root_hub->speed = USB_SPEED_SUPER;
2511 }
2512 return 0;
2513}
2514
2515
2516static int dummy_alloc_streams(struct usb_hcd *hcd, struct usb_device *udev,
2517 struct usb_host_endpoint **eps, unsigned int num_eps,
2518 unsigned int num_streams, gfp_t mem_flags)
2519{
2520 struct dummy_hcd *dum_hcd = hcd_to_dummy_hcd(hcd);
2521 unsigned long flags;
2522 int max_stream;
2523 int ret_streams = num_streams;
2524 unsigned int index;
2525 unsigned int i;
2526
2527 if (!num_eps)
2528 return -EINVAL;
2529
2530 spin_lock_irqsave(&dum_hcd->dum->lock, flags);
2531 for (i = 0; i < num_eps; i++) {
2532 index = dummy_get_ep_idx(&eps[i]->desc);
2533 if ((1 << index) & dum_hcd->stream_en_ep) {
2534 ret_streams = -EINVAL;
2535 goto out;
2536 }
2537 max_stream = usb_ss_max_streams(&eps[i]->ss_ep_comp);
2538 if (!max_stream) {
2539 ret_streams = -EINVAL;
2540 goto out;
2541 }
2542 if (max_stream < ret_streams) {
2543 dev_dbg(dummy_dev(dum_hcd), "Ep 0x%x only supports %u "
2544 "stream IDs.\n",
2545 eps[i]->desc.bEndpointAddress,
2546 max_stream);
2547 ret_streams = max_stream;
2548 }
2549 }
2550
2551 for (i = 0; i < num_eps; i++) {
2552 index = dummy_get_ep_idx(&eps[i]->desc);
2553 dum_hcd->stream_en_ep |= 1 << index;
2554 set_max_streams_for_pipe(dum_hcd,
2555 usb_endpoint_num(&eps[i]->desc), ret_streams);
2556 }
2557out:
2558 spin_unlock_irqrestore(&dum_hcd->dum->lock, flags);
2559 return ret_streams;
2560}
2561
2562
2563static int dummy_free_streams(struct usb_hcd *hcd, struct usb_device *udev,
2564 struct usb_host_endpoint **eps, unsigned int num_eps,
2565 gfp_t mem_flags)
2566{
2567 struct dummy_hcd *dum_hcd = hcd_to_dummy_hcd(hcd);
2568 unsigned long flags;
2569 int ret;
2570 unsigned int index;
2571 unsigned int i;
2572
2573 spin_lock_irqsave(&dum_hcd->dum->lock, flags);
2574 for (i = 0; i < num_eps; i++) {
2575 index = dummy_get_ep_idx(&eps[i]->desc);
2576 if (!((1 << index) & dum_hcd->stream_en_ep)) {
2577 ret = -EINVAL;
2578 goto out;
2579 }
2580 }
2581
2582 for (i = 0; i < num_eps; i++) {
2583 index = dummy_get_ep_idx(&eps[i]->desc);
2584 dum_hcd->stream_en_ep &= ~(1 << index);
2585 set_max_streams_for_pipe(dum_hcd,
2586 usb_endpoint_num(&eps[i]->desc), 0);
2587 }
2588 ret = 0;
2589out:
2590 spin_unlock_irqrestore(&dum_hcd->dum->lock, flags);
2591 return ret;
2592}
2593
2594static struct hc_driver dummy_hcd = {
2595 .description = (char *) driver_name,
2596 .product_desc = "Dummy host controller",
2597 .hcd_priv_size = sizeof(struct dummy_hcd),
2598
2599 .reset = dummy_setup,
2600 .start = dummy_start,
2601 .stop = dummy_stop,
2602
2603 .urb_enqueue = dummy_urb_enqueue,
2604 .urb_dequeue = dummy_urb_dequeue,
2605
2606 .get_frame_number = dummy_h_get_frame,
2607
2608 .hub_status_data = dummy_hub_status,
2609 .hub_control = dummy_hub_control,
2610 .bus_suspend = dummy_bus_suspend,
2611 .bus_resume = dummy_bus_resume,
2612
2613 .alloc_streams = dummy_alloc_streams,
2614 .free_streams = dummy_free_streams,
2615};
2616
2617static int dummy_hcd_probe(struct platform_device *pdev)
2618{
2619 struct dummy *dum;
2620 struct usb_hcd *hs_hcd;
2621 struct usb_hcd *ss_hcd;
2622 int retval;
2623
2624 dev_info(&pdev->dev, "%s, driver " DRIVER_VERSION "\n", driver_desc);
2625 dum = *((void **)dev_get_platdata(&pdev->dev));
2626
2627 if (mod_data.is_super_speed)
2628 dummy_hcd.flags = HCD_USB3 | HCD_SHARED;
2629 else if (mod_data.is_high_speed)
2630 dummy_hcd.flags = HCD_USB2;
2631 else
2632 dummy_hcd.flags = HCD_USB11;
2633 hs_hcd = usb_create_hcd(&dummy_hcd, &pdev->dev, dev_name(&pdev->dev));
2634 if (!hs_hcd)
2635 return -ENOMEM;
2636 hs_hcd->has_tt = 1;
2637
2638 retval = usb_add_hcd(hs_hcd, 0, 0);
2639 if (retval)
2640 goto put_usb2_hcd;
2641
2642 if (mod_data.is_super_speed) {
2643 ss_hcd = usb_create_shared_hcd(&dummy_hcd, &pdev->dev,
2644 dev_name(&pdev->dev), hs_hcd);
2645 if (!ss_hcd) {
2646 retval = -ENOMEM;
2647 goto dealloc_usb2_hcd;
2648 }
2649
2650 retval = usb_add_hcd(ss_hcd, 0, 0);
2651 if (retval)
2652 goto put_usb3_hcd;
2653 }
2654 return 0;
2655
2656put_usb3_hcd:
2657 usb_put_hcd(ss_hcd);
2658dealloc_usb2_hcd:
2659 usb_remove_hcd(hs_hcd);
2660put_usb2_hcd:
2661 usb_put_hcd(hs_hcd);
2662 dum->hs_hcd = dum->ss_hcd = NULL;
2663 return retval;
2664}
2665
2666static int dummy_hcd_remove(struct platform_device *pdev)
2667{
2668 struct dummy *dum;
2669
2670 dum = hcd_to_dummy_hcd(platform_get_drvdata(pdev))->dum;
2671
2672 if (dum->ss_hcd) {
2673 usb_remove_hcd(dummy_hcd_to_hcd(dum->ss_hcd));
2674 usb_put_hcd(dummy_hcd_to_hcd(dum->ss_hcd));
2675 }
2676
2677 usb_remove_hcd(dummy_hcd_to_hcd(dum->hs_hcd));
2678 usb_put_hcd(dummy_hcd_to_hcd(dum->hs_hcd));
2679
2680 dum->hs_hcd = NULL;
2681 dum->ss_hcd = NULL;
2682
2683 return 0;
2684}
2685
2686static int dummy_hcd_suspend(struct platform_device *pdev, pm_message_t state)
2687{
2688 struct usb_hcd *hcd;
2689 struct dummy_hcd *dum_hcd;
2690 int rc = 0;
2691
2692 dev_dbg(&pdev->dev, "%s\n", __func__);
2693
2694 hcd = platform_get_drvdata(pdev);
2695 dum_hcd = hcd_to_dummy_hcd(hcd);
2696 if (dum_hcd->rh_state == DUMMY_RH_RUNNING) {
2697 dev_warn(&pdev->dev, "Root hub isn't suspended!\n");
2698 rc = -EBUSY;
2699 } else
2700 clear_bit(HCD_FLAG_HW_ACCESSIBLE, &hcd->flags);
2701 return rc;
2702}
2703
2704static int dummy_hcd_resume(struct platform_device *pdev)
2705{
2706 struct usb_hcd *hcd;
2707
2708 dev_dbg(&pdev->dev, "%s\n", __func__);
2709
2710 hcd = platform_get_drvdata(pdev);
2711 set_bit(HCD_FLAG_HW_ACCESSIBLE, &hcd->flags);
2712 usb_hcd_poll_rh_status(hcd);
2713 return 0;
2714}
2715
2716static struct platform_driver dummy_hcd_driver = {
2717 .probe = dummy_hcd_probe,
2718 .remove = dummy_hcd_remove,
2719 .suspend = dummy_hcd_suspend,
2720 .resume = dummy_hcd_resume,
2721 .driver = {
2722 .name = (char *) driver_name,
2723 },
2724};
2725
2726
2727#define MAX_NUM_UDC 2
2728static struct platform_device *the_udc_pdev[MAX_NUM_UDC];
2729static struct platform_device *the_hcd_pdev[MAX_NUM_UDC];
2730
2731static int __init init(void)
2732{
2733 int retval = -ENOMEM;
2734 int i;
2735 struct dummy *dum[MAX_NUM_UDC];
2736
2737 if (usb_disabled())
2738 return -ENODEV;
2739
2740 if (!mod_data.is_high_speed && mod_data.is_super_speed)
2741 return -EINVAL;
2742
2743 if (mod_data.num < 1 || mod_data.num > MAX_NUM_UDC) {
2744 pr_err("Number of emulated UDC must be in range of 1...%d\n",
2745 MAX_NUM_UDC);
2746 return -EINVAL;
2747 }
2748
2749 for (i = 0; i < mod_data.num; i++) {
2750 the_hcd_pdev[i] = platform_device_alloc(driver_name, i);
2751 if (!the_hcd_pdev[i]) {
2752 i--;
2753 while (i >= 0)
2754 platform_device_put(the_hcd_pdev[i--]);
2755 return retval;
2756 }
2757 }
2758 for (i = 0; i < mod_data.num; i++) {
2759 the_udc_pdev[i] = platform_device_alloc(gadget_name, i);
2760 if (!the_udc_pdev[i]) {
2761 i--;
2762 while (i >= 0)
2763 platform_device_put(the_udc_pdev[i--]);
2764 goto err_alloc_udc;
2765 }
2766 }
2767 for (i = 0; i < mod_data.num; i++) {
2768 dum[i] = kzalloc(sizeof(struct dummy), GFP_KERNEL);
2769 if (!dum[i]) {
2770 retval = -ENOMEM;
2771 goto err_add_pdata;
2772 }
2773 retval = platform_device_add_data(the_hcd_pdev[i], &dum[i],
2774 sizeof(void *));
2775 if (retval)
2776 goto err_add_pdata;
2777 retval = platform_device_add_data(the_udc_pdev[i], &dum[i],
2778 sizeof(void *));
2779 if (retval)
2780 goto err_add_pdata;
2781 }
2782
2783 retval = platform_driver_register(&dummy_hcd_driver);
2784 if (retval < 0)
2785 goto err_add_pdata;
2786 retval = platform_driver_register(&dummy_udc_driver);
2787 if (retval < 0)
2788 goto err_register_udc_driver;
2789
2790 for (i = 0; i < mod_data.num; i++) {
2791 retval = platform_device_add(the_hcd_pdev[i]);
2792 if (retval < 0) {
2793 i--;
2794 while (i >= 0)
2795 platform_device_del(the_hcd_pdev[i--]);
2796 goto err_add_hcd;
2797 }
2798 }
2799 for (i = 0; i < mod_data.num; i++) {
2800 if (!dum[i]->hs_hcd ||
2801 (!dum[i]->ss_hcd && mod_data.is_super_speed)) {
2802
2803
2804
2805
2806 retval = -EINVAL;
2807 goto err_add_udc;
2808 }
2809 }
2810
2811 for (i = 0; i < mod_data.num; i++) {
2812 retval = platform_device_add(the_udc_pdev[i]);
2813 if (retval < 0) {
2814 i--;
2815 while (i >= 0)
2816 platform_device_del(the_udc_pdev[i--]);
2817 goto err_add_udc;
2818 }
2819 }
2820
2821 for (i = 0; i < mod_data.num; i++) {
2822 if (!platform_get_drvdata(the_udc_pdev[i])) {
2823
2824
2825
2826
2827 retval = -EINVAL;
2828 goto err_probe_udc;
2829 }
2830 }
2831 return retval;
2832
2833err_probe_udc:
2834 for (i = 0; i < mod_data.num; i++)
2835 platform_device_del(the_udc_pdev[i]);
2836err_add_udc:
2837 for (i = 0; i < mod_data.num; i++)
2838 platform_device_del(the_hcd_pdev[i]);
2839err_add_hcd:
2840 platform_driver_unregister(&dummy_udc_driver);
2841err_register_udc_driver:
2842 platform_driver_unregister(&dummy_hcd_driver);
2843err_add_pdata:
2844 for (i = 0; i < mod_data.num; i++)
2845 kfree(dum[i]);
2846 for (i = 0; i < mod_data.num; i++)
2847 platform_device_put(the_udc_pdev[i]);
2848err_alloc_udc:
2849 for (i = 0; i < mod_data.num; i++)
2850 platform_device_put(the_hcd_pdev[i]);
2851 return retval;
2852}
2853module_init(init);
2854
2855static void __exit cleanup(void)
2856{
2857 int i;
2858
2859 for (i = 0; i < mod_data.num; i++) {
2860 struct dummy *dum;
2861
2862 dum = *((void **)dev_get_platdata(&the_udc_pdev[i]->dev));
2863
2864 platform_device_unregister(the_udc_pdev[i]);
2865 platform_device_unregister(the_hcd_pdev[i]);
2866 kfree(dum);
2867 }
2868 platform_driver_unregister(&dummy_udc_driver);
2869 platform_driver_unregister(&dummy_hcd_driver);
2870}
2871module_exit(cleanup);
2872