1 // SPDX-License-Identifier: GPL-2.0+
3 * dummy_hcd.c -- Dummy/Loopback USB host and device emulator driver.
5 * Maintainer: Alan Stern <stern@rowland.harvard.edu>
7 * Copyright (C) 2003 David Brownell
8 * Copyright (C) 2003-2005 Alan Stern
13 * This exposes a device side "USB gadget" API, driven by requests to a
14 * Linux-USB host controller driver. USB traffic is simulated; there's
15 * no need for USB hardware. Use this with two other drivers:
17 * - Gadget driver, responding to requests (slave);
18 * - Host-side device driver, as already familiar in Linux.
20 * Having this all in one kernel can help some stages of development,
21 * bypassing some hardware (and driver) issues. UML could help too.
23 * Note: The emulation does not include isochronous transfers!
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>
42 #include <asm/byteorder.h>
45 #include <asm/unaligned.h>
47 #define DRIVER_DESC "USB Host+Gadget Emulator"
48 #define DRIVER_VERSION "02 May 2005"
50 #define POWER_BUDGET 500 /* in mA; use 8 for low-power port testing */
52 static const char driver_name
[] = "dummy_hcd";
53 static const char driver_desc
[] = "USB Host+Gadget Emulator";
55 static const char gadget_name
[] = "dummy_udc";
57 MODULE_DESCRIPTION(DRIVER_DESC
);
58 MODULE_AUTHOR("David Brownell");
59 MODULE_LICENSE("GPL");
61 struct dummy_hcd_module_parameters
{
67 static struct dummy_hcd_module_parameters mod_data
= {
68 .is_super_speed
= false,
69 .is_high_speed
= true,
72 module_param_named(is_super_speed
, mod_data
.is_super_speed
, bool, S_IRUGO
);
73 MODULE_PARM_DESC(is_super_speed
, "true to simulate SuperSpeed connection");
74 module_param_named(is_high_speed
, mod_data
.is_high_speed
, bool, S_IRUGO
);
75 MODULE_PARM_DESC(is_high_speed
, "true to simulate HighSpeed connection");
76 module_param_named(num
, mod_data
.num
, uint
, S_IRUGO
);
77 MODULE_PARM_DESC(num
, "number of emulated controllers");
78 /*-------------------------------------------------------------------------*/
80 /* gadget side driver data structres */
82 struct list_head queue
;
83 unsigned long last_io
; /* jiffies timestamp */
84 struct usb_gadget
*gadget
;
85 const struct usb_endpoint_descriptor
*desc
;
89 unsigned already_seen
:1;
90 unsigned setup_stage
:1;
94 struct dummy_request
{
95 struct list_head queue
; /* ep's requests */
96 struct usb_request req
;
99 static inline struct dummy_ep
*usb_ep_to_dummy_ep(struct usb_ep
*_ep
)
101 return container_of(_ep
, struct dummy_ep
, ep
);
104 static inline struct dummy_request
*usb_request_to_dummy_request
105 (struct usb_request
*_req
)
107 return container_of(_req
, struct dummy_request
, req
);
110 /*-------------------------------------------------------------------------*/
113 * Every device has ep0 for control requests, plus up to 30 more endpoints,
114 * in one of two types:
116 * - Configurable: direction (in/out), type (bulk, iso, etc), and endpoint
117 * number can be changed. Names like "ep-a" are used for this type.
119 * - Fixed Function: in other cases. some characteristics may be mutable;
120 * that'd be hardware-specific. Names like "ep12out-bulk" are used.
122 * Gadget drivers are responsible for not setting up conflicting endpoint
123 * configurations, illegal or unsupported packet lengths, and so on.
126 static const char ep0name
[] = "ep0";
128 static const struct {
130 const struct usb_ep_caps caps
;
132 #define EP_INFO(_name, _caps) \
138 /* we don't provide isochronous endpoints since we don't support them */
139 #define TYPE_BULK_OR_INT (USB_EP_CAPS_TYPE_BULK | USB_EP_CAPS_TYPE_INT)
141 /* everyone has ep0 */
143 USB_EP_CAPS(USB_EP_CAPS_TYPE_CONTROL
, USB_EP_CAPS_DIR_ALL
)),
144 /* act like a pxa250: fifteen fixed function endpoints */
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
)),
151 USB_EP_CAPS(USB_EP_CAPS_TYPE_ISO, USB_EP_CAPS_DIR_IN)),
152 EP_INFO("ep4out-iso",
153 USB_EP_CAPS(USB_EP_CAPS_TYPE_ISO, USB_EP_CAPS_DIR_OUT)),
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
)),
163 USB_EP_CAPS(USB_EP_CAPS_TYPE_ISO, USB_EP_CAPS_DIR_IN)),
164 EP_INFO("ep9out-iso",
165 USB_EP_CAPS(USB_EP_CAPS_TYPE_ISO, USB_EP_CAPS_DIR_OUT)),
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
)),
174 EP_INFO("ep13in-iso",
175 USB_EP_CAPS(USB_EP_CAPS_TYPE_ISO, USB_EP_CAPS_DIR_IN)),
176 EP_INFO("ep14out-iso",
177 USB_EP_CAPS(USB_EP_CAPS_TYPE_ISO, USB_EP_CAPS_DIR_OUT)),
179 EP_INFO("ep15in-int",
180 USB_EP_CAPS(USB_EP_CAPS_TYPE_INT
, USB_EP_CAPS_DIR_IN
)),
182 /* or like sa1100: two fixed function endpoints */
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
)),
188 /* and now some generic EPs so we have enough in multi config */
190 USB_EP_CAPS(TYPE_BULK_OR_INT
, USB_EP_CAPS_DIR_OUT
)),
192 USB_EP_CAPS(TYPE_BULK_OR_INT
, USB_EP_CAPS_DIR_IN
)),
194 USB_EP_CAPS(TYPE_BULK_OR_INT
, USB_EP_CAPS_DIR_OUT
)),
196 USB_EP_CAPS(TYPE_BULK_OR_INT
, USB_EP_CAPS_DIR_OUT
)),
198 USB_EP_CAPS(TYPE_BULK_OR_INT
, USB_EP_CAPS_DIR_IN
)),
200 USB_EP_CAPS(TYPE_BULK_OR_INT
, USB_EP_CAPS_DIR_OUT
)),
202 USB_EP_CAPS(TYPE_BULK_OR_INT
, USB_EP_CAPS_DIR_IN
)),
204 USB_EP_CAPS(TYPE_BULK_OR_INT
, USB_EP_CAPS_DIR_OUT
)),
206 USB_EP_CAPS(TYPE_BULK_OR_INT
, USB_EP_CAPS_DIR_OUT
)),
208 USB_EP_CAPS(TYPE_BULK_OR_INT
, USB_EP_CAPS_DIR_IN
)),
210 USB_EP_CAPS(TYPE_BULK_OR_INT
, USB_EP_CAPS_DIR_OUT
)),
212 USB_EP_CAPS(TYPE_BULK_OR_INT
, USB_EP_CAPS_DIR_IN
)),
214 USB_EP_CAPS(TYPE_BULK_OR_INT
, USB_EP_CAPS_DIR_OUT
)),
219 #define DUMMY_ENDPOINTS ARRAY_SIZE(ep_info)
221 /*-------------------------------------------------------------------------*/
227 struct list_head urbp_list
;
228 struct sg_mapping_iter miter
;
233 enum dummy_rh_state
{
241 enum dummy_rh_state rh_state
;
242 struct timer_list timer
;
245 unsigned long re_timeout
;
247 struct usb_device
*udev
;
248 struct list_head urbp_list
;
249 struct urbp
*next_frame_urbp
;
252 u8 num_stream
[30 / 2];
255 unsigned old_active
:1;
263 * SLAVE/GADGET side support
265 struct dummy_ep ep
[DUMMY_ENDPOINTS
];
268 struct usb_gadget gadget
;
269 struct usb_gadget_driver
*driver
;
270 struct dummy_request fifo_req
;
271 u8 fifo_buf
[FIFO_SIZE
];
273 unsigned ints_enabled
:1;
274 unsigned udc_suspended
:1;
278 * MASTER/HOST side support
280 struct dummy_hcd
*hs_hcd
;
281 struct dummy_hcd
*ss_hcd
;
284 static inline struct dummy_hcd
*hcd_to_dummy_hcd(struct usb_hcd
*hcd
)
286 return (struct dummy_hcd
*) (hcd
->hcd_priv
);
289 static inline struct usb_hcd
*dummy_hcd_to_hcd(struct dummy_hcd
*dum
)
291 return container_of((void *) dum
, struct usb_hcd
, hcd_priv
);
294 static inline struct device
*dummy_dev(struct dummy_hcd
*dum
)
296 return dummy_hcd_to_hcd(dum
)->self
.controller
;
299 static inline struct device
*udc_dev(struct dummy
*dum
)
301 return dum
->gadget
.dev
.parent
;
304 static inline struct dummy
*ep_to_dummy(struct dummy_ep
*ep
)
306 return container_of(ep
->gadget
, struct dummy
, gadget
);
309 static inline struct dummy_hcd
*gadget_to_dummy_hcd(struct usb_gadget
*gadget
)
311 struct dummy
*dum
= container_of(gadget
, struct dummy
, gadget
);
312 if (dum
->gadget
.speed
== USB_SPEED_SUPER
)
318 static inline struct dummy
*gadget_dev_to_dummy(struct device
*dev
)
320 return container_of(dev
, struct dummy
, gadget
.dev
);
323 /*-------------------------------------------------------------------------*/
325 /* SLAVE/GADGET SIDE UTILITY ROUTINES */
327 /* called with spinlock held */
328 static void nuke(struct dummy
*dum
, struct dummy_ep
*ep
)
330 while (!list_empty(&ep
->queue
)) {
331 struct dummy_request
*req
;
333 req
= list_entry(ep
->queue
.next
, struct dummy_request
, queue
);
334 list_del_init(&req
->queue
);
335 req
->req
.status
= -ESHUTDOWN
;
337 spin_unlock(&dum
->lock
);
338 usb_gadget_giveback_request(&ep
->ep
, &req
->req
);
339 spin_lock(&dum
->lock
);
343 /* caller must hold lock */
344 static void stop_activity(struct dummy
*dum
)
348 /* prevent any more requests */
351 /* The timer is left running so that outstanding URBs can fail */
353 /* nuke any pending requests first, so driver i/o is quiesced */
354 for (i
= 0; i
< DUMMY_ENDPOINTS
; ++i
)
355 nuke(dum
, &dum
->ep
[i
]);
357 /* driver now does any non-usb quiescing necessary */
361 * set_link_state_by_speed() - Sets the current state of the link according to
363 * @dum_hcd: pointer to the dummy_hcd structure to update the link state for
365 * This function updates the port_status according to the link state and the
368 static void set_link_state_by_speed(struct dummy_hcd
*dum_hcd
)
370 struct dummy
*dum
= dum_hcd
->dum
;
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 /* UDC suspend must cause a disconnect */
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);
384 /* device is connected and not suspended */
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
)
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 /* UDC suspend must cause a disconnect */
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);
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
)
427 /* caller must hold lock */
428 static void set_link_state(struct dummy_hcd
*dum_hcd
)
430 struct dummy
*dum
= dum_hcd
->dum
;
431 unsigned int power_bit
;
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
))
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
);
445 if ((dum_hcd
->port_status
& USB_PORT_STAT_ENABLE
) == 0 ||
447 dum_hcd
->resuming
= 0;
449 /* Currently !connected or in reset */
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
;
457 /* Report reset and disconnect events to the driver */
458 if (dum
->ints_enabled
&& (disconnect
|| reset
)) {
460 ++dum
->callback_usage
;
461 spin_unlock(&dum
->lock
);
463 usb_gadget_udc_reset(&dum
->gadget
, dum
->driver
);
465 dum
->driver
->disconnect(&dum
->gadget
);
466 spin_lock(&dum
->lock
);
467 --dum
->callback_usage
;
469 } else if (dum_hcd
->active
!= dum_hcd
->old_active
&&
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
;
481 dum_hcd
->old_status
= dum_hcd
->port_status
;
482 dum_hcd
->old_active
= dum_hcd
->active
;
485 /*-------------------------------------------------------------------------*/
487 /* SLAVE/GADGET SIDE DRIVER
489 * This only tracks gadget state. All the work is done when the host
490 * side tries some (emulated) i/o operation. Real device controller
491 * drivers would do real i/o using dma, fifos, irqs, timers, etc.
494 #define is_enabled(dum) \
495 (dum->port_status & USB_PORT_STAT_ENABLE)
497 static int dummy_enable(struct usb_ep
*_ep
,
498 const struct usb_endpoint_descriptor
*desc
)
501 struct dummy_hcd
*dum_hcd
;
506 ep
= usb_ep_to_dummy_ep(_ep
);
507 if (!_ep
|| !desc
|| ep
->desc
|| _ep
->name
== ep0name
508 || desc
->bDescriptorType
!= USB_DT_ENDPOINT
)
510 dum
= ep_to_dummy(ep
);
514 dum_hcd
= gadget_to_dummy_hcd(&dum
->gadget
);
515 if (!is_enabled(dum_hcd
))
519 * For HS/FS devices only bits 0..10 of the wMaxPacketSize represent the
520 * maximum packet size.
521 * For SS devices the wMaxPacketSize is limited by 1024.
523 max
= usb_endpoint_maxp(desc
);
525 /* drivers must not request bad settings, since lower levels
526 * (hardware or its drivers) may not check. some endpoints
527 * can't do iso, many have maxpacket limitations, etc.
529 * since this "hardware" driver is here to help debugging, we
530 * have some extra sanity checks. (there could be more though,
531 * especially for "ep9out" style fixed function ones.)
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")) {
540 switch (dum
->gadget
.speed
) {
541 case USB_SPEED_SUPER
:
550 if (max
== 8 || max
== 16 || max
== 32 || max
== 64)
551 /* we'll fake any legal size */
553 /* save a return statement */
558 case USB_ENDPOINT_XFER_INT
:
559 if (strstr(ep
->ep
.name
, "-iso")) /* bulk is ok */
561 /* real hardware might not handle all packet sizes */
562 switch (dum
->gadget
.speed
) {
563 case USB_SPEED_SUPER
:
567 /* save a return statement */
572 /* save a return statement */
580 case USB_ENDPOINT_XFER_ISOC
:
581 if (strstr(ep
->ep
.name
, "-bulk")
582 || strstr(ep
->ep
.name
, "-int"))
584 /* real hardware might not handle all packet sizes */
585 switch (dum
->gadget
.speed
) {
586 case USB_SPEED_SUPER
:
590 /* save a return statement */
595 /* save a return statement */
601 /* few chips support control except on ep0 */
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
);
616 dev_dbg(udc_dev(dum
), "enabled %s (ep%d%s-%s) maxpacket %d stream %s\n",
618 desc
->bEndpointAddress
& 0x0f,
619 (desc
->bEndpointAddress
& USB_DIR_IN
) ? "in" : "out",
621 switch (usb_endpoint_type(desc
)) {
622 case USB_ENDPOINT_XFER_BULK
:
625 case USB_ENDPOINT_XFER_ISOC
:
628 case USB_ENDPOINT_XFER_INT
:
635 max
, ep
->stream_en
? "enabled" : "disabled");
637 /* at this point real hardware should be NAKing transfers
638 * to that endpoint, until a buffer is queued to it.
640 ep
->halted
= ep
->wedged
= 0;
646 static int dummy_disable(struct usb_ep
*_ep
)
652 ep
= usb_ep_to_dummy_ep(_ep
);
653 if (!_ep
|| !ep
->desc
|| _ep
->name
== ep0name
)
655 dum
= ep_to_dummy(ep
);
657 spin_lock_irqsave(&dum
->lock
, flags
);
661 spin_unlock_irqrestore(&dum
->lock
, flags
);
663 dev_dbg(udc_dev(dum
), "disabled %s\n", _ep
->name
);
667 static struct usb_request
*dummy_alloc_request(struct usb_ep
*_ep
,
670 struct dummy_request
*req
;
675 req
= kzalloc(sizeof(*req
), mem_flags
);
678 INIT_LIST_HEAD(&req
->queue
);
682 static void dummy_free_request(struct usb_ep
*_ep
, struct usb_request
*_req
)
684 struct dummy_request
*req
;
691 req
= usb_request_to_dummy_request(_req
);
692 WARN_ON(!list_empty(&req
->queue
));
696 static void fifo_complete(struct usb_ep
*ep
, struct usb_request
*req
)
700 static int dummy_queue(struct usb_ep
*_ep
, struct usb_request
*_req
,
704 struct dummy_request
*req
;
706 struct dummy_hcd
*dum_hcd
;
709 req
= usb_request_to_dummy_request(_req
);
710 if (!_req
|| !list_empty(&req
->queue
) || !_req
->complete
)
713 ep
= usb_ep_to_dummy_ep(_ep
);
714 if (!_ep
|| (!ep
->desc
&& _ep
->name
!= ep0name
))
717 dum
= ep_to_dummy(ep
);
718 dum_hcd
= gadget_to_dummy_hcd(&dum
->gadget
);
719 if (!dum
->driver
|| !is_enabled(dum_hcd
))
723 dev_dbg(udc_dev(dum
), "ep %p queue req %p to %s, len %d buf %p\n",
724 ep
, _req
, _ep
->name
, _req
->length
, _req
->buf
);
726 _req
->status
= -EINPROGRESS
;
728 spin_lock_irqsave(&dum
->lock
, flags
);
730 /* implement an emulated single-request FIFO */
731 if (ep
->desc
&& (ep
->desc
->bEndpointAddress
& USB_DIR_IN
) &&
732 list_empty(&dum
->fifo_req
.queue
) &&
733 list_empty(&ep
->queue
) &&
734 _req
->length
<= FIFO_SIZE
) {
735 req
= &dum
->fifo_req
;
737 req
->req
.buf
= dum
->fifo_buf
;
738 memcpy(dum
->fifo_buf
, _req
->buf
, _req
->length
);
739 req
->req
.context
= dum
;
740 req
->req
.complete
= fifo_complete
;
742 list_add_tail(&req
->queue
, &ep
->queue
);
743 spin_unlock(&dum
->lock
);
744 _req
->actual
= _req
->length
;
746 usb_gadget_giveback_request(_ep
, _req
);
747 spin_lock(&dum
->lock
);
749 list_add_tail(&req
->queue
, &ep
->queue
);
750 spin_unlock_irqrestore(&dum
->lock
, flags
);
752 /* real hardware would likely enable transfers here, in case
753 * it'd been left NAKing.
758 static int dummy_dequeue(struct usb_ep
*_ep
, struct usb_request
*_req
)
762 int retval
= -EINVAL
;
764 struct dummy_request
*req
= NULL
;
768 ep
= usb_ep_to_dummy_ep(_ep
);
769 dum
= ep_to_dummy(ep
);
774 local_irq_save(flags
);
775 spin_lock(&dum
->lock
);
776 list_for_each_entry(req
, &ep
->queue
, queue
) {
777 if (&req
->req
== _req
) {
778 list_del_init(&req
->queue
);
779 _req
->status
= -ECONNRESET
;
784 spin_unlock(&dum
->lock
);
787 dev_dbg(udc_dev(dum
),
788 "dequeued req %p from %s, len %d buf %p\n",
789 req
, _ep
->name
, _req
->length
, _req
->buf
);
790 usb_gadget_giveback_request(_ep
, _req
);
792 local_irq_restore(flags
);
797 dummy_set_halt_and_wedge(struct usb_ep
*_ep
, int value
, int wedged
)
804 ep
= usb_ep_to_dummy_ep(_ep
);
805 dum
= ep_to_dummy(ep
);
809 ep
->halted
= ep
->wedged
= 0;
810 else if (ep
->desc
&& (ep
->desc
->bEndpointAddress
& USB_DIR_IN
) &&
811 !list_empty(&ep
->queue
))
818 /* FIXME clear emulated data toggle too */
823 dummy_set_halt(struct usb_ep
*_ep
, int value
)
825 return dummy_set_halt_and_wedge(_ep
, value
, 0);
828 static int dummy_set_wedge(struct usb_ep
*_ep
)
830 if (!_ep
|| _ep
->name
== ep0name
)
832 return dummy_set_halt_and_wedge(_ep
, 1, 1);
835 static const struct usb_ep_ops dummy_ep_ops
= {
836 .enable
= dummy_enable
,
837 .disable
= dummy_disable
,
839 .alloc_request
= dummy_alloc_request
,
840 .free_request
= dummy_free_request
,
842 .queue
= dummy_queue
,
843 .dequeue
= dummy_dequeue
,
845 .set_halt
= dummy_set_halt
,
846 .set_wedge
= dummy_set_wedge
,
849 /*-------------------------------------------------------------------------*/
851 /* there are both host and device side versions of this call ... */
852 static int dummy_g_get_frame(struct usb_gadget
*_gadget
)
854 struct timespec64 ts64
;
856 ktime_get_ts64(&ts64
);
857 return ts64
.tv_nsec
/ NSEC_PER_MSEC
;
860 static int dummy_wakeup(struct usb_gadget
*_gadget
)
862 struct dummy_hcd
*dum_hcd
;
864 dum_hcd
= gadget_to_dummy_hcd(_gadget
);
865 if (!(dum_hcd
->dum
->devstatus
& ((1 << USB_DEVICE_B_HNP_ENABLE
)
866 | (1 << USB_DEVICE_REMOTE_WAKEUP
))))
868 if ((dum_hcd
->port_status
& USB_PORT_STAT_CONNECTION
) == 0)
870 if ((dum_hcd
->port_status
& USB_PORT_STAT_SUSPEND
) == 0 &&
871 dum_hcd
->rh_state
!= DUMMY_RH_SUSPENDED
)
874 /* FIXME: What if the root hub is suspended but the port isn't? */
876 /* hub notices our request, issues downstream resume, etc */
877 dum_hcd
->resuming
= 1;
878 dum_hcd
->re_timeout
= jiffies
+ msecs_to_jiffies(20);
879 mod_timer(&dummy_hcd_to_hcd(dum_hcd
)->rh_timer
, dum_hcd
->re_timeout
);
883 static int dummy_set_selfpowered(struct usb_gadget
*_gadget
, int value
)
887 _gadget
->is_selfpowered
= (value
!= 0);
888 dum
= gadget_to_dummy_hcd(_gadget
)->dum
;
890 dum
->devstatus
|= (1 << USB_DEVICE_SELF_POWERED
);
892 dum
->devstatus
&= ~(1 << USB_DEVICE_SELF_POWERED
);
896 static void dummy_udc_update_ep0(struct dummy
*dum
)
898 if (dum
->gadget
.speed
== USB_SPEED_SUPER
)
899 dum
->ep
[0].ep
.maxpacket
= 9;
901 dum
->ep
[0].ep
.maxpacket
= 64;
904 static int dummy_pullup(struct usb_gadget
*_gadget
, int value
)
906 struct dummy_hcd
*dum_hcd
;
910 dum
= gadget_dev_to_dummy(&_gadget
->dev
);
911 dum_hcd
= gadget_to_dummy_hcd(_gadget
);
913 spin_lock_irqsave(&dum
->lock
, flags
);
914 dum
->pullup
= (value
!= 0);
915 set_link_state(dum_hcd
);
916 spin_unlock_irqrestore(&dum
->lock
, flags
);
918 usb_hcd_poll_rh_status(dummy_hcd_to_hcd(dum_hcd
));
922 static void dummy_udc_set_speed(struct usb_gadget
*_gadget
,
923 enum usb_device_speed speed
)
927 dum
= gadget_dev_to_dummy(&_gadget
->dev
);
929 if (mod_data
.is_super_speed
)
930 dum
->gadget
.speed
= min_t(u8
, USB_SPEED_SUPER
, speed
);
931 else if (mod_data
.is_high_speed
)
932 dum
->gadget
.speed
= min_t(u8
, USB_SPEED_HIGH
, speed
);
934 dum
->gadget
.speed
= USB_SPEED_FULL
;
936 dummy_udc_update_ep0(dum
);
938 if (dum
->gadget
.speed
< speed
)
939 dev_dbg(udc_dev(dum
), "This device can perform faster"
940 " if you connect it to a %s port...\n",
941 usb_speed_string(speed
));
944 static int dummy_udc_start(struct usb_gadget
*g
,
945 struct usb_gadget_driver
*driver
);
946 static int dummy_udc_stop(struct usb_gadget
*g
);
948 static const struct usb_gadget_ops dummy_ops
= {
949 .get_frame
= dummy_g_get_frame
,
950 .wakeup
= dummy_wakeup
,
951 .set_selfpowered
= dummy_set_selfpowered
,
952 .pullup
= dummy_pullup
,
953 .udc_start
= dummy_udc_start
,
954 .udc_stop
= dummy_udc_stop
,
955 .udc_set_speed
= dummy_udc_set_speed
,
958 /*-------------------------------------------------------------------------*/
960 /* "function" sysfs attribute */
961 static ssize_t
function_show(struct device
*dev
, struct device_attribute
*attr
,
964 struct dummy
*dum
= gadget_dev_to_dummy(dev
);
966 if (!dum
->driver
|| !dum
->driver
->function
)
968 return scnprintf(buf
, PAGE_SIZE
, "%s\n", dum
->driver
->function
);
970 static DEVICE_ATTR_RO(function
);
972 /*-------------------------------------------------------------------------*/
975 * Driver registration/unregistration.
977 * This is basically hardware-specific; there's usually only one real USB
978 * device (not host) controller since that's how USB devices are intended
979 * to work. So most implementations of these api calls will rely on the
980 * fact that only one driver will ever bind to the hardware. But curious
981 * hardware can be built with discrete components, so the gadget API doesn't
982 * require that assumption.
984 * For this emulator, it might be convenient to create a usb slave device
985 * for each driver that registers: just add to a big root hub.
988 static int dummy_udc_start(struct usb_gadget
*g
,
989 struct usb_gadget_driver
*driver
)
991 struct dummy_hcd
*dum_hcd
= gadget_to_dummy_hcd(g
);
992 struct dummy
*dum
= dum_hcd
->dum
;
994 if (driver
->max_speed
== USB_SPEED_UNKNOWN
)
998 * SLAVE side init ... the layer above hardware, which
999 * can't enumerate without help from the driver we're binding.
1002 spin_lock_irq(&dum
->lock
);
1004 dum
->driver
= driver
;
1005 dum
->ints_enabled
= 1;
1006 spin_unlock_irq(&dum
->lock
);
1011 static int dummy_udc_stop(struct usb_gadget
*g
)
1013 struct dummy_hcd
*dum_hcd
= gadget_to_dummy_hcd(g
);
1014 struct dummy
*dum
= dum_hcd
->dum
;
1016 spin_lock_irq(&dum
->lock
);
1017 dum
->ints_enabled
= 0;
1020 /* emulate synchronize_irq(): wait for callbacks to finish */
1021 while (dum
->callback_usage
> 0) {
1022 spin_unlock_irq(&dum
->lock
);
1023 usleep_range(1000, 2000);
1024 spin_lock_irq(&dum
->lock
);
1028 spin_unlock_irq(&dum
->lock
);
1035 /* The gadget structure is stored inside the hcd structure and will be
1036 * released along with it. */
1037 static void init_dummy_udc_hw(struct dummy
*dum
)
1041 INIT_LIST_HEAD(&dum
->gadget
.ep_list
);
1042 for (i
= 0; i
< DUMMY_ENDPOINTS
; i
++) {
1043 struct dummy_ep
*ep
= &dum
->ep
[i
];
1045 if (!ep_info
[i
].name
)
1047 ep
->ep
.name
= ep_info
[i
].name
;
1048 ep
->ep
.caps
= ep_info
[i
].caps
;
1049 ep
->ep
.ops
= &dummy_ep_ops
;
1050 list_add_tail(&ep
->ep
.ep_list
, &dum
->gadget
.ep_list
);
1051 ep
->halted
= ep
->wedged
= ep
->already_seen
=
1052 ep
->setup_stage
= 0;
1053 usb_ep_set_maxpacket_limit(&ep
->ep
, ~0);
1054 ep
->ep
.max_streams
= 16;
1055 ep
->last_io
= jiffies
;
1056 ep
->gadget
= &dum
->gadget
;
1058 INIT_LIST_HEAD(&ep
->queue
);
1061 dum
->gadget
.ep0
= &dum
->ep
[0].ep
;
1062 list_del_init(&dum
->ep
[0].ep
.ep_list
);
1063 INIT_LIST_HEAD(&dum
->fifo_req
.queue
);
1065 #ifdef CONFIG_USB_OTG
1066 dum
->gadget
.is_otg
= 1;
1070 static int dummy_udc_probe(struct platform_device
*pdev
)
1075 dum
= *((void **)dev_get_platdata(&pdev
->dev
));
1076 /* Clear usb_gadget region for new registration to udc-core */
1077 memzero_explicit(&dum
->gadget
, sizeof(struct usb_gadget
));
1078 dum
->gadget
.name
= gadget_name
;
1079 dum
->gadget
.ops
= &dummy_ops
;
1080 if (mod_data
.is_super_speed
)
1081 dum
->gadget
.max_speed
= USB_SPEED_SUPER
;
1082 else if (mod_data
.is_high_speed
)
1083 dum
->gadget
.max_speed
= USB_SPEED_HIGH
;
1085 dum
->gadget
.max_speed
= USB_SPEED_FULL
;
1087 dum
->gadget
.dev
.parent
= &pdev
->dev
;
1088 init_dummy_udc_hw(dum
);
1090 rc
= usb_add_gadget_udc(&pdev
->dev
, &dum
->gadget
);
1094 rc
= device_create_file(&dum
->gadget
.dev
, &dev_attr_function
);
1097 platform_set_drvdata(pdev
, dum
);
1101 usb_del_gadget_udc(&dum
->gadget
);
1106 static int dummy_udc_remove(struct platform_device
*pdev
)
1108 struct dummy
*dum
= platform_get_drvdata(pdev
);
1110 device_remove_file(&dum
->gadget
.dev
, &dev_attr_function
);
1111 usb_del_gadget_udc(&dum
->gadget
);
1115 static void dummy_udc_pm(struct dummy
*dum
, struct dummy_hcd
*dum_hcd
,
1118 spin_lock_irq(&dum
->lock
);
1119 dum
->udc_suspended
= suspend
;
1120 set_link_state(dum_hcd
);
1121 spin_unlock_irq(&dum
->lock
);
1124 static int dummy_udc_suspend(struct platform_device
*pdev
, pm_message_t state
)
1126 struct dummy
*dum
= platform_get_drvdata(pdev
);
1127 struct dummy_hcd
*dum_hcd
= gadget_to_dummy_hcd(&dum
->gadget
);
1129 dev_dbg(&pdev
->dev
, "%s\n", __func__
);
1130 dummy_udc_pm(dum
, dum_hcd
, 1);
1131 usb_hcd_poll_rh_status(dummy_hcd_to_hcd(dum_hcd
));
1135 static int dummy_udc_resume(struct platform_device
*pdev
)
1137 struct dummy
*dum
= platform_get_drvdata(pdev
);
1138 struct dummy_hcd
*dum_hcd
= gadget_to_dummy_hcd(&dum
->gadget
);
1140 dev_dbg(&pdev
->dev
, "%s\n", __func__
);
1141 dummy_udc_pm(dum
, dum_hcd
, 0);
1142 usb_hcd_poll_rh_status(dummy_hcd_to_hcd(dum_hcd
));
1146 static struct platform_driver dummy_udc_driver
= {
1147 .probe
= dummy_udc_probe
,
1148 .remove
= dummy_udc_remove
,
1149 .suspend
= dummy_udc_suspend
,
1150 .resume
= dummy_udc_resume
,
1152 .name
= (char *) gadget_name
,
1156 /*-------------------------------------------------------------------------*/
1158 static unsigned int dummy_get_ep_idx(const struct usb_endpoint_descriptor
*desc
)
1162 index
= usb_endpoint_num(desc
) << 1;
1163 if (usb_endpoint_dir_in(desc
))
1168 /* MASTER/HOST SIDE DRIVER
1170 * this uses the hcd framework to hook up to host side drivers.
1171 * its root hub will only have one device, otherwise it acts like
1172 * a normal host controller.
1174 * when urbs are queued, they're just stuck on a list that we
1175 * scan in a timer callback. that callback connects writes from
1176 * the host with reads from the device, and so on, based on the
1180 static int dummy_ep_stream_en(struct dummy_hcd
*dum_hcd
, struct urb
*urb
)
1182 const struct usb_endpoint_descriptor
*desc
= &urb
->ep
->desc
;
1185 if (!usb_endpoint_xfer_bulk(desc
))
1188 index
= dummy_get_ep_idx(desc
);
1189 return (1 << index
) & dum_hcd
->stream_en_ep
;
1193 * The max stream number is saved as a nibble so for the 30 possible endpoints
1194 * we only 15 bytes of memory. Therefore we are limited to max 16 streams (0
1195 * means we use only 1 stream). The maximum according to the spec is 16bit so
1196 * if the 16 stream limit is about to go, the array size should be incremented
1197 * to 30 elements of type u16.
1199 static int get_max_streams_for_pipe(struct dummy_hcd
*dum_hcd
,
1204 max_streams
= dum_hcd
->num_stream
[usb_pipeendpoint(pipe
)];
1205 if (usb_pipeout(pipe
))
1213 static void set_max_streams_for_pipe(struct dummy_hcd
*dum_hcd
,
1214 unsigned int pipe
, unsigned int streams
)
1219 max_streams
= dum_hcd
->num_stream
[usb_pipeendpoint(pipe
)];
1220 if (usb_pipeout(pipe
)) {
1224 max_streams
&= 0xf0;
1226 max_streams
|= streams
;
1227 dum_hcd
->num_stream
[usb_pipeendpoint(pipe
)] = max_streams
;
1230 static int dummy_validate_stream(struct dummy_hcd
*dum_hcd
, struct urb
*urb
)
1232 unsigned int max_streams
;
1235 enabled
= dummy_ep_stream_en(dum_hcd
, urb
);
1236 if (!urb
->stream_id
) {
1244 max_streams
= get_max_streams_for_pipe(dum_hcd
,
1245 usb_pipeendpoint(urb
->pipe
));
1246 if (urb
->stream_id
> max_streams
) {
1247 dev_err(dummy_dev(dum_hcd
), "Stream id %d is out of range.\n",
1255 static int dummy_urb_enqueue(
1256 struct usb_hcd
*hcd
,
1260 struct dummy_hcd
*dum_hcd
;
1262 unsigned long flags
;
1265 urbp
= kmalloc(sizeof *urbp
, mem_flags
);
1269 urbp
->miter_started
= 0;
1271 dum_hcd
= hcd_to_dummy_hcd(hcd
);
1272 spin_lock_irqsave(&dum_hcd
->dum
->lock
, flags
);
1274 rc
= dummy_validate_stream(dum_hcd
, urb
);
1280 rc
= usb_hcd_link_urb_to_ep(hcd
, urb
);
1286 if (!dum_hcd
->udev
) {
1287 dum_hcd
->udev
= urb
->dev
;
1288 usb_get_dev(dum_hcd
->udev
);
1289 } else if (unlikely(dum_hcd
->udev
!= urb
->dev
))
1290 dev_err(dummy_dev(dum_hcd
), "usb_device address has changed!\n");
1292 list_add_tail(&urbp
->urbp_list
, &dum_hcd
->urbp_list
);
1294 if (!dum_hcd
->next_frame_urbp
)
1295 dum_hcd
->next_frame_urbp
= urbp
;
1296 if (usb_pipetype(urb
->pipe
) == PIPE_CONTROL
)
1297 urb
->error_count
= 1; /* mark as a new urb */
1299 /* kick the scheduler, it'll do the rest */
1300 if (!timer_pending(&dum_hcd
->timer
))
1301 mod_timer(&dum_hcd
->timer
, jiffies
+ 1);
1304 spin_unlock_irqrestore(&dum_hcd
->dum
->lock
, flags
);
1308 static int dummy_urb_dequeue(struct usb_hcd
*hcd
, struct urb
*urb
, int status
)
1310 struct dummy_hcd
*dum_hcd
;
1311 unsigned long flags
;
1314 /* giveback happens automatically in timer callback,
1315 * so make sure the callback happens */
1316 dum_hcd
= hcd_to_dummy_hcd(hcd
);
1317 spin_lock_irqsave(&dum_hcd
->dum
->lock
, flags
);
1319 rc
= usb_hcd_check_unlink_urb(hcd
, urb
, status
);
1320 if (!rc
&& dum_hcd
->rh_state
!= DUMMY_RH_RUNNING
&&
1321 !list_empty(&dum_hcd
->urbp_list
))
1322 mod_timer(&dum_hcd
->timer
, jiffies
);
1324 spin_unlock_irqrestore(&dum_hcd
->dum
->lock
, flags
);
1328 static int dummy_perform_transfer(struct urb
*urb
, struct dummy_request
*req
,
1332 struct urbp
*urbp
= urb
->hcpriv
;
1334 struct sg_mapping_iter
*miter
= &urbp
->miter
;
1339 to_host
= usb_pipein(urb
->pipe
);
1340 rbuf
= req
->req
.buf
+ req
->req
.actual
;
1342 if (!urb
->num_sgs
) {
1343 ubuf
= urb
->transfer_buffer
+ urb
->actual_length
;
1345 memcpy(ubuf
, rbuf
, len
);
1347 memcpy(rbuf
, ubuf
, len
);
1351 if (!urbp
->miter_started
) {
1352 u32 flags
= SG_MITER_ATOMIC
;
1355 flags
|= SG_MITER_TO_SG
;
1357 flags
|= SG_MITER_FROM_SG
;
1359 sg_miter_start(miter
, urb
->sg
, urb
->num_sgs
, flags
);
1360 urbp
->miter_started
= 1;
1362 next_sg
= sg_miter_next(miter
);
1363 if (next_sg
== false) {
1369 this_sg
= min_t(u32
, len
, miter
->length
);
1370 miter
->consumed
= this_sg
;
1374 memcpy(ubuf
, rbuf
, this_sg
);
1376 memcpy(rbuf
, ubuf
, this_sg
);
1381 next_sg
= sg_miter_next(miter
);
1382 if (next_sg
== false) {
1390 sg_miter_stop(miter
);
1394 /* transfer up to a frame's worth; caller must own lock */
1395 static int transfer(struct dummy_hcd
*dum_hcd
, struct urb
*urb
,
1396 struct dummy_ep
*ep
, int limit
, int *status
)
1398 struct dummy
*dum
= dum_hcd
->dum
;
1399 struct dummy_request
*req
;
1403 /* if there's no request queued, the device is NAKing; return */
1404 list_for_each_entry(req
, &ep
->queue
, queue
) {
1405 unsigned host_len
, dev_len
, len
;
1406 int is_short
, to_host
;
1409 if (dummy_ep_stream_en(dum_hcd
, urb
)) {
1410 if ((urb
->stream_id
!= req
->req
.stream_id
))
1414 /* 1..N packets of ep->ep.maxpacket each ... the last one
1415 * may be short (including zero length).
1417 * writer can send a zlp explicitly (length 0) or implicitly
1418 * (length mod maxpacket zero, and 'zero' flag); they always
1421 host_len
= urb
->transfer_buffer_length
- urb
->actual_length
;
1422 dev_len
= req
->req
.length
- req
->req
.actual
;
1423 len
= min(host_len
, dev_len
);
1425 /* FIXME update emulated data toggle too */
1427 to_host
= usb_pipein(urb
->pipe
);
1428 if (unlikely(len
== 0))
1431 /* not enough bandwidth left? */
1432 if (limit
< ep
->ep
.maxpacket
&& limit
< len
)
1434 len
= min_t(unsigned, len
, limit
);
1438 /* send multiple of maxpacket first, then remainder */
1439 if (len
>= ep
->ep
.maxpacket
) {
1441 if (len
% ep
->ep
.maxpacket
)
1443 len
-= len
% ep
->ep
.maxpacket
;
1448 len
= dummy_perform_transfer(urb
, req
, len
);
1450 ep
->last_io
= jiffies
;
1452 req
->req
.status
= len
;
1456 urb
->actual_length
+= len
;
1457 req
->req
.actual
+= len
;
1461 /* short packets terminate, maybe with overflow/underflow.
1462 * it's only really an error to write too much.
1464 * partially filling a buffer optionally blocks queue advances
1465 * (so completion handlers can clean up the queue) but we don't
1466 * need to emulate such data-in-flight.
1469 if (host_len
== dev_len
) {
1470 req
->req
.status
= 0;
1472 } else if (to_host
) {
1473 req
->req
.status
= 0;
1474 if (dev_len
> host_len
)
1475 *status
= -EOVERFLOW
;
1480 if (host_len
> dev_len
)
1481 req
->req
.status
= -EOVERFLOW
;
1483 req
->req
.status
= 0;
1487 * many requests terminate without a short packet.
1488 * send a zlp if demanded by flags.
1491 if (req
->req
.length
== req
->req
.actual
) {
1492 if (req
->req
.zero
&& to_host
)
1495 req
->req
.status
= 0;
1497 if (urb
->transfer_buffer_length
== urb
->actual_length
) {
1498 if (urb
->transfer_flags
& URB_ZERO_PACKET
&&
1506 /* device side completion --> continuable */
1507 if (req
->req
.status
!= -EINPROGRESS
) {
1508 list_del_init(&req
->queue
);
1510 spin_unlock(&dum
->lock
);
1511 usb_gadget_giveback_request(&ep
->ep
, &req
->req
);
1512 spin_lock(&dum
->lock
);
1514 /* requests might have been unlinked... */
1518 /* host side completion --> terminate */
1519 if (*status
!= -EINPROGRESS
)
1522 /* rescan to continue with any other queued i/o */
1529 static int periodic_bytes(struct dummy
*dum
, struct dummy_ep
*ep
)
1531 int limit
= ep
->ep
.maxpacket
;
1533 if (dum
->gadget
.speed
== USB_SPEED_HIGH
) {
1536 /* high bandwidth mode */
1537 tmp
= usb_endpoint_maxp_mult(ep
->desc
);
1538 tmp
*= 8 /* applies to entire frame */;
1539 limit
+= limit
* tmp
;
1541 if (dum
->gadget
.speed
== USB_SPEED_SUPER
) {
1542 switch (usb_endpoint_type(ep
->desc
)) {
1543 case USB_ENDPOINT_XFER_ISOC
:
1544 /* Sec. 4.4.8.2 USB3.0 Spec */
1545 limit
= 3 * 16 * 1024 * 8;
1547 case USB_ENDPOINT_XFER_INT
:
1548 /* Sec. 4.4.7.2 USB3.0 Spec */
1549 limit
= 3 * 1024 * 8;
1551 case USB_ENDPOINT_XFER_BULK
:
1559 #define is_active(dum_hcd) ((dum_hcd->port_status & \
1560 (USB_PORT_STAT_CONNECTION | USB_PORT_STAT_ENABLE | \
1561 USB_PORT_STAT_SUSPEND)) \
1562 == (USB_PORT_STAT_CONNECTION | USB_PORT_STAT_ENABLE))
1564 static struct dummy_ep
*find_endpoint(struct dummy
*dum
, u8 address
)
1568 if (!is_active((dum
->gadget
.speed
== USB_SPEED_SUPER
?
1569 dum
->ss_hcd
: dum
->hs_hcd
)))
1571 if (!dum
->ints_enabled
)
1573 if ((address
& ~USB_DIR_IN
) == 0)
1575 for (i
= 1; i
< DUMMY_ENDPOINTS
; i
++) {
1576 struct dummy_ep
*ep
= &dum
->ep
[i
];
1580 if (ep
->desc
->bEndpointAddress
== address
)
1588 #define Dev_Request (USB_TYPE_STANDARD | USB_RECIP_DEVICE)
1589 #define Dev_InRequest (Dev_Request | USB_DIR_IN)
1590 #define Intf_Request (USB_TYPE_STANDARD | USB_RECIP_INTERFACE)
1591 #define Intf_InRequest (Intf_Request | USB_DIR_IN)
1592 #define Ep_Request (USB_TYPE_STANDARD | USB_RECIP_ENDPOINT)
1593 #define Ep_InRequest (Ep_Request | USB_DIR_IN)
1597 * handle_control_request() - handles all control transfers
1598 * @dum: pointer to dummy (the_controller)
1599 * @urb: the urb request to handle
1600 * @setup: pointer to the setup data for a USB device control
1602 * @status: pointer to request handling status
1604 * Return 0 - if the request was handled
1605 * 1 - if the request wasn't handles
1606 * error code on error
1608 static int handle_control_request(struct dummy_hcd
*dum_hcd
, struct urb
*urb
,
1609 struct usb_ctrlrequest
*setup
,
1612 struct dummy_ep
*ep2
;
1613 struct dummy
*dum
= dum_hcd
->dum
;
1618 w_index
= le16_to_cpu(setup
->wIndex
);
1619 w_value
= le16_to_cpu(setup
->wValue
);
1620 switch (setup
->bRequest
) {
1621 case USB_REQ_SET_ADDRESS
:
1622 if (setup
->bRequestType
!= Dev_Request
)
1624 dum
->address
= w_value
;
1626 dev_dbg(udc_dev(dum
), "set_address = %d\n",
1630 case USB_REQ_SET_FEATURE
:
1631 if (setup
->bRequestType
== Dev_Request
) {
1634 case USB_DEVICE_REMOTE_WAKEUP
:
1636 case USB_DEVICE_B_HNP_ENABLE
:
1637 dum
->gadget
.b_hnp_enable
= 1;
1639 case USB_DEVICE_A_HNP_SUPPORT
:
1640 dum
->gadget
.a_hnp_support
= 1;
1642 case USB_DEVICE_A_ALT_HNP_SUPPORT
:
1643 dum
->gadget
.a_alt_hnp_support
= 1;
1645 case USB_DEVICE_U1_ENABLE
:
1646 if (dummy_hcd_to_hcd(dum_hcd
)->speed
==
1648 w_value
= USB_DEV_STAT_U1_ENABLED
;
1650 ret_val
= -EOPNOTSUPP
;
1652 case USB_DEVICE_U2_ENABLE
:
1653 if (dummy_hcd_to_hcd(dum_hcd
)->speed
==
1655 w_value
= USB_DEV_STAT_U2_ENABLED
;
1657 ret_val
= -EOPNOTSUPP
;
1659 case USB_DEVICE_LTM_ENABLE
:
1660 if (dummy_hcd_to_hcd(dum_hcd
)->speed
==
1662 w_value
= USB_DEV_STAT_LTM_ENABLED
;
1664 ret_val
= -EOPNOTSUPP
;
1667 ret_val
= -EOPNOTSUPP
;
1670 dum
->devstatus
|= (1 << w_value
);
1673 } else if (setup
->bRequestType
== Ep_Request
) {
1675 ep2
= find_endpoint(dum
, w_index
);
1676 if (!ep2
|| ep2
->ep
.name
== ep0name
) {
1677 ret_val
= -EOPNOTSUPP
;
1685 case USB_REQ_CLEAR_FEATURE
:
1686 if (setup
->bRequestType
== Dev_Request
) {
1689 case USB_DEVICE_REMOTE_WAKEUP
:
1690 w_value
= USB_DEVICE_REMOTE_WAKEUP
;
1692 case USB_DEVICE_U1_ENABLE
:
1693 if (dummy_hcd_to_hcd(dum_hcd
)->speed
==
1695 w_value
= USB_DEV_STAT_U1_ENABLED
;
1697 ret_val
= -EOPNOTSUPP
;
1699 case USB_DEVICE_U2_ENABLE
:
1700 if (dummy_hcd_to_hcd(dum_hcd
)->speed
==
1702 w_value
= USB_DEV_STAT_U2_ENABLED
;
1704 ret_val
= -EOPNOTSUPP
;
1706 case USB_DEVICE_LTM_ENABLE
:
1707 if (dummy_hcd_to_hcd(dum_hcd
)->speed
==
1709 w_value
= USB_DEV_STAT_LTM_ENABLED
;
1711 ret_val
= -EOPNOTSUPP
;
1714 ret_val
= -EOPNOTSUPP
;
1718 dum
->devstatus
&= ~(1 << w_value
);
1721 } else if (setup
->bRequestType
== Ep_Request
) {
1723 ep2
= find_endpoint(dum
, w_index
);
1725 ret_val
= -EOPNOTSUPP
;
1734 case USB_REQ_GET_STATUS
:
1735 if (setup
->bRequestType
== Dev_InRequest
1736 || setup
->bRequestType
== Intf_InRequest
1737 || setup
->bRequestType
== Ep_InRequest
) {
1740 * device: remote wakeup, selfpowered
1741 * interface: nothing
1744 buf
= (char *)urb
->transfer_buffer
;
1745 if (urb
->transfer_buffer_length
> 0) {
1746 if (setup
->bRequestType
== Ep_InRequest
) {
1747 ep2
= find_endpoint(dum
, w_index
);
1749 ret_val
= -EOPNOTSUPP
;
1752 buf
[0] = ep2
->halted
;
1753 } else if (setup
->bRequestType
==
1755 buf
[0] = (u8
)dum
->devstatus
;
1759 if (urb
->transfer_buffer_length
> 1)
1761 urb
->actual_length
= min_t(u32
, 2,
1762 urb
->transfer_buffer_length
);
1771 /* drive both sides of the transfers; looks like irq handlers to
1772 * both drivers except the callbacks aren't in_irq().
1774 static void dummy_timer(unsigned long _dum_hcd
)
1776 struct dummy_hcd
*dum_hcd
= (struct dummy_hcd
*) _dum_hcd
;
1777 struct dummy
*dum
= dum_hcd
->dum
;
1778 struct urbp
*urbp
, *tmp
;
1779 unsigned long flags
;
1783 /* simplistic model for one frame's bandwidth */
1784 /* FIXME: account for transaction and packet overhead */
1785 switch (dum
->gadget
.speed
) {
1787 total
= 8/*bytes*/ * 12/*packets*/;
1789 case USB_SPEED_FULL
:
1790 total
= 64/*bytes*/ * 19/*packets*/;
1792 case USB_SPEED_HIGH
:
1793 total
= 512/*bytes*/ * 13/*packets*/ * 8/*uframes*/;
1795 case USB_SPEED_SUPER
:
1796 /* Bus speed is 500000 bytes/ms, so use a little less */
1800 dev_err(dummy_dev(dum_hcd
), "bogus device speed\n");
1804 /* FIXME if HZ != 1000 this will probably misbehave ... */
1806 /* look at each urb queued by the host side driver */
1807 spin_lock_irqsave(&dum
->lock
, flags
);
1809 if (!dum_hcd
->udev
) {
1810 dev_err(dummy_dev(dum_hcd
),
1811 "timer fired with no URBs pending?\n");
1812 spin_unlock_irqrestore(&dum
->lock
, flags
);
1815 dum_hcd
->next_frame_urbp
= NULL
;
1817 for (i
= 0; i
< DUMMY_ENDPOINTS
; i
++) {
1818 if (!ep_info
[i
].name
)
1820 dum
->ep
[i
].already_seen
= 0;
1824 list_for_each_entry_safe(urbp
, tmp
, &dum_hcd
->urbp_list
, urbp_list
) {
1826 struct dummy_request
*req
;
1828 struct dummy_ep
*ep
= NULL
;
1829 int status
= -EINPROGRESS
;
1831 /* stop when we reach URBs queued after the timer interrupt */
1832 if (urbp
== dum_hcd
->next_frame_urbp
)
1838 else if (dum_hcd
->rh_state
!= DUMMY_RH_RUNNING
)
1841 /* Used up this frame's bandwidth? */
1845 /* find the gadget's ep for this request (if configured) */
1846 address
= usb_pipeendpoint (urb
->pipe
);
1847 if (usb_pipein(urb
->pipe
))
1848 address
|= USB_DIR_IN
;
1849 ep
= find_endpoint(dum
, address
);
1851 /* set_configuration() disagreement */
1852 dev_dbg(dummy_dev(dum_hcd
),
1853 "no ep configured for urb %p\n",
1859 if (ep
->already_seen
)
1861 ep
->already_seen
= 1;
1862 if (ep
== &dum
->ep
[0] && urb
->error_count
) {
1863 ep
->setup_stage
= 1; /* a new urb */
1864 urb
->error_count
= 0;
1866 if (ep
->halted
&& !ep
->setup_stage
) {
1867 /* NOTE: must not be iso! */
1868 dev_dbg(dummy_dev(dum_hcd
), "ep %s halted, urb %p\n",
1873 /* FIXME make sure both ends agree on maxpacket */
1875 /* handle control requests */
1876 if (ep
== &dum
->ep
[0] && ep
->setup_stage
) {
1877 struct usb_ctrlrequest setup
;
1880 setup
= *(struct usb_ctrlrequest
*) urb
->setup_packet
;
1881 /* paranoia, in case of stale queued data */
1882 list_for_each_entry(req
, &ep
->queue
, queue
) {
1883 list_del_init(&req
->queue
);
1884 req
->req
.status
= -EOVERFLOW
;
1885 dev_dbg(udc_dev(dum
), "stale req = %p\n",
1888 spin_unlock(&dum
->lock
);
1889 usb_gadget_giveback_request(&ep
->ep
, &req
->req
);
1890 spin_lock(&dum
->lock
);
1891 ep
->already_seen
= 0;
1895 /* gadget driver never sees set_address or operations
1896 * on standard feature flags. some hardware doesn't
1899 ep
->last_io
= jiffies
;
1900 ep
->setup_stage
= 0;
1903 value
= handle_control_request(dum_hcd
, urb
, &setup
,
1906 /* gadget driver handles all other requests. block
1907 * until setup() returns; no reentrancy issues etc.
1910 ++dum
->callback_usage
;
1911 spin_unlock(&dum
->lock
);
1912 value
= dum
->driver
->setup(&dum
->gadget
,
1914 spin_lock(&dum
->lock
);
1915 --dum
->callback_usage
;
1918 /* no delays (max 64KB data stage) */
1920 goto treat_control_like_bulk
;
1922 /* error, see below */
1926 if (value
!= -EOPNOTSUPP
)
1927 dev_dbg(udc_dev(dum
),
1931 urb
->actual_length
= 0;
1937 /* non-control requests */
1939 switch (usb_pipetype(urb
->pipe
)) {
1940 case PIPE_ISOCHRONOUS
:
1942 * We don't support isochronous. But if we did,
1943 * here are some of the issues we'd have to face:
1945 * Is it urb->interval since the last xfer?
1946 * Use urb->iso_frame_desc[i].
1947 * Complete whether or not ep has requests queued.
1948 * Report random errors, to debug drivers.
1950 limit
= max(limit
, periodic_bytes(dum
, ep
));
1951 status
= -EINVAL
; /* fail all xfers */
1954 case PIPE_INTERRUPT
:
1955 /* FIXME is it urb->interval since the last xfer?
1956 * this almost certainly polls too fast.
1958 limit
= max(limit
, periodic_bytes(dum
, ep
));
1962 treat_control_like_bulk
:
1963 ep
->last_io
= jiffies
;
1964 total
-= transfer(dum_hcd
, urb
, ep
, limit
, &status
);
1968 /* incomplete transfer? */
1969 if (status
== -EINPROGRESS
)
1973 list_del(&urbp
->urbp_list
);
1976 ep
->already_seen
= ep
->setup_stage
= 0;
1978 usb_hcd_unlink_urb_from_ep(dummy_hcd_to_hcd(dum_hcd
), urb
);
1979 spin_unlock(&dum
->lock
);
1980 usb_hcd_giveback_urb(dummy_hcd_to_hcd(dum_hcd
), urb
, status
);
1981 spin_lock(&dum
->lock
);
1986 if (list_empty(&dum_hcd
->urbp_list
)) {
1987 usb_put_dev(dum_hcd
->udev
);
1988 dum_hcd
->udev
= NULL
;
1989 } else if (dum_hcd
->rh_state
== DUMMY_RH_RUNNING
) {
1990 /* want a 1 msec delay here */
1991 mod_timer(&dum_hcd
->timer
, jiffies
+ msecs_to_jiffies(1));
1994 spin_unlock_irqrestore(&dum
->lock
, flags
);
1997 /*-------------------------------------------------------------------------*/
1999 #define PORT_C_MASK \
2000 ((USB_PORT_STAT_C_CONNECTION \
2001 | USB_PORT_STAT_C_ENABLE \
2002 | USB_PORT_STAT_C_SUSPEND \
2003 | USB_PORT_STAT_C_OVERCURRENT \
2004 | USB_PORT_STAT_C_RESET) << 16)
2006 static int dummy_hub_status(struct usb_hcd
*hcd
, char *buf
)
2008 struct dummy_hcd
*dum_hcd
;
2009 unsigned long flags
;
2012 dum_hcd
= hcd_to_dummy_hcd(hcd
);
2014 spin_lock_irqsave(&dum_hcd
->dum
->lock
, flags
);
2015 if (!HCD_HW_ACCESSIBLE(hcd
))
2018 if (dum_hcd
->resuming
&& time_after_eq(jiffies
, dum_hcd
->re_timeout
)) {
2019 dum_hcd
->port_status
|= (USB_PORT_STAT_C_SUSPEND
<< 16);
2020 dum_hcd
->port_status
&= ~USB_PORT_STAT_SUSPEND
;
2021 set_link_state(dum_hcd
);
2024 if ((dum_hcd
->port_status
& PORT_C_MASK
) != 0) {
2026 dev_dbg(dummy_dev(dum_hcd
), "port status 0x%08x has changes\n",
2027 dum_hcd
->port_status
);
2029 if (dum_hcd
->rh_state
== DUMMY_RH_SUSPENDED
)
2030 usb_hcd_resume_root_hub(hcd
);
2033 spin_unlock_irqrestore(&dum_hcd
->dum
->lock
, flags
);
2037 /* usb 3.0 root hub device descriptor */
2039 struct usb_bos_descriptor bos
;
2040 struct usb_ss_cap_descriptor ss_cap
;
2041 } __packed usb3_bos_desc
= {
2044 .bLength
= USB_DT_BOS_SIZE
,
2045 .bDescriptorType
= USB_DT_BOS
,
2046 .wTotalLength
= cpu_to_le16(sizeof(usb3_bos_desc
)),
2047 .bNumDeviceCaps
= 1,
2050 .bLength
= USB_DT_USB_SS_CAP_SIZE
,
2051 .bDescriptorType
= USB_DT_DEVICE_CAPABILITY
,
2052 .bDevCapabilityType
= USB_SS_CAP_TYPE
,
2053 .wSpeedSupported
= cpu_to_le16(USB_5GBPS_OPERATION
),
2054 .bFunctionalitySupport
= ilog2(USB_5GBPS_OPERATION
),
2059 ss_hub_descriptor(struct usb_hub_descriptor
*desc
)
2061 memset(desc
, 0, sizeof *desc
);
2062 desc
->bDescriptorType
= USB_DT_SS_HUB
;
2063 desc
->bDescLength
= 12;
2064 desc
->wHubCharacteristics
= cpu_to_le16(
2065 HUB_CHAR_INDV_PORT_LPSM
|
2066 HUB_CHAR_COMMON_OCPM
);
2067 desc
->bNbrPorts
= 1;
2068 desc
->u
.ss
.bHubHdrDecLat
= 0x04; /* Worst case: 0.4 micro sec*/
2069 desc
->u
.ss
.DeviceRemovable
= 0;
2072 static inline void hub_descriptor(struct usb_hub_descriptor
*desc
)
2074 memset(desc
, 0, sizeof *desc
);
2075 desc
->bDescriptorType
= USB_DT_HUB
;
2076 desc
->bDescLength
= 9;
2077 desc
->wHubCharacteristics
= cpu_to_le16(
2078 HUB_CHAR_INDV_PORT_LPSM
|
2079 HUB_CHAR_COMMON_OCPM
);
2080 desc
->bNbrPorts
= 1;
2081 desc
->u
.hs
.DeviceRemovable
[0] = 0;
2082 desc
->u
.hs
.DeviceRemovable
[1] = 0xff; /* PortPwrCtrlMask */
2085 static int dummy_hub_control(
2086 struct usb_hcd
*hcd
,
2093 struct dummy_hcd
*dum_hcd
;
2095 unsigned long flags
;
2097 if (!HCD_HW_ACCESSIBLE(hcd
))
2100 dum_hcd
= hcd_to_dummy_hcd(hcd
);
2102 spin_lock_irqsave(&dum_hcd
->dum
->lock
, flags
);
2104 case ClearHubFeature
:
2106 case ClearPortFeature
:
2108 case USB_PORT_FEAT_SUSPEND
:
2109 if (hcd
->speed
== HCD_USB3
) {
2110 dev_dbg(dummy_dev(dum_hcd
),
2111 "USB_PORT_FEAT_SUSPEND req not "
2112 "supported for USB 3.0 roothub\n");
2115 if (dum_hcd
->port_status
& USB_PORT_STAT_SUSPEND
) {
2116 /* 20msec resume signaling */
2117 dum_hcd
->resuming
= 1;
2118 dum_hcd
->re_timeout
= jiffies
+
2119 msecs_to_jiffies(20);
2122 case USB_PORT_FEAT_POWER
:
2123 dev_dbg(dummy_dev(dum_hcd
), "power-off\n");
2124 if (hcd
->speed
== HCD_USB3
)
2125 dum_hcd
->port_status
&= ~USB_SS_PORT_STAT_POWER
;
2127 dum_hcd
->port_status
&= ~USB_PORT_STAT_POWER
;
2128 set_link_state(dum_hcd
);
2131 dum_hcd
->port_status
&= ~(1 << wValue
);
2132 set_link_state(dum_hcd
);
2135 case GetHubDescriptor
:
2136 if (hcd
->speed
== HCD_USB3
&&
2137 (wLength
< USB_DT_SS_HUB_SIZE
||
2138 wValue
!= (USB_DT_SS_HUB
<< 8))) {
2139 dev_dbg(dummy_dev(dum_hcd
),
2140 "Wrong hub descriptor type for "
2141 "USB 3.0 roothub.\n");
2144 if (hcd
->speed
== HCD_USB3
)
2145 ss_hub_descriptor((struct usb_hub_descriptor
*) buf
);
2147 hub_descriptor((struct usb_hub_descriptor
*) buf
);
2150 case DeviceRequest
| USB_REQ_GET_DESCRIPTOR
:
2151 if (hcd
->speed
!= HCD_USB3
)
2154 if ((wValue
>> 8) != USB_DT_BOS
)
2157 memcpy(buf
, &usb3_bos_desc
, sizeof(usb3_bos_desc
));
2158 retval
= sizeof(usb3_bos_desc
);
2162 *(__le32
*) buf
= cpu_to_le32(0);
2168 /* whoever resets or resumes must GetPortStatus to
2171 if (dum_hcd
->resuming
&&
2172 time_after_eq(jiffies
, dum_hcd
->re_timeout
)) {
2173 dum_hcd
->port_status
|= (USB_PORT_STAT_C_SUSPEND
<< 16);
2174 dum_hcd
->port_status
&= ~USB_PORT_STAT_SUSPEND
;
2176 if ((dum_hcd
->port_status
& USB_PORT_STAT_RESET
) != 0 &&
2177 time_after_eq(jiffies
, dum_hcd
->re_timeout
)) {
2178 dum_hcd
->port_status
|= (USB_PORT_STAT_C_RESET
<< 16);
2179 dum_hcd
->port_status
&= ~USB_PORT_STAT_RESET
;
2180 if (dum_hcd
->dum
->pullup
) {
2181 dum_hcd
->port_status
|= USB_PORT_STAT_ENABLE
;
2183 if (hcd
->speed
< HCD_USB3
) {
2184 switch (dum_hcd
->dum
->gadget
.speed
) {
2185 case USB_SPEED_HIGH
:
2186 dum_hcd
->port_status
|=
2187 USB_PORT_STAT_HIGH_SPEED
;
2190 dum_hcd
->dum
->gadget
.ep0
->
2192 dum_hcd
->port_status
|=
2193 USB_PORT_STAT_LOW_SPEED
;
2196 dum_hcd
->dum
->gadget
.speed
=
2203 set_link_state(dum_hcd
);
2204 ((__le16
*) buf
)[0] = cpu_to_le16(dum_hcd
->port_status
);
2205 ((__le16
*) buf
)[1] = cpu_to_le16(dum_hcd
->port_status
>> 16);
2210 case SetPortFeature
:
2212 case USB_PORT_FEAT_LINK_STATE
:
2213 if (hcd
->speed
!= HCD_USB3
) {
2214 dev_dbg(dummy_dev(dum_hcd
),
2215 "USB_PORT_FEAT_LINK_STATE req not "
2216 "supported for USB 2.0 roothub\n");
2220 * Since this is dummy we don't have an actual link so
2221 * there is nothing to do for the SET_LINK_STATE cmd
2224 case USB_PORT_FEAT_U1_TIMEOUT
:
2225 case USB_PORT_FEAT_U2_TIMEOUT
:
2226 /* TODO: add suspend/resume support! */
2227 if (hcd
->speed
!= HCD_USB3
) {
2228 dev_dbg(dummy_dev(dum_hcd
),
2229 "USB_PORT_FEAT_U1/2_TIMEOUT req not "
2230 "supported for USB 2.0 roothub\n");
2234 case USB_PORT_FEAT_SUSPEND
:
2235 /* Applicable only for USB2.0 hub */
2236 if (hcd
->speed
== HCD_USB3
) {
2237 dev_dbg(dummy_dev(dum_hcd
),
2238 "USB_PORT_FEAT_SUSPEND req not "
2239 "supported for USB 3.0 roothub\n");
2242 if (dum_hcd
->active
) {
2243 dum_hcd
->port_status
|= USB_PORT_STAT_SUSPEND
;
2245 /* HNP would happen here; for now we
2246 * assume b_bus_req is always true.
2248 set_link_state(dum_hcd
);
2249 if (((1 << USB_DEVICE_B_HNP_ENABLE
)
2250 & dum_hcd
->dum
->devstatus
) != 0)
2251 dev_dbg(dummy_dev(dum_hcd
),
2255 case USB_PORT_FEAT_POWER
:
2256 if (hcd
->speed
== HCD_USB3
)
2257 dum_hcd
->port_status
|= USB_SS_PORT_STAT_POWER
;
2259 dum_hcd
->port_status
|= USB_PORT_STAT_POWER
;
2260 set_link_state(dum_hcd
);
2262 case USB_PORT_FEAT_BH_PORT_RESET
:
2263 /* Applicable only for USB3.0 hub */
2264 if (hcd
->speed
!= HCD_USB3
) {
2265 dev_dbg(dummy_dev(dum_hcd
),
2266 "USB_PORT_FEAT_BH_PORT_RESET req not "
2267 "supported for USB 2.0 roothub\n");
2271 case USB_PORT_FEAT_RESET
:
2272 /* if it's already enabled, disable */
2273 if (hcd
->speed
== HCD_USB3
) {
2274 dum_hcd
->port_status
= 0;
2275 dum_hcd
->port_status
=
2276 (USB_SS_PORT_STAT_POWER
|
2277 USB_PORT_STAT_CONNECTION
|
2278 USB_PORT_STAT_RESET
);
2280 dum_hcd
->port_status
&= ~(USB_PORT_STAT_ENABLE
2281 | USB_PORT_STAT_LOW_SPEED
2282 | USB_PORT_STAT_HIGH_SPEED
);
2284 * We want to reset device status. All but the
2285 * Self powered feature
2287 dum_hcd
->dum
->devstatus
&=
2288 (1 << USB_DEVICE_SELF_POWERED
);
2290 * FIXME USB3.0: what is the correct reset signaling
2291 * interval? Is it still 50msec as for HS?
2293 dum_hcd
->re_timeout
= jiffies
+ msecs_to_jiffies(50);
2296 if (hcd
->speed
== HCD_USB3
) {
2297 if ((dum_hcd
->port_status
&
2298 USB_SS_PORT_STAT_POWER
) != 0) {
2299 dum_hcd
->port_status
|= (1 << wValue
);
2302 if ((dum_hcd
->port_status
&
2303 USB_PORT_STAT_POWER
) != 0) {
2304 dum_hcd
->port_status
|= (1 << wValue
);
2306 set_link_state(dum_hcd
);
2309 case GetPortErrorCount
:
2310 if (hcd
->speed
!= HCD_USB3
) {
2311 dev_dbg(dummy_dev(dum_hcd
),
2312 "GetPortErrorCount req not "
2313 "supported for USB 2.0 roothub\n");
2316 /* We'll always return 0 since this is a dummy hub */
2317 *(__le32
*) buf
= cpu_to_le32(0);
2320 if (hcd
->speed
!= HCD_USB3
) {
2321 dev_dbg(dummy_dev(dum_hcd
),
2322 "SetHubDepth req not supported for "
2323 "USB 2.0 roothub\n");
2328 dev_dbg(dummy_dev(dum_hcd
),
2329 "hub control req%04x v%04x i%04x l%d\n",
2330 typeReq
, wValue
, wIndex
, wLength
);
2332 /* "protocol stall" on error */
2335 spin_unlock_irqrestore(&dum_hcd
->dum
->lock
, flags
);
2337 if ((dum_hcd
->port_status
& PORT_C_MASK
) != 0)
2338 usb_hcd_poll_rh_status(hcd
);
2342 static int dummy_bus_suspend(struct usb_hcd
*hcd
)
2344 struct dummy_hcd
*dum_hcd
= hcd_to_dummy_hcd(hcd
);
2346 dev_dbg(&hcd
->self
.root_hub
->dev
, "%s\n", __func__
);
2348 spin_lock_irq(&dum_hcd
->dum
->lock
);
2349 dum_hcd
->rh_state
= DUMMY_RH_SUSPENDED
;
2350 set_link_state(dum_hcd
);
2351 hcd
->state
= HC_STATE_SUSPENDED
;
2352 spin_unlock_irq(&dum_hcd
->dum
->lock
);
2356 static int dummy_bus_resume(struct usb_hcd
*hcd
)
2358 struct dummy_hcd
*dum_hcd
= hcd_to_dummy_hcd(hcd
);
2361 dev_dbg(&hcd
->self
.root_hub
->dev
, "%s\n", __func__
);
2363 spin_lock_irq(&dum_hcd
->dum
->lock
);
2364 if (!HCD_HW_ACCESSIBLE(hcd
)) {
2367 dum_hcd
->rh_state
= DUMMY_RH_RUNNING
;
2368 set_link_state(dum_hcd
);
2369 if (!list_empty(&dum_hcd
->urbp_list
))
2370 mod_timer(&dum_hcd
->timer
, jiffies
);
2371 hcd
->state
= HC_STATE_RUNNING
;
2373 spin_unlock_irq(&dum_hcd
->dum
->lock
);
2377 /*-------------------------------------------------------------------------*/
2379 static inline ssize_t
show_urb(char *buf
, size_t size
, struct urb
*urb
)
2381 int ep
= usb_pipeendpoint(urb
->pipe
);
2383 return snprintf(buf
, size
,
2384 "urb/%p %s ep%d%s%s len %d/%d\n",
2387 switch (urb
->dev
->speed
) {
2391 case USB_SPEED_FULL
:
2394 case USB_SPEED_HIGH
:
2397 case USB_SPEED_SUPER
:
2404 ep
, ep
? (usb_pipein(urb
->pipe
) ? "in" : "out") : "",
2406 switch (usb_pipetype(urb
->pipe
)) { \
2407 case PIPE_CONTROL
: \
2413 case PIPE_INTERRUPT
: \
2420 urb
->actual_length
, urb
->transfer_buffer_length
);
2423 static ssize_t
urbs_show(struct device
*dev
, struct device_attribute
*attr
,
2426 struct usb_hcd
*hcd
= dev_get_drvdata(dev
);
2427 struct dummy_hcd
*dum_hcd
= hcd_to_dummy_hcd(hcd
);
2430 unsigned long flags
;
2432 spin_lock_irqsave(&dum_hcd
->dum
->lock
, flags
);
2433 list_for_each_entry(urbp
, &dum_hcd
->urbp_list
, urbp_list
) {
2436 temp
= show_urb(buf
, PAGE_SIZE
- size
, urbp
->urb
);
2440 spin_unlock_irqrestore(&dum_hcd
->dum
->lock
, flags
);
2444 static DEVICE_ATTR_RO(urbs
);
2446 static int dummy_start_ss(struct dummy_hcd
*dum_hcd
)
2448 setup_timer(&dum_hcd
->timer
, dummy_timer
, (unsigned long)dum_hcd
);
2449 dum_hcd
->rh_state
= DUMMY_RH_RUNNING
;
2450 dum_hcd
->stream_en_ep
= 0;
2451 INIT_LIST_HEAD(&dum_hcd
->urbp_list
);
2452 dummy_hcd_to_hcd(dum_hcd
)->power_budget
= POWER_BUDGET
;
2453 dummy_hcd_to_hcd(dum_hcd
)->state
= HC_STATE_RUNNING
;
2454 dummy_hcd_to_hcd(dum_hcd
)->uses_new_polling
= 1;
2455 #ifdef CONFIG_USB_OTG
2456 dummy_hcd_to_hcd(dum_hcd
)->self
.otg_port
= 1;
2460 /* FIXME 'urbs' should be a per-device thing, maybe in usbcore */
2461 return device_create_file(dummy_dev(dum_hcd
), &dev_attr_urbs
);
2464 static int dummy_start(struct usb_hcd
*hcd
)
2466 struct dummy_hcd
*dum_hcd
= hcd_to_dummy_hcd(hcd
);
2469 * MASTER side init ... we emulate a root hub that'll only ever
2470 * talk to one device (the slave side). Also appears in sysfs,
2471 * just like more familiar pci-based HCDs.
2473 if (!usb_hcd_is_primary_hcd(hcd
))
2474 return dummy_start_ss(dum_hcd
);
2476 spin_lock_init(&dum_hcd
->dum
->lock
);
2477 setup_timer(&dum_hcd
->timer
, dummy_timer
, (unsigned long)dum_hcd
);
2478 dum_hcd
->rh_state
= DUMMY_RH_RUNNING
;
2480 INIT_LIST_HEAD(&dum_hcd
->urbp_list
);
2482 hcd
->power_budget
= POWER_BUDGET
;
2483 hcd
->state
= HC_STATE_RUNNING
;
2484 hcd
->uses_new_polling
= 1;
2486 #ifdef CONFIG_USB_OTG
2487 hcd
->self
.otg_port
= 1;
2490 /* FIXME 'urbs' should be a per-device thing, maybe in usbcore */
2491 return device_create_file(dummy_dev(dum_hcd
), &dev_attr_urbs
);
2494 static void dummy_stop(struct usb_hcd
*hcd
)
2496 device_remove_file(dummy_dev(hcd_to_dummy_hcd(hcd
)), &dev_attr_urbs
);
2497 dev_info(dummy_dev(hcd_to_dummy_hcd(hcd
)), "stopped\n");
2500 /*-------------------------------------------------------------------------*/
2502 static int dummy_h_get_frame(struct usb_hcd
*hcd
)
2504 return dummy_g_get_frame(NULL
);
2507 static int dummy_setup(struct usb_hcd
*hcd
)
2511 dum
= *((void **)dev_get_platdata(hcd
->self
.controller
));
2512 hcd
->self
.sg_tablesize
= ~0;
2513 if (usb_hcd_is_primary_hcd(hcd
)) {
2514 dum
->hs_hcd
= hcd_to_dummy_hcd(hcd
);
2515 dum
->hs_hcd
->dum
= dum
;
2517 * Mark the first roothub as being USB 2.0.
2518 * The USB 3.0 roothub will be registered later by
2521 hcd
->speed
= HCD_USB2
;
2522 hcd
->self
.root_hub
->speed
= USB_SPEED_HIGH
;
2524 dum
->ss_hcd
= hcd_to_dummy_hcd(hcd
);
2525 dum
->ss_hcd
->dum
= dum
;
2526 hcd
->speed
= HCD_USB3
;
2527 hcd
->self
.root_hub
->speed
= USB_SPEED_SUPER
;
2532 /* Change a group of bulk endpoints to support multiple stream IDs */
2533 static int dummy_alloc_streams(struct usb_hcd
*hcd
, struct usb_device
*udev
,
2534 struct usb_host_endpoint
**eps
, unsigned int num_eps
,
2535 unsigned int num_streams
, gfp_t mem_flags
)
2537 struct dummy_hcd
*dum_hcd
= hcd_to_dummy_hcd(hcd
);
2538 unsigned long flags
;
2540 int ret_streams
= num_streams
;
2547 spin_lock_irqsave(&dum_hcd
->dum
->lock
, flags
);
2548 for (i
= 0; i
< num_eps
; i
++) {
2549 index
= dummy_get_ep_idx(&eps
[i
]->desc
);
2550 if ((1 << index
) & dum_hcd
->stream_en_ep
) {
2551 ret_streams
= -EINVAL
;
2554 max_stream
= usb_ss_max_streams(&eps
[i
]->ss_ep_comp
);
2556 ret_streams
= -EINVAL
;
2559 if (max_stream
< ret_streams
) {
2560 dev_dbg(dummy_dev(dum_hcd
), "Ep 0x%x only supports %u "
2562 eps
[i
]->desc
.bEndpointAddress
,
2564 ret_streams
= max_stream
;
2568 for (i
= 0; i
< num_eps
; i
++) {
2569 index
= dummy_get_ep_idx(&eps
[i
]->desc
);
2570 dum_hcd
->stream_en_ep
|= 1 << index
;
2571 set_max_streams_for_pipe(dum_hcd
,
2572 usb_endpoint_num(&eps
[i
]->desc
), ret_streams
);
2575 spin_unlock_irqrestore(&dum_hcd
->dum
->lock
, flags
);
2579 /* Reverts a group of bulk endpoints back to not using stream IDs. */
2580 static int dummy_free_streams(struct usb_hcd
*hcd
, struct usb_device
*udev
,
2581 struct usb_host_endpoint
**eps
, unsigned int num_eps
,
2584 struct dummy_hcd
*dum_hcd
= hcd_to_dummy_hcd(hcd
);
2585 unsigned long flags
;
2590 spin_lock_irqsave(&dum_hcd
->dum
->lock
, flags
);
2591 for (i
= 0; i
< num_eps
; i
++) {
2592 index
= dummy_get_ep_idx(&eps
[i
]->desc
);
2593 if (!((1 << index
) & dum_hcd
->stream_en_ep
)) {
2599 for (i
= 0; i
< num_eps
; i
++) {
2600 index
= dummy_get_ep_idx(&eps
[i
]->desc
);
2601 dum_hcd
->stream_en_ep
&= ~(1 << index
);
2602 set_max_streams_for_pipe(dum_hcd
,
2603 usb_endpoint_num(&eps
[i
]->desc
), 0);
2607 spin_unlock_irqrestore(&dum_hcd
->dum
->lock
, flags
);
2611 static struct hc_driver dummy_hcd
= {
2612 .description
= (char *) driver_name
,
2613 .product_desc
= "Dummy host controller",
2614 .hcd_priv_size
= sizeof(struct dummy_hcd
),
2616 .reset
= dummy_setup
,
2617 .start
= dummy_start
,
2620 .urb_enqueue
= dummy_urb_enqueue
,
2621 .urb_dequeue
= dummy_urb_dequeue
,
2623 .get_frame_number
= dummy_h_get_frame
,
2625 .hub_status_data
= dummy_hub_status
,
2626 .hub_control
= dummy_hub_control
,
2627 .bus_suspend
= dummy_bus_suspend
,
2628 .bus_resume
= dummy_bus_resume
,
2630 .alloc_streams
= dummy_alloc_streams
,
2631 .free_streams
= dummy_free_streams
,
2634 static int dummy_hcd_probe(struct platform_device
*pdev
)
2637 struct usb_hcd
*hs_hcd
;
2638 struct usb_hcd
*ss_hcd
;
2641 dev_info(&pdev
->dev
, "%s, driver " DRIVER_VERSION
"\n", driver_desc
);
2642 dum
= *((void **)dev_get_platdata(&pdev
->dev
));
2644 if (mod_data
.is_super_speed
)
2645 dummy_hcd
.flags
= HCD_USB3
| HCD_SHARED
;
2646 else if (mod_data
.is_high_speed
)
2647 dummy_hcd
.flags
= HCD_USB2
;
2649 dummy_hcd
.flags
= HCD_USB11
;
2650 hs_hcd
= usb_create_hcd(&dummy_hcd
, &pdev
->dev
, dev_name(&pdev
->dev
));
2655 retval
= usb_add_hcd(hs_hcd
, 0, 0);
2659 if (mod_data
.is_super_speed
) {
2660 ss_hcd
= usb_create_shared_hcd(&dummy_hcd
, &pdev
->dev
,
2661 dev_name(&pdev
->dev
), hs_hcd
);
2664 goto dealloc_usb2_hcd
;
2667 retval
= usb_add_hcd(ss_hcd
, 0, 0);
2674 usb_put_hcd(ss_hcd
);
2676 usb_remove_hcd(hs_hcd
);
2678 usb_put_hcd(hs_hcd
);
2679 dum
->hs_hcd
= dum
->ss_hcd
= NULL
;
2683 static int dummy_hcd_remove(struct platform_device
*pdev
)
2687 dum
= hcd_to_dummy_hcd(platform_get_drvdata(pdev
))->dum
;
2690 usb_remove_hcd(dummy_hcd_to_hcd(dum
->ss_hcd
));
2691 usb_put_hcd(dummy_hcd_to_hcd(dum
->ss_hcd
));
2694 usb_remove_hcd(dummy_hcd_to_hcd(dum
->hs_hcd
));
2695 usb_put_hcd(dummy_hcd_to_hcd(dum
->hs_hcd
));
2703 static int dummy_hcd_suspend(struct platform_device
*pdev
, pm_message_t state
)
2705 struct usb_hcd
*hcd
;
2706 struct dummy_hcd
*dum_hcd
;
2709 dev_dbg(&pdev
->dev
, "%s\n", __func__
);
2711 hcd
= platform_get_drvdata(pdev
);
2712 dum_hcd
= hcd_to_dummy_hcd(hcd
);
2713 if (dum_hcd
->rh_state
== DUMMY_RH_RUNNING
) {
2714 dev_warn(&pdev
->dev
, "Root hub isn't suspended!\n");
2717 clear_bit(HCD_FLAG_HW_ACCESSIBLE
, &hcd
->flags
);
2721 static int dummy_hcd_resume(struct platform_device
*pdev
)
2723 struct usb_hcd
*hcd
;
2725 dev_dbg(&pdev
->dev
, "%s\n", __func__
);
2727 hcd
= platform_get_drvdata(pdev
);
2728 set_bit(HCD_FLAG_HW_ACCESSIBLE
, &hcd
->flags
);
2729 usb_hcd_poll_rh_status(hcd
);
2733 static struct platform_driver dummy_hcd_driver
= {
2734 .probe
= dummy_hcd_probe
,
2735 .remove
= dummy_hcd_remove
,
2736 .suspend
= dummy_hcd_suspend
,
2737 .resume
= dummy_hcd_resume
,
2739 .name
= (char *) driver_name
,
2743 /*-------------------------------------------------------------------------*/
2744 #define MAX_NUM_UDC 2
2745 static struct platform_device
*the_udc_pdev
[MAX_NUM_UDC
];
2746 static struct platform_device
*the_hcd_pdev
[MAX_NUM_UDC
];
2748 static int __init
init(void)
2750 int retval
= -ENOMEM
;
2752 struct dummy
*dum
[MAX_NUM_UDC
];
2757 if (!mod_data
.is_high_speed
&& mod_data
.is_super_speed
)
2760 if (mod_data
.num
< 1 || mod_data
.num
> MAX_NUM_UDC
) {
2761 pr_err("Number of emulated UDC must be in range of 1...%d\n",
2766 for (i
= 0; i
< mod_data
.num
; i
++) {
2767 the_hcd_pdev
[i
] = platform_device_alloc(driver_name
, i
);
2768 if (!the_hcd_pdev
[i
]) {
2771 platform_device_put(the_hcd_pdev
[i
--]);
2775 for (i
= 0; i
< mod_data
.num
; i
++) {
2776 the_udc_pdev
[i
] = platform_device_alloc(gadget_name
, i
);
2777 if (!the_udc_pdev
[i
]) {
2780 platform_device_put(the_udc_pdev
[i
--]);
2784 for (i
= 0; i
< mod_data
.num
; i
++) {
2785 dum
[i
] = kzalloc(sizeof(struct dummy
), GFP_KERNEL
);
2790 retval
= platform_device_add_data(the_hcd_pdev
[i
], &dum
[i
],
2794 retval
= platform_device_add_data(the_udc_pdev
[i
], &dum
[i
],
2800 retval
= platform_driver_register(&dummy_hcd_driver
);
2803 retval
= platform_driver_register(&dummy_udc_driver
);
2805 goto err_register_udc_driver
;
2807 for (i
= 0; i
< mod_data
.num
; i
++) {
2808 retval
= platform_device_add(the_hcd_pdev
[i
]);
2812 platform_device_del(the_hcd_pdev
[i
--]);
2816 for (i
= 0; i
< mod_data
.num
; i
++) {
2817 if (!dum
[i
]->hs_hcd
||
2818 (!dum
[i
]->ss_hcd
&& mod_data
.is_super_speed
)) {
2820 * The hcd was added successfully but its probe
2821 * function failed for some reason.
2828 for (i
= 0; i
< mod_data
.num
; i
++) {
2829 retval
= platform_device_add(the_udc_pdev
[i
]);
2833 platform_device_del(the_udc_pdev
[i
--]);
2838 for (i
= 0; i
< mod_data
.num
; i
++) {
2839 if (!platform_get_drvdata(the_udc_pdev
[i
])) {
2841 * The udc was added successfully but its probe
2842 * function failed for some reason.
2851 for (i
= 0; i
< mod_data
.num
; i
++)
2852 platform_device_del(the_udc_pdev
[i
]);
2854 for (i
= 0; i
< mod_data
.num
; i
++)
2855 platform_device_del(the_hcd_pdev
[i
]);
2857 platform_driver_unregister(&dummy_udc_driver
);
2858 err_register_udc_driver
:
2859 platform_driver_unregister(&dummy_hcd_driver
);
2861 for (i
= 0; i
< mod_data
.num
; i
++)
2863 for (i
= 0; i
< mod_data
.num
; i
++)
2864 platform_device_put(the_udc_pdev
[i
]);
2866 for (i
= 0; i
< mod_data
.num
; i
++)
2867 platform_device_put(the_hcd_pdev
[i
]);
2872 static void __exit
cleanup(void)
2876 for (i
= 0; i
< mod_data
.num
; i
++) {
2879 dum
= *((void **)dev_get_platdata(&the_udc_pdev
[i
]->dev
));
2881 platform_device_unregister(the_udc_pdev
[i
]);
2882 platform_device_unregister(the_hcd_pdev
[i
]);
2885 platform_driver_unregister(&dummy_udc_driver
);
2886 platform_driver_unregister(&dummy_hcd_driver
);
2888 module_exit(cleanup
);