2
* dummy_hcd.c -- Dummy/Loopback USB host and device emulator driver.
4
* Maintainer: Alan Stern <stern@rowland.harvard.edu>
6
* Copyright (C) 2003 David Brownell
7
* Copyright (C) 2003-2005 Alan Stern
9
* This program is free software; you can redistribute it and/or modify
10
* it under the terms of the GNU General Public License as published by
11
* the Free Software Foundation; either version 2 of the License, or
12
* (at your option) any later version.
17
* This exposes a device side "USB gadget" API, driven by requests to a
18
* Linux-USB host controller driver. USB traffic is simulated; there's
19
* no need for USB hardware. Use this with two other drivers:
21
* - Gadget driver, responding to requests (slave);
22
* - Host-side device driver, as already familiar in Linux.
24
* Having this all in one kernel can help some stages of development,
25
* bypassing some hardware (and driver) issues. UML could help too.
28
#include <linux/module.h>
29
#include <linux/kernel.h>
30
#include <linux/delay.h>
31
#include <linux/ioport.h>
32
#include <linux/slab.h>
33
#include <linux/errno.h>
34
#include <linux/init.h>
35
#include <linux/timer.h>
36
#include <linux/list.h>
37
#include <linux/interrupt.h>
38
#include <linux/platform_device.h>
39
#include <linux/usb.h>
40
#include <linux/usb/gadget.h>
41
#include <linux/usb/hcd.h>
43
#include <asm/byteorder.h>
46
#include <asm/system.h>
47
#include <asm/unaligned.h>
50
#define DRIVER_DESC "USB Host+Gadget Emulator"
51
#define DRIVER_VERSION "02 May 2005"
53
#define POWER_BUDGET 500 /* in mA; use 8 for low-power port testing */
55
static const char driver_name [] = "dummy_hcd";
56
static const char driver_desc [] = "USB Host+Gadget Emulator";
58
static const char gadget_name [] = "dummy_udc";
60
MODULE_DESCRIPTION (DRIVER_DESC);
61
MODULE_AUTHOR ("David Brownell");
62
MODULE_LICENSE ("GPL");
64
struct dummy_hcd_module_parameters {
69
static struct dummy_hcd_module_parameters mod_data = {
70
.is_super_speed = false,
71
.is_high_speed = true,
73
module_param_named(is_super_speed, mod_data.is_super_speed, bool, S_IRUGO);
74
MODULE_PARM_DESC(is_super_speed, "true to simulate SuperSpeed connection");
75
module_param_named(is_high_speed, mod_data.is_high_speed, bool, S_IRUGO);
76
MODULE_PARM_DESC(is_high_speed, "true to simulate HighSpeed connection");
77
/*-------------------------------------------------------------------------*/
79
/* gadget side driver data structres */
81
struct list_head queue;
82
unsigned long last_io; /* jiffies timestamp */
83
struct usb_gadget *gadget;
84
const struct usb_endpoint_descriptor *desc;
88
unsigned already_seen : 1;
89
unsigned setup_stage : 1;
92
struct dummy_request {
93
struct list_head queue; /* ep's requests */
94
struct usb_request req;
97
static inline struct dummy_ep *usb_ep_to_dummy_ep (struct usb_ep *_ep)
99
return container_of (_ep, struct dummy_ep, ep);
102
static inline struct dummy_request *usb_request_to_dummy_request
103
(struct usb_request *_req)
105
return container_of (_req, struct dummy_request, req);
108
/*-------------------------------------------------------------------------*/
111
* Every device has ep0 for control requests, plus up to 30 more endpoints,
112
* in one of two types:
114
* - Configurable: direction (in/out), type (bulk, iso, etc), and endpoint
115
* number can be changed. Names like "ep-a" are used for this type.
117
* - Fixed Function: in other cases. some characteristics may be mutable;
118
* that'd be hardware-specific. Names like "ep12out-bulk" are used.
120
* Gadget drivers are responsible for not setting up conflicting endpoint
121
* configurations, illegal or unsupported packet lengths, and so on.
124
static const char ep0name [] = "ep0";
126
static const char *const ep_name [] = {
127
ep0name, /* everyone has ep0 */
129
/* act like a net2280: high speed, six configurable endpoints */
130
"ep-a", "ep-b", "ep-c", "ep-d", "ep-e", "ep-f",
132
/* or like pxa250: fifteen fixed function endpoints */
133
"ep1in-bulk", "ep2out-bulk", "ep3in-iso", "ep4out-iso", "ep5in-int",
134
"ep6in-bulk", "ep7out-bulk", "ep8in-iso", "ep9out-iso", "ep10in-int",
135
"ep11in-bulk", "ep12out-bulk", "ep13in-iso", "ep14out-iso",
138
/* or like sa1100: two fixed function endpoints */
139
"ep1out-bulk", "ep2in-bulk",
141
#define DUMMY_ENDPOINTS ARRAY_SIZE(ep_name)
143
/*-------------------------------------------------------------------------*/
149
struct list_head urbp_list;
153
enum dummy_rh_state {
161
enum dummy_rh_state rh_state;
162
struct timer_list timer;
165
unsigned long re_timeout;
167
struct usb_device *udev;
168
struct list_head urbp_list;
171
unsigned old_active:1;
179
* SLAVE/GADGET side support
181
struct dummy_ep ep [DUMMY_ENDPOINTS];
183
struct usb_gadget gadget;
184
struct usb_gadget_driver *driver;
185
struct dummy_request fifo_req;
186
u8 fifo_buf [FIFO_SIZE];
188
unsigned udc_suspended:1;
192
* MASTER/HOST side support
194
struct dummy_hcd *hs_hcd;
195
struct dummy_hcd *ss_hcd;
198
static inline struct dummy_hcd *hcd_to_dummy_hcd(struct usb_hcd *hcd)
200
return (struct dummy_hcd *) (hcd->hcd_priv);
203
static inline struct usb_hcd *dummy_hcd_to_hcd(struct dummy_hcd *dum)
205
return container_of((void *) dum, struct usb_hcd, hcd_priv);
208
static inline struct device *dummy_dev(struct dummy_hcd *dum)
210
return dummy_hcd_to_hcd(dum)->self.controller;
213
static inline struct device *udc_dev (struct dummy *dum)
215
return dum->gadget.dev.parent;
218
static inline struct dummy *ep_to_dummy (struct dummy_ep *ep)
220
return container_of (ep->gadget, struct dummy, gadget);
223
static inline struct dummy_hcd *gadget_to_dummy_hcd(struct usb_gadget *gadget)
225
struct dummy *dum = container_of(gadget, struct dummy, gadget);
226
if (dum->gadget.speed == USB_SPEED_SUPER)
232
static inline struct dummy *gadget_dev_to_dummy (struct device *dev)
234
return container_of (dev, struct dummy, gadget.dev);
237
static struct dummy the_controller;
239
/*-------------------------------------------------------------------------*/
241
/* SLAVE/GADGET SIDE UTILITY ROUTINES */
243
/* called with spinlock held */
244
static void nuke (struct dummy *dum, struct dummy_ep *ep)
246
while (!list_empty (&ep->queue)) {
247
struct dummy_request *req;
249
req = list_entry (ep->queue.next, struct dummy_request, queue);
250
list_del_init (&req->queue);
251
req->req.status = -ESHUTDOWN;
253
spin_unlock (&dum->lock);
254
req->req.complete (&ep->ep, &req->req);
255
spin_lock (&dum->lock);
259
/* caller must hold lock */
261
stop_activity (struct dummy *dum)
265
/* prevent any more requests */
268
/* The timer is left running so that outstanding URBs can fail */
270
/* nuke any pending requests first, so driver i/o is quiesced */
271
list_for_each_entry (ep, &dum->gadget.ep_list, ep.ep_list)
274
/* driver now does any non-usb quiescing necessary */
278
* set_link_state_by_speed() - Sets the current state of the link according to
280
* @dum_hcd: pointer to the dummy_hcd structure to update the link state for
282
* This function updates the port_status according to the link state and the
285
static void set_link_state_by_speed(struct dummy_hcd *dum_hcd)
287
struct dummy *dum = dum_hcd->dum;
289
if (dummy_hcd_to_hcd(dum_hcd)->speed == HCD_USB3) {
290
if ((dum_hcd->port_status & USB_SS_PORT_STAT_POWER) == 0) {
291
dum_hcd->port_status = 0;
292
} else if (!dum->pullup || dum->udc_suspended) {
293
/* UDC suspend must cause a disconnect */
294
dum_hcd->port_status &= ~(USB_PORT_STAT_CONNECTION |
295
USB_PORT_STAT_ENABLE);
296
if ((dum_hcd->old_status &
297
USB_PORT_STAT_CONNECTION) != 0)
298
dum_hcd->port_status |=
299
(USB_PORT_STAT_C_CONNECTION << 16);
301
/* device is connected and not suspended */
302
dum_hcd->port_status |= (USB_PORT_STAT_CONNECTION |
303
USB_PORT_STAT_SPEED_5GBPS) ;
304
if ((dum_hcd->old_status &
305
USB_PORT_STAT_CONNECTION) == 0)
306
dum_hcd->port_status |=
307
(USB_PORT_STAT_C_CONNECTION << 16);
308
if ((dum_hcd->port_status &
309
USB_PORT_STAT_ENABLE) == 1 &&
310
(dum_hcd->port_status &
311
USB_SS_PORT_LS_U0) == 1 &&
312
dum_hcd->rh_state != DUMMY_RH_SUSPENDED)
316
if ((dum_hcd->port_status & USB_PORT_STAT_POWER) == 0) {
317
dum_hcd->port_status = 0;
318
} else if (!dum->pullup || dum->udc_suspended) {
319
/* UDC suspend must cause a disconnect */
320
dum_hcd->port_status &= ~(USB_PORT_STAT_CONNECTION |
321
USB_PORT_STAT_ENABLE |
322
USB_PORT_STAT_LOW_SPEED |
323
USB_PORT_STAT_HIGH_SPEED |
324
USB_PORT_STAT_SUSPEND);
325
if ((dum_hcd->old_status &
326
USB_PORT_STAT_CONNECTION) != 0)
327
dum_hcd->port_status |=
328
(USB_PORT_STAT_C_CONNECTION << 16);
330
dum_hcd->port_status |= USB_PORT_STAT_CONNECTION;
331
if ((dum_hcd->old_status &
332
USB_PORT_STAT_CONNECTION) == 0)
333
dum_hcd->port_status |=
334
(USB_PORT_STAT_C_CONNECTION << 16);
335
if ((dum_hcd->port_status & USB_PORT_STAT_ENABLE) == 0)
336
dum_hcd->port_status &= ~USB_PORT_STAT_SUSPEND;
337
else if ((dum_hcd->port_status &
338
USB_PORT_STAT_SUSPEND) == 0 &&
339
dum_hcd->rh_state != DUMMY_RH_SUSPENDED)
345
/* caller must hold lock */
346
static void set_link_state(struct dummy_hcd *dum_hcd)
348
struct dummy *dum = dum_hcd->dum;
352
if ((dummy_hcd_to_hcd(dum_hcd)->speed == HCD_USB3 &&
353
dum->gadget.speed != USB_SPEED_SUPER) ||
354
(dummy_hcd_to_hcd(dum_hcd)->speed != HCD_USB3 &&
355
dum->gadget.speed == USB_SPEED_SUPER))
358
set_link_state_by_speed(dum_hcd);
360
if ((dum_hcd->port_status & USB_PORT_STAT_ENABLE) == 0 ||
362
dum_hcd->resuming = 0;
364
/* if !connected or reset */
365
if ((dum_hcd->port_status & USB_PORT_STAT_CONNECTION) == 0 ||
366
(dum_hcd->port_status & USB_PORT_STAT_RESET) != 0) {
368
* We're connected and not reset (reset occurred now),
369
* and driver attached - disconnect!
371
if ((dum_hcd->old_status & USB_PORT_STAT_CONNECTION) != 0 &&
372
(dum_hcd->old_status & USB_PORT_STAT_RESET) == 0 &&
375
spin_unlock(&dum->lock);
376
dum->driver->disconnect(&dum->gadget);
377
spin_lock(&dum->lock);
379
} else if (dum_hcd->active != dum_hcd->old_active) {
380
if (dum_hcd->old_active && dum->driver->suspend) {
381
spin_unlock(&dum->lock);
382
dum->driver->suspend(&dum->gadget);
383
spin_lock(&dum->lock);
384
} else if (!dum_hcd->old_active && dum->driver->resume) {
385
spin_unlock(&dum->lock);
386
dum->driver->resume(&dum->gadget);
387
spin_lock(&dum->lock);
391
dum_hcd->old_status = dum_hcd->port_status;
392
dum_hcd->old_active = dum_hcd->active;
395
/*-------------------------------------------------------------------------*/
397
/* SLAVE/GADGET SIDE DRIVER
399
* This only tracks gadget state. All the work is done when the host
400
* side tries some (emulated) i/o operation. Real device controller
401
* drivers would do real i/o using dma, fifos, irqs, timers, etc.
404
#define is_enabled(dum) \
405
(dum->port_status & USB_PORT_STAT_ENABLE)
408
dummy_enable (struct usb_ep *_ep, const struct usb_endpoint_descriptor *desc)
411
struct dummy_hcd *dum_hcd;
416
ep = usb_ep_to_dummy_ep (_ep);
417
if (!_ep || !desc || ep->desc || _ep->name == ep0name
418
|| desc->bDescriptorType != USB_DT_ENDPOINT)
420
dum = ep_to_dummy (ep);
424
dum_hcd = gadget_to_dummy_hcd(&dum->gadget);
425
if (!is_enabled(dum_hcd))
429
* For HS/FS devices only bits 0..10 of the wMaxPacketSize represent the
430
* maximum packet size.
431
* For SS devices the wMaxPacketSize is limited by 1024.
433
max = usb_endpoint_maxp(desc) & 0x7ff;
435
/* drivers must not request bad settings, since lower levels
436
* (hardware or its drivers) may not check. some endpoints
437
* can't do iso, many have maxpacket limitations, etc.
439
* since this "hardware" driver is here to help debugging, we
440
* have some extra sanity checks. (there could be more though,
441
* especially for "ep9out" style fixed function ones.)
444
switch (desc->bmAttributes & 0x03) {
445
case USB_ENDPOINT_XFER_BULK:
446
if (strstr (ep->ep.name, "-iso")
447
|| strstr (ep->ep.name, "-int")) {
450
switch (dum->gadget.speed) {
451
case USB_SPEED_SUPER:
460
if (max == 8 || max == 16 || max == 32 || max == 64)
461
/* we'll fake any legal size */
463
/* save a return statement */
468
case USB_ENDPOINT_XFER_INT:
469
if (strstr (ep->ep.name, "-iso")) /* bulk is ok */
471
/* real hardware might not handle all packet sizes */
472
switch (dum->gadget.speed) {
473
case USB_SPEED_SUPER:
477
/* save a return statement */
481
/* save a return statement */
488
case USB_ENDPOINT_XFER_ISOC:
489
if (strstr (ep->ep.name, "-bulk")
490
|| strstr (ep->ep.name, "-int"))
492
/* real hardware might not handle all packet sizes */
493
switch (dum->gadget.speed) {
494
case USB_SPEED_SUPER:
498
/* save a return statement */
502
/* save a return statement */
508
/* few chips support control except on ep0 */
512
_ep->maxpacket = max;
515
dev_dbg (udc_dev(dum), "enabled %s (ep%d%s-%s) maxpacket %d\n",
517
desc->bEndpointAddress & 0x0f,
518
(desc->bEndpointAddress & USB_DIR_IN) ? "in" : "out",
520
switch (desc->bmAttributes & 0x03) {
521
case USB_ENDPOINT_XFER_BULK:
524
case USB_ENDPOINT_XFER_ISOC:
527
case USB_ENDPOINT_XFER_INT:
536
/* at this point real hardware should be NAKing transfers
537
* to that endpoint, until a buffer is queued to it.
539
ep->halted = ep->wedged = 0;
545
static int dummy_disable (struct usb_ep *_ep)
552
ep = usb_ep_to_dummy_ep (_ep);
553
if (!_ep || !ep->desc || _ep->name == ep0name)
555
dum = ep_to_dummy (ep);
557
spin_lock_irqsave (&dum->lock, flags);
561
spin_unlock_irqrestore (&dum->lock, flags);
563
dev_dbg (udc_dev(dum), "disabled %s\n", _ep->name);
567
static struct usb_request *
568
dummy_alloc_request (struct usb_ep *_ep, gfp_t mem_flags)
571
struct dummy_request *req;
575
ep = usb_ep_to_dummy_ep (_ep);
577
req = kzalloc(sizeof(*req), mem_flags);
580
INIT_LIST_HEAD (&req->queue);
585
dummy_free_request (struct usb_ep *_ep, struct usb_request *_req)
588
struct dummy_request *req;
590
ep = usb_ep_to_dummy_ep (_ep);
591
if (!ep || !_req || (!ep->desc && _ep->name != ep0name))
594
req = usb_request_to_dummy_request (_req);
595
WARN_ON (!list_empty (&req->queue));
600
fifo_complete (struct usb_ep *ep, struct usb_request *req)
605
dummy_queue (struct usb_ep *_ep, struct usb_request *_req,
609
struct dummy_request *req;
611
struct dummy_hcd *dum_hcd;
614
req = usb_request_to_dummy_request (_req);
615
if (!_req || !list_empty (&req->queue) || !_req->complete)
618
ep = usb_ep_to_dummy_ep (_ep);
619
if (!_ep || (!ep->desc && _ep->name != ep0name))
622
dum = ep_to_dummy (ep);
623
dum_hcd = gadget_to_dummy_hcd(&dum->gadget);
624
if (!dum->driver || !is_enabled(dum_hcd))
628
dev_dbg (udc_dev(dum), "ep %p queue req %p to %s, len %d buf %p\n",
629
ep, _req, _ep->name, _req->length, _req->buf);
632
_req->status = -EINPROGRESS;
634
spin_lock_irqsave (&dum->lock, flags);
636
/* implement an emulated single-request FIFO */
637
if (ep->desc && (ep->desc->bEndpointAddress & USB_DIR_IN) &&
638
list_empty (&dum->fifo_req.queue) &&
639
list_empty (&ep->queue) &&
640
_req->length <= FIFO_SIZE) {
641
req = &dum->fifo_req;
643
req->req.buf = dum->fifo_buf;
644
memcpy (dum->fifo_buf, _req->buf, _req->length);
645
req->req.context = dum;
646
req->req.complete = fifo_complete;
648
list_add_tail(&req->queue, &ep->queue);
649
spin_unlock (&dum->lock);
650
_req->actual = _req->length;
652
_req->complete (_ep, _req);
653
spin_lock (&dum->lock);
655
list_add_tail(&req->queue, &ep->queue);
656
spin_unlock_irqrestore (&dum->lock, flags);
658
/* real hardware would likely enable transfers here, in case
659
* it'd been left NAKing.
664
static int dummy_dequeue (struct usb_ep *_ep, struct usb_request *_req)
668
int retval = -EINVAL;
670
struct dummy_request *req = NULL;
674
ep = usb_ep_to_dummy_ep (_ep);
675
dum = ep_to_dummy (ep);
680
local_irq_save (flags);
681
spin_lock (&dum->lock);
682
list_for_each_entry (req, &ep->queue, queue) {
683
if (&req->req == _req) {
684
list_del_init (&req->queue);
685
_req->status = -ECONNRESET;
690
spin_unlock (&dum->lock);
693
dev_dbg (udc_dev(dum),
694
"dequeued req %p from %s, len %d buf %p\n",
695
req, _ep->name, _req->length, _req->buf);
696
_req->complete (_ep, _req);
698
local_irq_restore (flags);
703
dummy_set_halt_and_wedge(struct usb_ep *_ep, int value, int wedged)
710
ep = usb_ep_to_dummy_ep (_ep);
711
dum = ep_to_dummy (ep);
715
ep->halted = ep->wedged = 0;
716
else if (ep->desc && (ep->desc->bEndpointAddress & USB_DIR_IN) &&
717
!list_empty (&ep->queue))
724
/* FIXME clear emulated data toggle too */
729
dummy_set_halt(struct usb_ep *_ep, int value)
731
return dummy_set_halt_and_wedge(_ep, value, 0);
734
static int dummy_set_wedge(struct usb_ep *_ep)
736
if (!_ep || _ep->name == ep0name)
738
return dummy_set_halt_and_wedge(_ep, 1, 1);
741
static const struct usb_ep_ops dummy_ep_ops = {
742
.enable = dummy_enable,
743
.disable = dummy_disable,
745
.alloc_request = dummy_alloc_request,
746
.free_request = dummy_free_request,
748
.queue = dummy_queue,
749
.dequeue = dummy_dequeue,
751
.set_halt = dummy_set_halt,
752
.set_wedge = dummy_set_wedge,
755
/*-------------------------------------------------------------------------*/
757
/* there are both host and device side versions of this call ... */
758
static int dummy_g_get_frame (struct usb_gadget *_gadget)
762
do_gettimeofday (&tv);
763
return tv.tv_usec / 1000;
766
static int dummy_wakeup (struct usb_gadget *_gadget)
768
struct dummy_hcd *dum_hcd;
770
dum_hcd = gadget_to_dummy_hcd(_gadget);
771
if (!(dum_hcd->dum->devstatus & ((1 << USB_DEVICE_B_HNP_ENABLE)
772
| (1 << USB_DEVICE_REMOTE_WAKEUP))))
774
if ((dum_hcd->port_status & USB_PORT_STAT_CONNECTION) == 0)
776
if ((dum_hcd->port_status & USB_PORT_STAT_SUSPEND) == 0 &&
777
dum_hcd->rh_state != DUMMY_RH_SUSPENDED)
780
/* FIXME: What if the root hub is suspended but the port isn't? */
782
/* hub notices our request, issues downstream resume, etc */
783
dum_hcd->resuming = 1;
784
dum_hcd->re_timeout = jiffies + msecs_to_jiffies(20);
785
mod_timer(&dummy_hcd_to_hcd(dum_hcd)->rh_timer, dum_hcd->re_timeout);
789
static int dummy_set_selfpowered (struct usb_gadget *_gadget, int value)
793
dum = (gadget_to_dummy_hcd(_gadget))->dum;
795
dum->devstatus |= (1 << USB_DEVICE_SELF_POWERED);
797
dum->devstatus &= ~(1 << USB_DEVICE_SELF_POWERED);
801
static void dummy_udc_udpate_ep0(struct dummy *dum)
805
if (dum->gadget.speed == USB_SPEED_SUPER) {
806
for (i = 0; i < DUMMY_ENDPOINTS; i++)
807
dum->ep[i].ep.max_streams = 0x10;
808
dum->ep[0].ep.maxpacket = 9;
810
for (i = 0; i < DUMMY_ENDPOINTS; i++)
811
dum->ep[i].ep.max_streams = 0;
812
dum->ep[0].ep.maxpacket = 64;
816
static int dummy_pullup (struct usb_gadget *_gadget, int value)
818
struct dummy_hcd *dum_hcd;
822
dum = gadget_dev_to_dummy(&_gadget->dev);
824
if (value && dum->driver) {
825
if (mod_data.is_super_speed)
826
dum->gadget.speed = dum->driver->speed;
827
else if (mod_data.is_high_speed)
828
dum->gadget.speed = min_t(u8, USB_SPEED_HIGH,
831
dum->gadget.speed = USB_SPEED_FULL;
832
dummy_udc_udpate_ep0(dum);
834
if (dum->gadget.speed < dum->driver->speed)
835
dev_dbg(udc_dev(dum), "This device can perform faster"
836
" if you connect it to a %s port...\n",
837
(dum->driver->speed == USB_SPEED_SUPER ?
838
"SuperSpeed" : "HighSpeed"));
840
dum_hcd = gadget_to_dummy_hcd(_gadget);
842
spin_lock_irqsave (&dum->lock, flags);
843
dum->pullup = (value != 0);
844
set_link_state(dum_hcd);
845
spin_unlock_irqrestore (&dum->lock, flags);
847
usb_hcd_poll_rh_status(dummy_hcd_to_hcd(dum_hcd));
851
static int dummy_udc_start(struct usb_gadget *g,
852
struct usb_gadget_driver *driver);
853
static int dummy_udc_stop(struct usb_gadget *g,
854
struct usb_gadget_driver *driver);
856
static const struct usb_gadget_ops dummy_ops = {
857
.get_frame = dummy_g_get_frame,
858
.wakeup = dummy_wakeup,
859
.set_selfpowered = dummy_set_selfpowered,
860
.pullup = dummy_pullup,
861
.udc_start = dummy_udc_start,
862
.udc_stop = dummy_udc_stop,
865
/*-------------------------------------------------------------------------*/
867
/* "function" sysfs attribute */
869
show_function (struct device *dev, struct device_attribute *attr, char *buf)
871
struct dummy *dum = gadget_dev_to_dummy (dev);
873
if (!dum->driver || !dum->driver->function)
875
return scnprintf (buf, PAGE_SIZE, "%s\n", dum->driver->function);
877
static DEVICE_ATTR (function, S_IRUGO, show_function, NULL);
879
/*-------------------------------------------------------------------------*/
882
* Driver registration/unregistration.
884
* This is basically hardware-specific; there's usually only one real USB
885
* device (not host) controller since that's how USB devices are intended
886
* to work. So most implementations of these api calls will rely on the
887
* fact that only one driver will ever bind to the hardware. But curious
888
* hardware can be built with discrete components, so the gadget API doesn't
889
* require that assumption.
891
* For this emulator, it might be convenient to create a usb slave device
892
* for each driver that registers: just add to a big root hub.
895
static int dummy_udc_start(struct usb_gadget *g,
896
struct usb_gadget_driver *driver)
898
struct dummy_hcd *dum_hcd = gadget_to_dummy_hcd(g);
899
struct dummy *dum = dum_hcd->dum;
901
if (driver->speed == USB_SPEED_UNKNOWN)
905
* SLAVE side init ... the layer above hardware, which
906
* can't enumerate without help from the driver we're binding.
911
dum->driver = driver;
912
dev_dbg (udc_dev(dum), "binding gadget driver '%s'\n",
913
driver->driver.name);
917
static int dummy_udc_stop(struct usb_gadget *g,
918
struct usb_gadget_driver *driver)
920
struct dummy_hcd *dum_hcd = gadget_to_dummy_hcd(g);
921
struct dummy *dum = dum_hcd->dum;
923
dev_dbg (udc_dev(dum), "unregister gadget driver '%s'\n",
924
driver->driver.name);
928
dummy_pullup(&dum->gadget, 0);
934
/* The gadget structure is stored inside the hcd structure and will be
935
* released along with it. */
937
dummy_gadget_release (struct device *dev)
942
static void init_dummy_udc_hw(struct dummy *dum)
946
INIT_LIST_HEAD(&dum->gadget.ep_list);
947
for (i = 0; i < DUMMY_ENDPOINTS; i++) {
948
struct dummy_ep *ep = &dum->ep[i];
952
ep->ep.name = ep_name[i];
953
ep->ep.ops = &dummy_ep_ops;
954
list_add_tail(&ep->ep.ep_list, &dum->gadget.ep_list);
955
ep->halted = ep->wedged = ep->already_seen =
957
ep->ep.maxpacket = ~0;
958
ep->last_io = jiffies;
959
ep->gadget = &dum->gadget;
961
INIT_LIST_HEAD(&ep->queue);
964
dum->gadget.ep0 = &dum->ep[0].ep;
965
list_del_init(&dum->ep[0].ep.ep_list);
966
INIT_LIST_HEAD(&dum->fifo_req.queue);
968
#ifdef CONFIG_USB_OTG
969
dum->gadget.is_otg = 1;
973
static int dummy_udc_probe (struct platform_device *pdev)
975
struct dummy *dum = &the_controller;
978
dum->gadget.name = gadget_name;
979
dum->gadget.ops = &dummy_ops;
980
dum->gadget.is_dualspeed = 1;
982
dev_set_name(&dum->gadget.dev, "gadget");
983
dum->gadget.dev.parent = &pdev->dev;
984
dum->gadget.dev.release = dummy_gadget_release;
985
rc = device_register (&dum->gadget.dev);
987
put_device(&dum->gadget.dev);
991
init_dummy_udc_hw(dum);
993
rc = usb_add_gadget_udc(&pdev->dev, &dum->gadget);
997
rc = device_create_file (&dum->gadget.dev, &dev_attr_function);
1000
platform_set_drvdata(pdev, dum);
1004
usb_del_gadget_udc(&dum->gadget);
1006
device_unregister(&dum->gadget.dev);
1010
static int dummy_udc_remove (struct platform_device *pdev)
1012
struct dummy *dum = platform_get_drvdata (pdev);
1014
usb_del_gadget_udc(&dum->gadget);
1015
platform_set_drvdata (pdev, NULL);
1016
device_remove_file (&dum->gadget.dev, &dev_attr_function);
1017
device_unregister (&dum->gadget.dev);
1021
static void dummy_udc_pm(struct dummy *dum, struct dummy_hcd *dum_hcd,
1024
spin_lock_irq(&dum->lock);
1025
dum->udc_suspended = suspend;
1026
set_link_state(dum_hcd);
1027
spin_unlock_irq(&dum->lock);
1030
static int dummy_udc_suspend(struct platform_device *pdev, pm_message_t state)
1032
struct dummy *dum = platform_get_drvdata(pdev);
1033
struct dummy_hcd *dum_hcd = gadget_to_dummy_hcd(&dum->gadget);
1035
dev_dbg(&pdev->dev, "%s\n", __func__);
1036
dummy_udc_pm(dum, dum_hcd, 1);
1037
usb_hcd_poll_rh_status(dummy_hcd_to_hcd(dum_hcd));
1041
static int dummy_udc_resume(struct platform_device *pdev)
1043
struct dummy *dum = platform_get_drvdata(pdev);
1044
struct dummy_hcd *dum_hcd = gadget_to_dummy_hcd(&dum->gadget);
1046
dev_dbg(&pdev->dev, "%s\n", __func__);
1047
dummy_udc_pm(dum, dum_hcd, 0);
1048
usb_hcd_poll_rh_status(dummy_hcd_to_hcd(dum_hcd));
1052
static struct platform_driver dummy_udc_driver = {
1053
.probe = dummy_udc_probe,
1054
.remove = dummy_udc_remove,
1055
.suspend = dummy_udc_suspend,
1056
.resume = dummy_udc_resume,
1058
.name = (char *) gadget_name,
1059
.owner = THIS_MODULE,
1063
/*-------------------------------------------------------------------------*/
1065
/* MASTER/HOST SIDE DRIVER
1067
* this uses the hcd framework to hook up to host side drivers.
1068
* its root hub will only have one device, otherwise it acts like
1069
* a normal host controller.
1071
* when urbs are queued, they're just stuck on a list that we
1072
* scan in a timer callback. that callback connects writes from
1073
* the host with reads from the device, and so on, based on the
1077
static int dummy_urb_enqueue (
1078
struct usb_hcd *hcd,
1082
struct dummy_hcd *dum_hcd;
1084
unsigned long flags;
1087
if (!urb->transfer_buffer && urb->transfer_buffer_length)
1090
urbp = kmalloc (sizeof *urbp, mem_flags);
1095
dum_hcd = hcd_to_dummy_hcd(hcd);
1096
spin_lock_irqsave(&dum_hcd->dum->lock, flags);
1097
rc = usb_hcd_link_urb_to_ep(hcd, urb);
1103
if (!dum_hcd->udev) {
1104
dum_hcd->udev = urb->dev;
1105
usb_get_dev(dum_hcd->udev);
1106
} else if (unlikely(dum_hcd->udev != urb->dev))
1107
dev_err(dummy_dev(dum_hcd), "usb_device address has changed!\n");
1109
list_add_tail(&urbp->urbp_list, &dum_hcd->urbp_list);
1111
if (usb_pipetype (urb->pipe) == PIPE_CONTROL)
1112
urb->error_count = 1; /* mark as a new urb */
1114
/* kick the scheduler, it'll do the rest */
1115
if (!timer_pending(&dum_hcd->timer))
1116
mod_timer(&dum_hcd->timer, jiffies + 1);
1119
spin_unlock_irqrestore(&dum_hcd->dum->lock, flags);
1123
static int dummy_urb_dequeue(struct usb_hcd *hcd, struct urb *urb, int status)
1125
struct dummy_hcd *dum_hcd;
1126
unsigned long flags;
1129
/* giveback happens automatically in timer callback,
1130
* so make sure the callback happens */
1131
dum_hcd = hcd_to_dummy_hcd(hcd);
1132
spin_lock_irqsave(&dum_hcd->dum->lock, flags);
1134
rc = usb_hcd_check_unlink_urb(hcd, urb, status);
1135
if (!rc && dum_hcd->rh_state != DUMMY_RH_RUNNING &&
1136
!list_empty(&dum_hcd->urbp_list))
1137
mod_timer(&dum_hcd->timer, jiffies);
1139
spin_unlock_irqrestore(&dum_hcd->dum->lock, flags);
1143
/* transfer up to a frame's worth; caller must own lock */
1145
transfer(struct dummy *dum, struct urb *urb, struct dummy_ep *ep, int limit,
1148
struct dummy_request *req;
1151
/* if there's no request queued, the device is NAKing; return */
1152
list_for_each_entry (req, &ep->queue, queue) {
1153
unsigned host_len, dev_len, len;
1154
int is_short, to_host;
1157
/* 1..N packets of ep->ep.maxpacket each ... the last one
1158
* may be short (including zero length).
1160
* writer can send a zlp explicitly (length 0) or implicitly
1161
* (length mod maxpacket zero, and 'zero' flag); they always
1164
host_len = urb->transfer_buffer_length - urb->actual_length;
1165
dev_len = req->req.length - req->req.actual;
1166
len = min (host_len, dev_len);
1168
/* FIXME update emulated data toggle too */
1170
to_host = usb_pipein (urb->pipe);
1171
if (unlikely (len == 0))
1176
/* not enough bandwidth left? */
1177
if (limit < ep->ep.maxpacket && limit < len)
1179
len = min (len, (unsigned) limit);
1183
/* use an extra pass for the final short packet */
1184
if (len > ep->ep.maxpacket) {
1186
len -= (len % ep->ep.maxpacket);
1188
is_short = (len % ep->ep.maxpacket) != 0;
1190
/* else transfer packet(s) */
1191
ubuf = urb->transfer_buffer + urb->actual_length;
1192
rbuf = req->req.buf + req->req.actual;
1194
memcpy (ubuf, rbuf, len);
1196
memcpy (rbuf, ubuf, len);
1197
ep->last_io = jiffies;
1200
urb->actual_length += len;
1201
req->req.actual += len;
1204
/* short packets terminate, maybe with overflow/underflow.
1205
* it's only really an error to write too much.
1207
* partially filling a buffer optionally blocks queue advances
1208
* (so completion handlers can clean up the queue) but we don't
1209
* need to emulate such data-in-flight.
1212
if (host_len == dev_len) {
1213
req->req.status = 0;
1215
} else if (to_host) {
1216
req->req.status = 0;
1217
if (dev_len > host_len)
1218
*status = -EOVERFLOW;
1221
} else if (!to_host) {
1223
if (host_len > dev_len)
1224
req->req.status = -EOVERFLOW;
1226
req->req.status = 0;
1229
/* many requests terminate without a short packet */
1231
if (req->req.length == req->req.actual
1233
req->req.status = 0;
1234
if (urb->transfer_buffer_length == urb->actual_length
1235
&& !(urb->transfer_flags
1240
/* device side completion --> continuable */
1241
if (req->req.status != -EINPROGRESS) {
1242
list_del_init (&req->queue);
1244
spin_unlock (&dum->lock);
1245
req->req.complete (&ep->ep, &req->req);
1246
spin_lock (&dum->lock);
1248
/* requests might have been unlinked... */
1252
/* host side completion --> terminate */
1253
if (*status != -EINPROGRESS)
1256
/* rescan to continue with any other queued i/o */
1263
static int periodic_bytes (struct dummy *dum, struct dummy_ep *ep)
1265
int limit = ep->ep.maxpacket;
1267
if (dum->gadget.speed == USB_SPEED_HIGH) {
1270
/* high bandwidth mode */
1271
tmp = usb_endpoint_maxp(ep->desc);
1272
tmp = (tmp >> 11) & 0x03;
1273
tmp *= 8 /* applies to entire frame */;
1274
limit += limit * tmp;
1276
if (dum->gadget.speed == USB_SPEED_SUPER) {
1277
switch (ep->desc->bmAttributes & 0x03) {
1278
case USB_ENDPOINT_XFER_ISOC:
1279
/* Sec. 4.4.8.2 USB3.0 Spec */
1280
limit = 3 * 16 * 1024 * 8;
1282
case USB_ENDPOINT_XFER_INT:
1283
/* Sec. 4.4.7.2 USB3.0 Spec */
1284
limit = 3 * 1024 * 8;
1286
case USB_ENDPOINT_XFER_BULK:
1294
#define is_active(dum_hcd) ((dum_hcd->port_status & \
1295
(USB_PORT_STAT_CONNECTION | USB_PORT_STAT_ENABLE | \
1296
USB_PORT_STAT_SUSPEND)) \
1297
== (USB_PORT_STAT_CONNECTION | USB_PORT_STAT_ENABLE))
1299
static struct dummy_ep *find_endpoint (struct dummy *dum, u8 address)
1303
if (!is_active((dum->gadget.speed == USB_SPEED_SUPER ?
1304
dum->ss_hcd : dum->hs_hcd)))
1306
if ((address & ~USB_DIR_IN) == 0)
1307
return &dum->ep [0];
1308
for (i = 1; i < DUMMY_ENDPOINTS; i++) {
1309
struct dummy_ep *ep = &dum->ep [i];
1313
if (ep->desc->bEndpointAddress == address)
1321
#define Dev_Request (USB_TYPE_STANDARD | USB_RECIP_DEVICE)
1322
#define Dev_InRequest (Dev_Request | USB_DIR_IN)
1323
#define Intf_Request (USB_TYPE_STANDARD | USB_RECIP_INTERFACE)
1324
#define Intf_InRequest (Intf_Request | USB_DIR_IN)
1325
#define Ep_Request (USB_TYPE_STANDARD | USB_RECIP_ENDPOINT)
1326
#define Ep_InRequest (Ep_Request | USB_DIR_IN)
1330
* handle_control_request() - handles all control transfers
1331
* @dum: pointer to dummy (the_controller)
1332
* @urb: the urb request to handle
1333
* @setup: pointer to the setup data for a USB device control
1335
* @status: pointer to request handling status
1337
* Return 0 - if the request was handled
1338
* 1 - if the request wasn't handles
1339
* error code on error
1341
static int handle_control_request(struct dummy_hcd *dum_hcd, struct urb *urb,
1342
struct usb_ctrlrequest *setup,
1345
struct dummy_ep *ep2;
1346
struct dummy *dum = dum_hcd->dum;
1351
w_index = le16_to_cpu(setup->wIndex);
1352
w_value = le16_to_cpu(setup->wValue);
1353
switch (setup->bRequest) {
1354
case USB_REQ_SET_ADDRESS:
1355
if (setup->bRequestType != Dev_Request)
1357
dum->address = w_value;
1359
dev_dbg(udc_dev(dum), "set_address = %d\n",
1363
case USB_REQ_SET_FEATURE:
1364
if (setup->bRequestType == Dev_Request) {
1367
case USB_DEVICE_REMOTE_WAKEUP:
1369
case USB_DEVICE_B_HNP_ENABLE:
1370
dum->gadget.b_hnp_enable = 1;
1372
case USB_DEVICE_A_HNP_SUPPORT:
1373
dum->gadget.a_hnp_support = 1;
1375
case USB_DEVICE_A_ALT_HNP_SUPPORT:
1376
dum->gadget.a_alt_hnp_support = 1;
1378
case USB_DEVICE_U1_ENABLE:
1379
if (dummy_hcd_to_hcd(dum_hcd)->speed ==
1381
w_value = USB_DEV_STAT_U1_ENABLED;
1383
ret_val = -EOPNOTSUPP;
1385
case USB_DEVICE_U2_ENABLE:
1386
if (dummy_hcd_to_hcd(dum_hcd)->speed ==
1388
w_value = USB_DEV_STAT_U2_ENABLED;
1390
ret_val = -EOPNOTSUPP;
1392
case USB_DEVICE_LTM_ENABLE:
1393
if (dummy_hcd_to_hcd(dum_hcd)->speed ==
1395
w_value = USB_DEV_STAT_LTM_ENABLED;
1397
ret_val = -EOPNOTSUPP;
1400
ret_val = -EOPNOTSUPP;
1403
dum->devstatus |= (1 << w_value);
1406
} else if (setup->bRequestType == Ep_Request) {
1408
ep2 = find_endpoint(dum, w_index);
1409
if (!ep2 || ep2->ep.name == ep0name) {
1410
ret_val = -EOPNOTSUPP;
1418
case USB_REQ_CLEAR_FEATURE:
1419
if (setup->bRequestType == Dev_Request) {
1422
case USB_DEVICE_REMOTE_WAKEUP:
1423
w_value = USB_DEVICE_REMOTE_WAKEUP;
1425
case USB_DEVICE_U1_ENABLE:
1426
if (dummy_hcd_to_hcd(dum_hcd)->speed ==
1428
w_value = USB_DEV_STAT_U1_ENABLED;
1430
ret_val = -EOPNOTSUPP;
1432
case USB_DEVICE_U2_ENABLE:
1433
if (dummy_hcd_to_hcd(dum_hcd)->speed ==
1435
w_value = USB_DEV_STAT_U2_ENABLED;
1437
ret_val = -EOPNOTSUPP;
1439
case USB_DEVICE_LTM_ENABLE:
1440
if (dummy_hcd_to_hcd(dum_hcd)->speed ==
1442
w_value = USB_DEV_STAT_LTM_ENABLED;
1444
ret_val = -EOPNOTSUPP;
1447
ret_val = -EOPNOTSUPP;
1451
dum->devstatus &= ~(1 << w_value);
1454
} else if (setup->bRequestType == Ep_Request) {
1456
ep2 = find_endpoint(dum, w_index);
1458
ret_val = -EOPNOTSUPP;
1467
case USB_REQ_GET_STATUS:
1468
if (setup->bRequestType == Dev_InRequest
1469
|| setup->bRequestType == Intf_InRequest
1470
|| setup->bRequestType == Ep_InRequest) {
1473
* device: remote wakeup, selfpowered
1474
* interface: nothing
1477
buf = (char *)urb->transfer_buffer;
1478
if (urb->transfer_buffer_length > 0) {
1479
if (setup->bRequestType == Ep_InRequest) {
1480
ep2 = find_endpoint(dum, w_index);
1482
ret_val = -EOPNOTSUPP;
1485
buf[0] = ep2->halted;
1486
} else if (setup->bRequestType ==
1488
buf[0] = (u8)dum->devstatus;
1492
if (urb->transfer_buffer_length > 1)
1494
urb->actual_length = min_t(u32, 2,
1495
urb->transfer_buffer_length);
1504
/* drive both sides of the transfers; looks like irq handlers to
1505
* both drivers except the callbacks aren't in_irq().
1507
static void dummy_timer(unsigned long _dum_hcd)
1509
struct dummy_hcd *dum_hcd = (struct dummy_hcd *) _dum_hcd;
1510
struct dummy *dum = dum_hcd->dum;
1511
struct urbp *urbp, *tmp;
1512
unsigned long flags;
1516
/* simplistic model for one frame's bandwidth */
1517
switch (dum->gadget.speed) {
1519
total = 8/*bytes*/ * 12/*packets*/;
1521
case USB_SPEED_FULL:
1522
total = 64/*bytes*/ * 19/*packets*/;
1524
case USB_SPEED_HIGH:
1525
total = 512/*bytes*/ * 13/*packets*/ * 8/*uframes*/;
1527
case USB_SPEED_SUPER:
1528
/* Bus speed is 500000 bytes/ms, so use a little less */
1532
dev_err(dummy_dev(dum_hcd), "bogus device speed\n");
1536
/* FIXME if HZ != 1000 this will probably misbehave ... */
1538
/* look at each urb queued by the host side driver */
1539
spin_lock_irqsave (&dum->lock, flags);
1541
if (!dum_hcd->udev) {
1542
dev_err(dummy_dev(dum_hcd),
1543
"timer fired with no URBs pending?\n");
1544
spin_unlock_irqrestore (&dum->lock, flags);
1548
for (i = 0; i < DUMMY_ENDPOINTS; i++) {
1551
dum->ep [i].already_seen = 0;
1555
list_for_each_entry_safe(urbp, tmp, &dum_hcd->urbp_list, urbp_list) {
1557
struct dummy_request *req;
1559
struct dummy_ep *ep = NULL;
1561
int status = -EINPROGRESS;
1566
else if (dum_hcd->rh_state != DUMMY_RH_RUNNING)
1568
type = usb_pipetype (urb->pipe);
1570
/* used up this frame's non-periodic bandwidth?
1571
* FIXME there's infinite bandwidth for control and
1572
* periodic transfers ... unrealistic.
1574
if (total <= 0 && type == PIPE_BULK)
1577
/* find the gadget's ep for this request (if configured) */
1578
address = usb_pipeendpoint (urb->pipe);
1579
if (usb_pipein (urb->pipe))
1580
address |= USB_DIR_IN;
1581
ep = find_endpoint(dum, address);
1583
/* set_configuration() disagreement */
1584
dev_dbg(dummy_dev(dum_hcd),
1585
"no ep configured for urb %p\n",
1591
if (ep->already_seen)
1593
ep->already_seen = 1;
1594
if (ep == &dum->ep [0] && urb->error_count) {
1595
ep->setup_stage = 1; /* a new urb */
1596
urb->error_count = 0;
1598
if (ep->halted && !ep->setup_stage) {
1599
/* NOTE: must not be iso! */
1600
dev_dbg(dummy_dev(dum_hcd), "ep %s halted, urb %p\n",
1605
/* FIXME make sure both ends agree on maxpacket */
1607
/* handle control requests */
1608
if (ep == &dum->ep [0] && ep->setup_stage) {
1609
struct usb_ctrlrequest setup;
1612
setup = *(struct usb_ctrlrequest*) urb->setup_packet;
1613
/* paranoia, in case of stale queued data */
1614
list_for_each_entry (req, &ep->queue, queue) {
1615
list_del_init (&req->queue);
1616
req->req.status = -EOVERFLOW;
1617
dev_dbg (udc_dev(dum), "stale req = %p\n",
1620
spin_unlock (&dum->lock);
1621
req->req.complete (&ep->ep, &req->req);
1622
spin_lock (&dum->lock);
1623
ep->already_seen = 0;
1627
/* gadget driver never sees set_address or operations
1628
* on standard feature flags. some hardware doesn't
1631
ep->last_io = jiffies;
1632
ep->setup_stage = 0;
1635
value = handle_control_request(dum_hcd, urb, &setup,
1638
/* gadget driver handles all other requests. block
1639
* until setup() returns; no reentrancy issues etc.
1642
spin_unlock (&dum->lock);
1643
value = dum->driver->setup (&dum->gadget,
1645
spin_lock (&dum->lock);
1648
/* no delays (max 64KB data stage) */
1650
goto treat_control_like_bulk;
1652
/* error, see below */
1656
if (value != -EOPNOTSUPP)
1657
dev_dbg (udc_dev(dum),
1661
urb->actual_length = 0;
1667
/* non-control requests */
1669
switch (usb_pipetype (urb->pipe)) {
1670
case PIPE_ISOCHRONOUS:
1671
/* FIXME is it urb->interval since the last xfer?
1672
* use urb->iso_frame_desc[i].
1673
* complete whether or not ep has requests queued.
1674
* report random errors, to debug drivers.
1676
limit = max (limit, periodic_bytes (dum, ep));
1680
case PIPE_INTERRUPT:
1681
/* FIXME is it urb->interval since the last xfer?
1682
* this almost certainly polls too fast.
1684
limit = max (limit, periodic_bytes (dum, ep));
1687
// case PIPE_BULK: case PIPE_CONTROL:
1689
treat_control_like_bulk:
1690
ep->last_io = jiffies;
1691
total = transfer(dum, urb, ep, limit, &status);
1695
/* incomplete transfer? */
1696
if (status == -EINPROGRESS)
1700
list_del (&urbp->urbp_list);
1703
ep->already_seen = ep->setup_stage = 0;
1705
usb_hcd_unlink_urb_from_ep(dummy_hcd_to_hcd(dum_hcd), urb);
1706
spin_unlock (&dum->lock);
1707
usb_hcd_giveback_urb(dummy_hcd_to_hcd(dum_hcd), urb, status);
1708
spin_lock (&dum->lock);
1713
if (list_empty(&dum_hcd->urbp_list)) {
1714
usb_put_dev(dum_hcd->udev);
1715
dum_hcd->udev = NULL;
1716
} else if (dum_hcd->rh_state == DUMMY_RH_RUNNING) {
1717
/* want a 1 msec delay here */
1718
mod_timer(&dum_hcd->timer, jiffies + msecs_to_jiffies(1));
1721
spin_unlock_irqrestore (&dum->lock, flags);
1724
/*-------------------------------------------------------------------------*/
1726
#define PORT_C_MASK \
1727
((USB_PORT_STAT_C_CONNECTION \
1728
| USB_PORT_STAT_C_ENABLE \
1729
| USB_PORT_STAT_C_SUSPEND \
1730
| USB_PORT_STAT_C_OVERCURRENT \
1731
| USB_PORT_STAT_C_RESET) << 16)
1733
static int dummy_hub_status (struct usb_hcd *hcd, char *buf)
1735
struct dummy_hcd *dum_hcd;
1736
unsigned long flags;
1739
dum_hcd = hcd_to_dummy_hcd(hcd);
1741
spin_lock_irqsave(&dum_hcd->dum->lock, flags);
1742
if (!HCD_HW_ACCESSIBLE(hcd))
1745
if (dum_hcd->resuming && time_after_eq(jiffies, dum_hcd->re_timeout)) {
1746
dum_hcd->port_status |= (USB_PORT_STAT_C_SUSPEND << 16);
1747
dum_hcd->port_status &= ~USB_PORT_STAT_SUSPEND;
1748
set_link_state(dum_hcd);
1751
if ((dum_hcd->port_status & PORT_C_MASK) != 0) {
1753
dev_dbg(dummy_dev(dum_hcd), "port status 0x%08x has changes\n",
1754
dum_hcd->port_status);
1756
if (dum_hcd->rh_state == DUMMY_RH_SUSPENDED)
1757
usb_hcd_resume_root_hub (hcd);
1760
spin_unlock_irqrestore(&dum_hcd->dum->lock, flags);
1765
ss_hub_descriptor(struct usb_hub_descriptor *desc)
1767
memset(desc, 0, sizeof *desc);
1768
desc->bDescriptorType = 0x2a;
1769
desc->bDescLength = 12;
1770
desc->wHubCharacteristics = cpu_to_le16(0x0001);
1771
desc->bNbrPorts = 1;
1772
desc->u.ss.bHubHdrDecLat = 0x04; /* Worst case: 0.4 micro sec*/
1773
desc->u.ss.DeviceRemovable = 0xffff;
1777
hub_descriptor (struct usb_hub_descriptor *desc)
1779
memset (desc, 0, sizeof *desc);
1780
desc->bDescriptorType = 0x29;
1781
desc->bDescLength = 9;
1782
desc->wHubCharacteristics = cpu_to_le16(0x0001);
1783
desc->bNbrPorts = 1;
1784
desc->u.hs.DeviceRemovable[0] = 0xff;
1785
desc->u.hs.DeviceRemovable[1] = 0xff;
1788
static int dummy_hub_control (
1789
struct usb_hcd *hcd,
1796
struct dummy_hcd *dum_hcd;
1798
unsigned long flags;
1800
if (!HCD_HW_ACCESSIBLE(hcd))
1803
dum_hcd = hcd_to_dummy_hcd(hcd);
1805
spin_lock_irqsave(&dum_hcd->dum->lock, flags);
1807
case ClearHubFeature:
1809
case ClearPortFeature:
1811
case USB_PORT_FEAT_SUSPEND:
1812
if (hcd->speed == HCD_USB3) {
1813
dev_dbg(dummy_dev(dum_hcd),
1814
"USB_PORT_FEAT_SUSPEND req not "
1815
"supported for USB 3.0 roothub\n");
1818
if (dum_hcd->port_status & USB_PORT_STAT_SUSPEND) {
1819
/* 20msec resume signaling */
1820
dum_hcd->resuming = 1;
1821
dum_hcd->re_timeout = jiffies +
1822
msecs_to_jiffies(20);
1825
case USB_PORT_FEAT_POWER:
1826
if (hcd->speed == HCD_USB3) {
1827
if (dum_hcd->port_status & USB_PORT_STAT_POWER)
1828
dev_dbg(dummy_dev(dum_hcd),
1831
if (dum_hcd->port_status &
1832
USB_SS_PORT_STAT_POWER)
1833
dev_dbg(dummy_dev(dum_hcd),
1837
dum_hcd->port_status &= ~(1 << wValue);
1838
set_link_state(dum_hcd);
1841
case GetHubDescriptor:
1842
if (hcd->speed == HCD_USB3 &&
1843
(wLength < USB_DT_SS_HUB_SIZE ||
1844
wValue != (USB_DT_SS_HUB << 8))) {
1845
dev_dbg(dummy_dev(dum_hcd),
1846
"Wrong hub descriptor type for "
1847
"USB 3.0 roothub.\n");
1850
if (hcd->speed == HCD_USB3)
1851
ss_hub_descriptor((struct usb_hub_descriptor *) buf);
1853
hub_descriptor((struct usb_hub_descriptor *) buf);
1856
*(__le32 *) buf = cpu_to_le32 (0);
1862
/* whoever resets or resumes must GetPortStatus to
1865
if (dum_hcd->resuming &&
1866
time_after_eq(jiffies, dum_hcd->re_timeout)) {
1867
dum_hcd->port_status |= (USB_PORT_STAT_C_SUSPEND << 16);
1868
dum_hcd->port_status &= ~USB_PORT_STAT_SUSPEND;
1870
if ((dum_hcd->port_status & USB_PORT_STAT_RESET) != 0 &&
1871
time_after_eq(jiffies, dum_hcd->re_timeout)) {
1872
dum_hcd->port_status |= (USB_PORT_STAT_C_RESET << 16);
1873
dum_hcd->port_status &= ~USB_PORT_STAT_RESET;
1874
if (dum_hcd->dum->pullup) {
1875
dum_hcd->port_status |= USB_PORT_STAT_ENABLE;
1877
if (hcd->speed < HCD_USB3) {
1878
switch (dum_hcd->dum->gadget.speed) {
1879
case USB_SPEED_HIGH:
1880
dum_hcd->port_status |=
1881
USB_PORT_STAT_HIGH_SPEED;
1884
dum_hcd->dum->gadget.ep0->
1886
dum_hcd->port_status |=
1887
USB_PORT_STAT_LOW_SPEED;
1890
dum_hcd->dum->gadget.speed =
1897
set_link_state(dum_hcd);
1898
((__le16 *) buf)[0] = cpu_to_le16 (dum_hcd->port_status);
1899
((__le16 *) buf)[1] = cpu_to_le16 (dum_hcd->port_status >> 16);
1904
case SetPortFeature:
1906
case USB_PORT_FEAT_LINK_STATE:
1907
if (hcd->speed != HCD_USB3) {
1908
dev_dbg(dummy_dev(dum_hcd),
1909
"USB_PORT_FEAT_LINK_STATE req not "
1910
"supported for USB 2.0 roothub\n");
1914
* Since this is dummy we don't have an actual link so
1915
* there is nothing to do for the SET_LINK_STATE cmd
1918
case USB_PORT_FEAT_U1_TIMEOUT:
1919
case USB_PORT_FEAT_U2_TIMEOUT:
1920
/* TODO: add suspend/resume support! */
1921
if (hcd->speed != HCD_USB3) {
1922
dev_dbg(dummy_dev(dum_hcd),
1923
"USB_PORT_FEAT_U1/2_TIMEOUT req not "
1924
"supported for USB 2.0 roothub\n");
1928
case USB_PORT_FEAT_SUSPEND:
1929
/* Applicable only for USB2.0 hub */
1930
if (hcd->speed == HCD_USB3) {
1931
dev_dbg(dummy_dev(dum_hcd),
1932
"USB_PORT_FEAT_SUSPEND req not "
1933
"supported for USB 3.0 roothub\n");
1936
if (dum_hcd->active) {
1937
dum_hcd->port_status |= USB_PORT_STAT_SUSPEND;
1939
/* HNP would happen here; for now we
1940
* assume b_bus_req is always true.
1942
set_link_state(dum_hcd);
1943
if (((1 << USB_DEVICE_B_HNP_ENABLE)
1944
& dum_hcd->dum->devstatus) != 0)
1945
dev_dbg(dummy_dev(dum_hcd),
1949
case USB_PORT_FEAT_POWER:
1950
if (hcd->speed == HCD_USB3)
1951
dum_hcd->port_status |= USB_SS_PORT_STAT_POWER;
1953
dum_hcd->port_status |= USB_PORT_STAT_POWER;
1954
set_link_state(dum_hcd);
1956
case USB_PORT_FEAT_BH_PORT_RESET:
1957
/* Applicable only for USB3.0 hub */
1958
if (hcd->speed != HCD_USB3) {
1959
dev_dbg(dummy_dev(dum_hcd),
1960
"USB_PORT_FEAT_BH_PORT_RESET req not "
1961
"supported for USB 2.0 roothub\n");
1965
case USB_PORT_FEAT_RESET:
1966
/* if it's already enabled, disable */
1967
if (hcd->speed == HCD_USB3) {
1968
dum_hcd->port_status = 0;
1969
dum_hcd->port_status =
1970
(USB_SS_PORT_STAT_POWER |
1971
USB_PORT_STAT_CONNECTION |
1972
USB_PORT_STAT_RESET);
1974
dum_hcd->port_status &= ~(USB_PORT_STAT_ENABLE
1975
| USB_PORT_STAT_LOW_SPEED
1976
| USB_PORT_STAT_HIGH_SPEED);
1978
* We want to reset device status. All but the
1979
* Self powered feature
1981
dum_hcd->dum->devstatus &=
1982
(1 << USB_DEVICE_SELF_POWERED);
1984
* FIXME USB3.0: what is the correct reset signaling
1985
* interval? Is it still 50msec as for HS?
1987
dum_hcd->re_timeout = jiffies + msecs_to_jiffies(50);
1990
if (hcd->speed == HCD_USB3) {
1991
if ((dum_hcd->port_status &
1992
USB_SS_PORT_STAT_POWER) != 0) {
1993
dum_hcd->port_status |= (1 << wValue);
1994
set_link_state(dum_hcd);
1997
if ((dum_hcd->port_status &
1998
USB_PORT_STAT_POWER) != 0) {
1999
dum_hcd->port_status |= (1 << wValue);
2000
set_link_state(dum_hcd);
2004
case GetPortErrorCount:
2005
if (hcd->speed != HCD_USB3) {
2006
dev_dbg(dummy_dev(dum_hcd),
2007
"GetPortErrorCount req not "
2008
"supported for USB 2.0 roothub\n");
2011
/* We'll always return 0 since this is a dummy hub */
2012
*(__le32 *) buf = cpu_to_le32(0);
2015
if (hcd->speed != HCD_USB3) {
2016
dev_dbg(dummy_dev(dum_hcd),
2017
"SetHubDepth req not supported for "
2018
"USB 2.0 roothub\n");
2023
dev_dbg(dummy_dev(dum_hcd),
2024
"hub control req%04x v%04x i%04x l%d\n",
2025
typeReq, wValue, wIndex, wLength);
2027
/* "protocol stall" on error */
2030
spin_unlock_irqrestore(&dum_hcd->dum->lock, flags);
2032
if ((dum_hcd->port_status & PORT_C_MASK) != 0)
2033
usb_hcd_poll_rh_status (hcd);
2037
static int dummy_bus_suspend (struct usb_hcd *hcd)
2039
struct dummy_hcd *dum_hcd = hcd_to_dummy_hcd(hcd);
2041
dev_dbg (&hcd->self.root_hub->dev, "%s\n", __func__);
2043
spin_lock_irq(&dum_hcd->dum->lock);
2044
dum_hcd->rh_state = DUMMY_RH_SUSPENDED;
2045
set_link_state(dum_hcd);
2046
hcd->state = HC_STATE_SUSPENDED;
2047
spin_unlock_irq(&dum_hcd->dum->lock);
2051
static int dummy_bus_resume (struct usb_hcd *hcd)
2053
struct dummy_hcd *dum_hcd = hcd_to_dummy_hcd(hcd);
2056
dev_dbg (&hcd->self.root_hub->dev, "%s\n", __func__);
2058
spin_lock_irq(&dum_hcd->dum->lock);
2059
if (!HCD_HW_ACCESSIBLE(hcd)) {
2062
dum_hcd->rh_state = DUMMY_RH_RUNNING;
2063
set_link_state(dum_hcd);
2064
if (!list_empty(&dum_hcd->urbp_list))
2065
mod_timer(&dum_hcd->timer, jiffies);
2066
hcd->state = HC_STATE_RUNNING;
2068
spin_unlock_irq(&dum_hcd->dum->lock);
2072
/*-------------------------------------------------------------------------*/
2074
static inline ssize_t
2075
show_urb (char *buf, size_t size, struct urb *urb)
2077
int ep = usb_pipeendpoint (urb->pipe);
2079
return snprintf (buf, size,
2080
"urb/%p %s ep%d%s%s len %d/%d\n",
2083
switch (urb->dev->speed) {
2087
case USB_SPEED_FULL:
2090
case USB_SPEED_HIGH:
2093
case USB_SPEED_SUPER:
2100
ep, ep ? (usb_pipein (urb->pipe) ? "in" : "out") : "",
2102
switch (usb_pipetype (urb->pipe)) { \
2103
case PIPE_CONTROL: \
2109
case PIPE_INTERRUPT: \
2116
urb->actual_length, urb->transfer_buffer_length);
2120
show_urbs (struct device *dev, struct device_attribute *attr, char *buf)
2122
struct usb_hcd *hcd = dev_get_drvdata (dev);
2123
struct dummy_hcd *dum_hcd = hcd_to_dummy_hcd(hcd);
2126
unsigned long flags;
2128
spin_lock_irqsave(&dum_hcd->dum->lock, flags);
2129
list_for_each_entry(urbp, &dum_hcd->urbp_list, urbp_list) {
2132
temp = show_urb (buf, PAGE_SIZE - size, urbp->urb);
2136
spin_unlock_irqrestore(&dum_hcd->dum->lock, flags);
2140
static DEVICE_ATTR (urbs, S_IRUGO, show_urbs, NULL);
2142
static int dummy_start_ss(struct dummy_hcd *dum_hcd)
2144
init_timer(&dum_hcd->timer);
2145
dum_hcd->timer.function = dummy_timer;
2146
dum_hcd->timer.data = (unsigned long)dum_hcd;
2147
dum_hcd->rh_state = DUMMY_RH_RUNNING;
2148
INIT_LIST_HEAD(&dum_hcd->urbp_list);
2149
dummy_hcd_to_hcd(dum_hcd)->power_budget = POWER_BUDGET;
2150
dummy_hcd_to_hcd(dum_hcd)->state = HC_STATE_RUNNING;
2151
dummy_hcd_to_hcd(dum_hcd)->uses_new_polling = 1;
2152
#ifdef CONFIG_USB_OTG
2153
dummy_hcd_to_hcd(dum_hcd)->self.otg_port = 1;
2157
/* FIXME 'urbs' should be a per-device thing, maybe in usbcore */
2158
return device_create_file(dummy_dev(dum_hcd), &dev_attr_urbs);
2161
static int dummy_start(struct usb_hcd *hcd)
2163
struct dummy_hcd *dum_hcd = hcd_to_dummy_hcd(hcd);
2166
* MASTER side init ... we emulate a root hub that'll only ever
2167
* talk to one device (the slave side). Also appears in sysfs,
2168
* just like more familiar pci-based HCDs.
2170
if (!usb_hcd_is_primary_hcd(hcd))
2171
return dummy_start_ss(dum_hcd);
2173
spin_lock_init(&dum_hcd->dum->lock);
2174
init_timer(&dum_hcd->timer);
2175
dum_hcd->timer.function = dummy_timer;
2176
dum_hcd->timer.data = (unsigned long)dum_hcd;
2177
dum_hcd->rh_state = DUMMY_RH_RUNNING;
2179
INIT_LIST_HEAD(&dum_hcd->urbp_list);
2181
hcd->power_budget = POWER_BUDGET;
2182
hcd->state = HC_STATE_RUNNING;
2183
hcd->uses_new_polling = 1;
2185
#ifdef CONFIG_USB_OTG
2186
hcd->self.otg_port = 1;
2189
/* FIXME 'urbs' should be a per-device thing, maybe in usbcore */
2190
return device_create_file(dummy_dev(dum_hcd), &dev_attr_urbs);
2193
static void dummy_stop (struct usb_hcd *hcd)
2197
dum = (hcd_to_dummy_hcd(hcd))->dum;
2198
device_remove_file(dummy_dev(hcd_to_dummy_hcd(hcd)), &dev_attr_urbs);
2199
usb_gadget_unregister_driver(dum->driver);
2200
dev_info(dummy_dev(hcd_to_dummy_hcd(hcd)), "stopped\n");
2203
/*-------------------------------------------------------------------------*/
2205
static int dummy_h_get_frame (struct usb_hcd *hcd)
2207
return dummy_g_get_frame (NULL);
2210
static int dummy_setup(struct usb_hcd *hcd)
2212
if (usb_hcd_is_primary_hcd(hcd)) {
2213
the_controller.hs_hcd = hcd_to_dummy_hcd(hcd);
2214
the_controller.hs_hcd->dum = &the_controller;
2216
* Mark the first roothub as being USB 2.0.
2217
* The USB 3.0 roothub will be registered later by
2220
hcd->speed = HCD_USB2;
2221
hcd->self.root_hub->speed = USB_SPEED_HIGH;
2223
the_controller.ss_hcd = hcd_to_dummy_hcd(hcd);
2224
the_controller.ss_hcd->dum = &the_controller;
2225
hcd->speed = HCD_USB3;
2226
hcd->self.root_hub->speed = USB_SPEED_SUPER;
2231
/* Change a group of bulk endpoints to support multiple stream IDs */
2232
int dummy_alloc_streams(struct usb_hcd *hcd, struct usb_device *udev,
2233
struct usb_host_endpoint **eps, unsigned int num_eps,
2234
unsigned int num_streams, gfp_t mem_flags)
2236
if (hcd->speed != HCD_USB3)
2237
dev_dbg(dummy_dev(hcd_to_dummy_hcd(hcd)),
2238
"%s() - ERROR! Not supported for USB2.0 roothub\n",
2243
/* Reverts a group of bulk endpoints back to not using stream IDs. */
2244
int dummy_free_streams(struct usb_hcd *hcd, struct usb_device *udev,
2245
struct usb_host_endpoint **eps, unsigned int num_eps,
2248
if (hcd->speed != HCD_USB3)
2249
dev_dbg(dummy_dev(hcd_to_dummy_hcd(hcd)),
2250
"%s() - ERROR! Not supported for USB2.0 roothub\n",
2255
static struct hc_driver dummy_hcd = {
2256
.description = (char *) driver_name,
2257
.product_desc = "Dummy host controller",
2258
.hcd_priv_size = sizeof(struct dummy_hcd),
2260
.flags = HCD_USB3 | HCD_SHARED,
2262
.reset = dummy_setup,
2263
.start = dummy_start,
2266
.urb_enqueue = dummy_urb_enqueue,
2267
.urb_dequeue = dummy_urb_dequeue,
2269
.get_frame_number = dummy_h_get_frame,
2271
.hub_status_data = dummy_hub_status,
2272
.hub_control = dummy_hub_control,
2273
.bus_suspend = dummy_bus_suspend,
2274
.bus_resume = dummy_bus_resume,
2276
.alloc_streams = dummy_alloc_streams,
2277
.free_streams = dummy_free_streams,
2280
static int dummy_hcd_probe(struct platform_device *pdev)
2282
struct usb_hcd *hs_hcd;
2283
struct usb_hcd *ss_hcd;
2286
dev_info(&pdev->dev, "%s, driver " DRIVER_VERSION "\n", driver_desc);
2288
if (!mod_data.is_super_speed)
2289
dummy_hcd.flags = HCD_USB2;
2290
hs_hcd = usb_create_hcd(&dummy_hcd, &pdev->dev, dev_name(&pdev->dev));
2295
retval = usb_add_hcd(hs_hcd, 0, 0);
2297
usb_put_hcd(hs_hcd);
2301
if (mod_data.is_super_speed) {
2302
ss_hcd = usb_create_shared_hcd(&dummy_hcd, &pdev->dev,
2303
dev_name(&pdev->dev), hs_hcd);
2306
goto dealloc_usb2_hcd;
2309
retval = usb_add_hcd(ss_hcd, 0, 0);
2316
usb_put_hcd(ss_hcd);
2318
usb_put_hcd(hs_hcd);
2319
the_controller.hs_hcd = the_controller.ss_hcd = NULL;
2323
static int dummy_hcd_remove(struct platform_device *pdev)
2327
dum = (hcd_to_dummy_hcd(platform_get_drvdata(pdev)))->dum;
2330
usb_remove_hcd(dummy_hcd_to_hcd(dum->ss_hcd));
2331
usb_put_hcd(dummy_hcd_to_hcd(dum->ss_hcd));
2334
usb_remove_hcd(dummy_hcd_to_hcd(dum->hs_hcd));
2335
usb_put_hcd(dummy_hcd_to_hcd(dum->hs_hcd));
2337
the_controller.hs_hcd = NULL;
2338
the_controller.ss_hcd = NULL;
2343
static int dummy_hcd_suspend (struct platform_device *pdev, pm_message_t state)
2345
struct usb_hcd *hcd;
2346
struct dummy_hcd *dum_hcd;
2349
dev_dbg (&pdev->dev, "%s\n", __func__);
2351
hcd = platform_get_drvdata (pdev);
2352
dum_hcd = hcd_to_dummy_hcd(hcd);
2353
if (dum_hcd->rh_state == DUMMY_RH_RUNNING) {
2354
dev_warn(&pdev->dev, "Root hub isn't suspended!\n");
2357
clear_bit(HCD_FLAG_HW_ACCESSIBLE, &hcd->flags);
2361
static int dummy_hcd_resume (struct platform_device *pdev)
2363
struct usb_hcd *hcd;
2365
dev_dbg (&pdev->dev, "%s\n", __func__);
2367
hcd = platform_get_drvdata (pdev);
2368
set_bit(HCD_FLAG_HW_ACCESSIBLE, &hcd->flags);
2369
usb_hcd_poll_rh_status (hcd);
2373
static struct platform_driver dummy_hcd_driver = {
2374
.probe = dummy_hcd_probe,
2375
.remove = dummy_hcd_remove,
2376
.suspend = dummy_hcd_suspend,
2377
.resume = dummy_hcd_resume,
2379
.name = (char *) driver_name,
2380
.owner = THIS_MODULE,
2384
/*-------------------------------------------------------------------------*/
2386
static struct platform_device *the_udc_pdev;
2387
static struct platform_device *the_hcd_pdev;
2389
static int __init init (void)
2391
int retval = -ENOMEM;
2393
if (usb_disabled ())
2396
if (!mod_data.is_high_speed && mod_data.is_super_speed)
2399
the_hcd_pdev = platform_device_alloc(driver_name, -1);
2402
the_udc_pdev = platform_device_alloc(gadget_name, -1);
2406
retval = platform_driver_register(&dummy_hcd_driver);
2408
goto err_register_hcd_driver;
2409
retval = platform_driver_register(&dummy_udc_driver);
2411
goto err_register_udc_driver;
2413
retval = platform_device_add(the_hcd_pdev);
2416
if (!the_controller.hs_hcd ||
2417
(!the_controller.ss_hcd && mod_data.is_super_speed)) {
2419
* The hcd was added successfully but its probe function failed
2425
retval = platform_device_add(the_udc_pdev);
2428
if (!platform_get_drvdata(the_udc_pdev)) {
2430
* The udc was added successfully but its probe function failed
2439
platform_device_del(the_udc_pdev);
2441
platform_device_del(the_hcd_pdev);
2443
platform_driver_unregister(&dummy_udc_driver);
2444
err_register_udc_driver:
2445
platform_driver_unregister(&dummy_hcd_driver);
2446
err_register_hcd_driver:
2447
platform_device_put(the_udc_pdev);
2449
platform_device_put(the_hcd_pdev);
2454
static void __exit cleanup (void)
2456
platform_device_unregister(the_udc_pdev);
2457
platform_device_unregister(the_hcd_pdev);
2458
platform_driver_unregister(&dummy_udc_driver);
2459
platform_driver_unregister(&dummy_hcd_driver);
2461
module_exit (cleanup);