projects / deliverable / linux.git / blob
? search:


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