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