projects / linux-2.6-block.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
USB: dummy-hcd: fix "warn-unused-result" messages
[linux-2.6-block.git] / drivers / usb / gadget / dummy_hcd.c
CommitLineData
1da177e4
LT		 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#define DEBUG
38
1da177e4
LT		 39#include <linux/module.h>
40#include <linux/kernel.h>
41#include <linux/delay.h>
42#include <linux/ioport.h>
43#include <linux/sched.h>
44#include <linux/slab.h>
45#include <linux/smp_lock.h>
46#include <linux/errno.h>
47#include <linux/init.h>
48#include <linux/timer.h>
49#include <linux/list.h>
50#include <linux/interrupt.h>
d052d1be 51#include <linux/platform_device.h>
1da177e4
LT		 52#include <linux/usb.h>
53#include <linux/usb_gadget.h>
54
55#include <asm/byteorder.h>
56#include <asm/io.h>
57#include <asm/irq.h>
58#include <asm/system.h>
59#include <asm/unaligned.h>
60
61
62#include "../core/hcd.h"
63
64
65#define DRIVER_DESC "USB Host+Gadget Emulator"
391eca9d 66#define DRIVER_VERSION "02 May 2005"
1da177e4
LT		 67
68static const char driver_name [] = "dummy_hcd";
69static const char driver_desc [] = "USB Host+Gadget Emulator";
70
71static const char gadget_name [] = "dummy_udc";
72
73MODULE_DESCRIPTION (DRIVER_DESC);
74MODULE_AUTHOR ("David Brownell");
75MODULE_LICENSE ("GPL");
76
77/*-------------------------------------------------------------------------*/
78
79/* gadget side driver data structres */
80struct dummy_ep {
81 struct list_head queue;
82 unsigned long last_io; /* jiffies timestamp */
83 struct usb_gadget *gadget;
84 const struct usb_endpoint_descriptor *desc;
85 struct usb_ep ep;
86 unsigned halted : 1;
87 unsigned already_seen : 1;
88 unsigned setup_stage : 1;
89};
90
91struct dummy_request {
92 struct list_head queue; /* ep's requests */
93 struct usb_request req;
94};
95
96static inline struct dummy_ep *usb_ep_to_dummy_ep (struct usb_ep *_ep)
97{
98 return container_of (_ep, struct dummy_ep, ep);
99}
100
101static inline struct dummy_request *usb_request_to_dummy_request
102 (struct usb_request *_req)
103{
104 return container_of (_req, struct dummy_request, req);
105}
106
107/*-------------------------------------------------------------------------*/
108
109/*
110 * Every device has ep0 for control requests, plus up to 30 more endpoints,
111 * in one of two types:
112 *
113 * - Configurable: direction (in/out), type (bulk, iso, etc), and endpoint
114 * number can be changed. Names like "ep-a" are used for this type.
115 *
116 * - Fixed Function: in other cases. some characteristics may be mutable;
117 * that'd be hardware-specific. Names like "ep12out-bulk" are used.
118 *
119 * Gadget drivers are responsible for not setting up conflicting endpoint
120 * configurations, illegal or unsupported packet lengths, and so on.
121 */
122
123static const char ep0name [] = "ep0";
124
125static const char *const ep_name [] = {
126 ep0name, /* everyone has ep0 */
127
128 /* act like a net2280: high speed, six configurable endpoints */
129 "ep-a", "ep-b", "ep-c", "ep-d", "ep-e", "ep-f",
130
131 /* or like pxa250: fifteen fixed function endpoints */
132 "ep1in-bulk", "ep2out-bulk", "ep3in-iso", "ep4out-iso", "ep5in-int",
133 "ep6in-bulk", "ep7out-bulk", "ep8in-iso", "ep9out-iso", "ep10in-int",
134 "ep11in-bulk", "ep12out-bulk", "ep13in-iso", "ep14out-iso",
135 "ep15in-int",
136
137 /* or like sa1100: two fixed function endpoints */
138 "ep1out-bulk", "ep2in-bulk",
139};
52950ed4 140#define DUMMY_ENDPOINTS ARRAY_SIZE(ep_name)
1da177e4 141
d9b76251
AS		 142/*-------------------------------------------------------------------------*/
143
1da177e4
LT		 144#define FIFO_SIZE 64
145
146struct urbp {
147 struct urb *urb;
148 struct list_head urbp_list;
149};
150
391eca9d
AS		 151
152enum dummy_rh_state {
153 DUMMY_RH_RESET,
154 DUMMY_RH_SUSPENDED,
155 DUMMY_RH_RUNNING
156};
157
1da177e4
LT		 158struct dummy {
159 spinlock_t lock;
160
161 /*
162 * SLAVE/GADGET side support
163 */
164 struct dummy_ep ep [DUMMY_ENDPOINTS];
165 int address;
166 struct usb_gadget gadget;
167 struct usb_gadget_driver *driver;
168 struct dummy_request fifo_req;
169 u8 fifo_buf [FIFO_SIZE];
170 u16 devstatus;
391eca9d 171 unsigned udc_suspended:1;
f1c39fad
AS		 172 unsigned pullup:1;
173 unsigned active:1;
174 unsigned old_active:1;
1da177e4
LT		 175
176 /*
177 * MASTER/HOST side support
178 */
391eca9d 179 enum dummy_rh_state rh_state;
1da177e4
LT		 180 struct timer_list timer;
181 u32 port_status;
f1c39fad 182 u32 old_status;
1da177e4
LT		 183 unsigned resuming:1;
184 unsigned long re_timeout;
185
186 struct usb_device *udev;
187 struct list_head urbp_list;
188};
189
190static inline struct dummy *hcd_to_dummy (struct usb_hcd *hcd)
191{
192 return (struct dummy *) (hcd->hcd_priv);
193}
194
195static inline struct usb_hcd *dummy_to_hcd (struct dummy *dum)
196{
197 return container_of((void *) dum, struct usb_hcd, hcd_priv);
198}
199
200static inline struct device *dummy_dev (struct dummy *dum)
201{
202 return dummy_to_hcd(dum)->self.controller;
203}
204
d9b76251
AS		 205static inline struct device *udc_dev (struct dummy *dum)
206{
207 return dum->gadget.dev.parent;
208}
209
1da177e4
LT		 210static inline struct dummy *ep_to_dummy (struct dummy_ep *ep)
211{
212 return container_of (ep->gadget, struct dummy, gadget);
213}
214
215static inline struct dummy *gadget_to_dummy (struct usb_gadget *gadget)
216{
217 return container_of (gadget, struct dummy, gadget);
218}
219
220static inline struct dummy *gadget_dev_to_dummy (struct device *dev)
221{
222 return container_of (dev, struct dummy, gadget.dev);
223}
224
225static struct dummy *the_controller;
226
227/*-------------------------------------------------------------------------*/
228
f1c39fad
AS		 229/* SLAVE/GADGET SIDE UTILITY ROUTINES */
230
231/* called with spinlock held */
232static void nuke (struct dummy *dum, struct dummy_ep *ep)
233{
234 while (!list_empty (&ep->queue)) {
235 struct dummy_request *req;
236
237 req = list_entry (ep->queue.next, struct dummy_request, queue);
238 list_del_init (&req->queue);
239 req->req.status = -ESHUTDOWN;
240
241 spin_unlock (&dum->lock);
242 req->req.complete (&ep->ep, &req->req);
243 spin_lock (&dum->lock);
244 }
245}
246
247/* caller must hold lock */
248static void
249stop_activity (struct dummy *dum)
250{
251 struct dummy_ep *ep;
252
253 /* prevent any more requests */
254 dum->address = 0;
255
256 /* The timer is left running so that outstanding URBs can fail */
257
258 /* nuke any pending requests first, so driver i/o is quiesced */
259 list_for_each_entry (ep, &dum->gadget.ep_list, ep.ep_list)
260 nuke (dum, ep);
261
262 /* driver now does any non-usb quiescing necessary */
263}
264
265/* caller must hold lock */
266static void
267set_link_state (struct dummy *dum)
268{
269 dum->active = 0;
270 if ((dum->port_status & USB_PORT_STAT_POWER) == 0)
271 dum->port_status = 0;
391eca9d
AS		 272
273 /* UDC suspend must cause a disconnect */
274 else if (!dum->pullup || dum->udc_suspended) {
f1c39fad
AS		 275 dum->port_status &= ~(USB_PORT_STAT_CONNECTION |
276 USB_PORT_STAT_ENABLE |
277 USB_PORT_STAT_LOW_SPEED |
278 USB_PORT_STAT_HIGH_SPEED |
279 USB_PORT_STAT_SUSPEND);
280 if ((dum->old_status & USB_PORT_STAT_CONNECTION) != 0)
281 dum->port_status |= (USB_PORT_STAT_C_CONNECTION << 16);
282 } else {
283 dum->port_status |= USB_PORT_STAT_CONNECTION;
284 if ((dum->old_status & USB_PORT_STAT_CONNECTION) == 0)
285 dum->port_status |= (USB_PORT_STAT_C_CONNECTION << 16);
286 if ((dum->port_status & USB_PORT_STAT_ENABLE) == 0)
287 dum->port_status &= ~USB_PORT_STAT_SUSPEND;
391eca9d
AS		 288 else if ((dum->port_status & USB_PORT_STAT_SUSPEND) == 0 &&
289 dum->rh_state != DUMMY_RH_SUSPENDED)
f1c39fad
AS		 290 dum->active = 1;
291 }
292
293 if ((dum->port_status & USB_PORT_STAT_ENABLE) == 0 || dum->active)
294 dum->resuming = 0;
295
296 if ((dum->port_status & USB_PORT_STAT_CONNECTION) == 0 ||
297 (dum->port_status & USB_PORT_STAT_RESET) != 0) {
298 if ((dum->old_status & USB_PORT_STAT_CONNECTION) != 0 &&
299 (dum->old_status & USB_PORT_STAT_RESET) == 0 &&
300 dum->driver) {
301 stop_activity (dum);
302 spin_unlock (&dum->lock);
303 dum->driver->disconnect (&dum->gadget);
304 spin_lock (&dum->lock);
305 }
306 } else if (dum->active != dum->old_active) {
307 if (dum->old_active && dum->driver->suspend) {
308 spin_unlock (&dum->lock);
309 dum->driver->suspend (&dum->gadget);
310 spin_lock (&dum->lock);
311 } else if (!dum->old_active && dum->driver->resume) {
312 spin_unlock (&dum->lock);
313 dum->driver->resume (&dum->gadget);
314 spin_lock (&dum->lock);
315 }
316 }
317
318 dum->old_status = dum->port_status;
319 dum->old_active = dum->active;
320}
321
322/*-------------------------------------------------------------------------*/
323
1da177e4
LT		 324/* SLAVE/GADGET SIDE DRIVER
325 *
326 * This only tracks gadget state. All the work is done when the host
327 * side tries some (emulated) i/o operation. Real device controller
328 * drivers would do real i/o using dma, fifos, irqs, timers, etc.
329 */
330
331#define is_enabled(dum) \
332 (dum->port_status & USB_PORT_STAT_ENABLE)
333
334static int
335dummy_enable (struct usb_ep *_ep, const struct usb_endpoint_descriptor *desc)
336{
337 struct dummy *dum;
338 struct dummy_ep *ep;
339 unsigned max;
340 int retval;
341
342 ep = usb_ep_to_dummy_ep (_ep);
343 if (!_ep || !desc || ep->desc || _ep->name == ep0name
344 || desc->bDescriptorType != USB_DT_ENDPOINT)
345 return -EINVAL;
346 dum = ep_to_dummy (ep);
347 if (!dum->driver || !is_enabled (dum))
348 return -ESHUTDOWN;
349 max = le16_to_cpu(desc->wMaxPacketSize) & 0x3ff;
350
351 /* drivers must not request bad settings, since lower levels
352 * (hardware or its drivers) may not check. some endpoints
353 * can't do iso, many have maxpacket limitations, etc.
354 *
355 * since this "hardware" driver is here to help debugging, we
356 * have some extra sanity checks. (there could be more though,
357 * especially for "ep9out" style fixed function ones.)
358 */
359 retval = -EINVAL;
360 switch (desc->bmAttributes & 0x03) {
361 case USB_ENDPOINT_XFER_BULK:
362 if (strstr (ep->ep.name, "-iso")
363 || strstr (ep->ep.name, "-int")) {
364 goto done;
365 }
366 switch (dum->gadget.speed) {
367 case USB_SPEED_HIGH:
368 if (max == 512)
369 break;
370 /* conserve return statements */
371 default:
372 switch (max) {
373 case 8: case 16: case 32: case 64:
374 /* we'll fake any legal size */
375 break;
376 default:
377 case USB_SPEED_LOW:
378 goto done;
379 }
380 }
381 break;
382 case USB_ENDPOINT_XFER_INT:
383 if (strstr (ep->ep.name, "-iso")) /* bulk is ok */
384 goto done;
385 /* real hardware might not handle all packet sizes */
386 switch (dum->gadget.speed) {
387 case USB_SPEED_HIGH:
388 if (max <= 1024)
389 break;
390 /* save a return statement */
391 case USB_SPEED_FULL:
392 if (max <= 64)
393 break;
394 /* save a return statement */
395 default:
396 if (max <= 8)
397 break;
398 goto done;
399 }
400 break;
401 case USB_ENDPOINT_XFER_ISOC:
402 if (strstr (ep->ep.name, "-bulk")
403 || strstr (ep->ep.name, "-int"))
404 goto done;
405 /* real hardware might not handle all packet sizes */
406 switch (dum->gadget.speed) {
407 case USB_SPEED_HIGH:
408 if (max <= 1024)
409 break;
410 /* save a return statement */
411 case USB_SPEED_FULL:
412 if (max <= 1023)
413 break;
414 /* save a return statement */
415 default:
416 goto done;
417 }
418 break;
419 default:
420 /* few chips support control except on ep0 */
421 goto done;
422 }
423
424 _ep->maxpacket = max;
425 ep->desc = desc;
426
d9b76251 427 dev_dbg (udc_dev(dum), "enabled %s (ep%d%s-%s) maxpacket %d\n",
1da177e4
LT		 428 _ep->name,
429 desc->bEndpointAddress & 0x0f,
430 (desc->bEndpointAddress & USB_DIR_IN) ? "in" : "out",
431 ({ char *val;
432 switch (desc->bmAttributes & 0x03) {
433 case USB_ENDPOINT_XFER_BULK: val = "bulk"; break;
434 case USB_ENDPOINT_XFER_ISOC: val = "iso"; break;
435 case USB_ENDPOINT_XFER_INT: val = "intr"; break;
436 default: val = "ctrl"; break;
437 }; val; }),
438 max);
439
440 /* at this point real hardware should be NAKing transfers
441 * to that endpoint, until a buffer is queued to it.
442 */
443 retval = 0;
444done:
445 return retval;
446}
447
1da177e4
LT		 448static int dummy_disable (struct usb_ep *_ep)
449{
450 struct dummy_ep *ep;
451 struct dummy *dum;
452 unsigned long flags;
453 int retval;
454
455 ep = usb_ep_to_dummy_ep (_ep);
456 if (!_ep || !ep->desc || _ep->name == ep0name)
457 return -EINVAL;
458 dum = ep_to_dummy (ep);
459
460 spin_lock_irqsave (&dum->lock, flags);
461 ep->desc = NULL;
462 retval = 0;
463 nuke (dum, ep);
464 spin_unlock_irqrestore (&dum->lock, flags);
465
d9b76251 466 dev_dbg (udc_dev(dum), "disabled %s\n", _ep->name);
1da177e4
LT		 467 return retval;
468}
469
470static struct usb_request *
55016f10 471dummy_alloc_request (struct usb_ep *_ep, gfp_t mem_flags)
1da177e4
LT		 472{
473 struct dummy_ep *ep;
474 struct dummy_request *req;
475
476 if (!_ep)
477 return NULL;
478 ep = usb_ep_to_dummy_ep (_ep);
479
7039f422 480 req = kzalloc(sizeof(*req), mem_flags);
1da177e4
LT		 481 if (!req)
482 return NULL;
1da177e4
LT		 483 INIT_LIST_HEAD (&req->queue);
484 return &req->req;
485}
486
487static void
488dummy_free_request (struct usb_ep *_ep, struct usb_request *_req)
489{
490 struct dummy_ep *ep;
491 struct dummy_request *req;
492
493 ep = usb_ep_to_dummy_ep (_ep);
494 if (!ep || !_req || (!ep->desc && _ep->name != ep0name))
495 return;
496
497 req = usb_request_to_dummy_request (_req);
498 WARN_ON (!list_empty (&req->queue));
499 kfree (req);
500}
501
502static void *
503dummy_alloc_buffer (
504 struct usb_ep *_ep,
505 unsigned bytes,
506 dma_addr_t *dma,
55016f10 507 gfp_t mem_flags
1da177e4
LT		 508) {
509 char *retval;
510 struct dummy_ep *ep;
511 struct dummy *dum;
512
513 ep = usb_ep_to_dummy_ep (_ep);
514 dum = ep_to_dummy (ep);
515
516 if (!dum->driver)
517 return NULL;
518 retval = kmalloc (bytes, mem_flags);
519 *dma = (dma_addr_t) retval;
520 return retval;
521}
522
523static void
524dummy_free_buffer (
525 struct usb_ep *_ep,
526 void *buf,
527 dma_addr_t dma,
528 unsigned bytes
529) {
530 if (bytes)
531 kfree (buf);
532}
533
534static void
535fifo_complete (struct usb_ep *ep, struct usb_request *req)
536{
537}
538
539static int
5db539e4 540dummy_queue (struct usb_ep *_ep, struct usb_request *_req,
55016f10 541 gfp_t mem_flags)
1da177e4
LT		 542{
543 struct dummy_ep *ep;
544 struct dummy_request *req;
545 struct dummy *dum;
546 unsigned long flags;
547
548 req = usb_request_to_dummy_request (_req);
549 if (!_req || !list_empty (&req->queue) || !_req->complete)
550 return -EINVAL;
551
552 ep = usb_ep_to_dummy_ep (_ep);
553 if (!_ep || (!ep->desc && _ep->name != ep0name))
554 return -EINVAL;
555
556 dum = ep_to_dummy (ep);
557 if (!dum->driver || !is_enabled (dum))
558 return -ESHUTDOWN;
559
560#if 0
d9b76251 561 dev_dbg (udc_dev(dum), "ep %p queue req %p to %s, len %d buf %p\n",
1da177e4
LT		 562 ep, _req, _ep->name, _req->length, _req->buf);
563#endif
564
565 _req->status = -EINPROGRESS;
566 _req->actual = 0;
567 spin_lock_irqsave (&dum->lock, flags);
568
569 /* implement an emulated single-request FIFO */
570 if (ep->desc && (ep->desc->bEndpointAddress & USB_DIR_IN) &&
571 list_empty (&dum->fifo_req.queue) &&
572 list_empty (&ep->queue) &&
573 _req->length <= FIFO_SIZE) {
574 req = &dum->fifo_req;
575 req->req = *_req;
576 req->req.buf = dum->fifo_buf;
577 memcpy (dum->fifo_buf, _req->buf, _req->length);
578 req->req.context = dum;
579 req->req.complete = fifo_complete;
580
581 spin_unlock (&dum->lock);
582 _req->actual = _req->length;
583 _req->status = 0;
584 _req->complete (_ep, _req);
585 spin_lock (&dum->lock);
586 }
587 list_add_tail (&req->queue, &ep->queue);
588 spin_unlock_irqrestore (&dum->lock, flags);
589
590 /* real hardware would likely enable transfers here, in case
591 * it'd been left NAKing.
592 */
593 return 0;
594}
595
596static int dummy_dequeue (struct usb_ep *_ep, struct usb_request *_req)
597{
598 struct dummy_ep *ep;
599 struct dummy *dum;
600 int retval = -EINVAL;
601 unsigned long flags;
602 struct dummy_request *req = NULL;
603
604 if (!_ep || !_req)
605 return retval;
606 ep = usb_ep_to_dummy_ep (_ep);
607 dum = ep_to_dummy (ep);
608
609 if (!dum->driver)
610 return -ESHUTDOWN;
611
b4dbda1a
AS		 612 local_irq_save (flags);
613 spin_lock (&dum->lock);
1da177e4
LT		 614 list_for_each_entry (req, &ep->queue, queue) {
615 if (&req->req == _req) {
616 list_del_init (&req->queue);
617 _req->status = -ECONNRESET;
618 retval = 0;
619 break;
620 }
621 }
b4dbda1a 622 spin_unlock (&dum->lock);
1da177e4
LT		 623
624 if (retval == 0) {
d9b76251 625 dev_dbg (udc_dev(dum),
1da177e4
LT		 626 "dequeued req %p from %s, len %d buf %p\n",
627 req, _ep->name, _req->length, _req->buf);
628 _req->complete (_ep, _req);
629 }
b4dbda1a 630 local_irq_restore (flags);
1da177e4
LT		 631 return retval;
632}
633
634static int
635dummy_set_halt (struct usb_ep *_ep, int value)
636{
637 struct dummy_ep *ep;
638 struct dummy *dum;
639
640 if (!_ep)
641 return -EINVAL;
642 ep = usb_ep_to_dummy_ep (_ep);
643 dum = ep_to_dummy (ep);
644 if (!dum->driver)
645 return -ESHUTDOWN;
646 if (!value)
647 ep->halted = 0;
648 else if (ep->desc && (ep->desc->bEndpointAddress & USB_DIR_IN) &&
649 !list_empty (&ep->queue))
650 return -EAGAIN;
651 else
652 ep->halted = 1;
653 /* FIXME clear emulated data toggle too */
654 return 0;
655}
656
657static const struct usb_ep_ops dummy_ep_ops = {
658 .enable = dummy_enable,
659 .disable = dummy_disable,
660
661 .alloc_request = dummy_alloc_request,
662 .free_request = dummy_free_request,
663
664 .alloc_buffer = dummy_alloc_buffer,
665 .free_buffer = dummy_free_buffer,
666 /* map, unmap, ... eventually hook the "generic" dma calls */
667
668 .queue = dummy_queue,
669 .dequeue = dummy_dequeue,
670
671 .set_halt = dummy_set_halt,
672};
673
674/*-------------------------------------------------------------------------*/
675
676/* there are both host and device side versions of this call ... */
677static int dummy_g_get_frame (struct usb_gadget *_gadget)
678{
679 struct timeval tv;
680
681 do_gettimeofday (&tv);
682 return tv.tv_usec / 1000;
683}
684
685static int dummy_wakeup (struct usb_gadget *_gadget)
686{
687 struct dummy *dum;
688
689 dum = gadget_to_dummy (_gadget);
391eca9d 690 if (!(dum->devstatus & ( (1 << USB_DEVICE_B_HNP_ENABLE)
5742b0c9 691 | (1 << USB_DEVICE_REMOTE_WAKEUP))))
1da177e4 692 return -EINVAL;
391eca9d
AS		 693 if ((dum->port_status & USB_PORT_STAT_CONNECTION) == 0)
694 return -ENOLINK;
695 if ((dum->port_status & USB_PORT_STAT_SUSPEND) == 0 &&
696 dum->rh_state != DUMMY_RH_SUSPENDED)
697 return -EIO;
698
699 /* FIXME: What if the root hub is suspended but the port isn't? */
1da177e4
LT		 700
701 /* hub notices our request, issues downstream resume, etc */
702 dum->resuming = 1;
f1c39fad 703 dum->re_timeout = jiffies + msecs_to_jiffies(20);
685eb93f 704 mod_timer (&dummy_to_hcd (dum)->rh_timer, dum->re_timeout);
1da177e4
LT		 705 return 0;
706}
707
708static int dummy_set_selfpowered (struct usb_gadget *_gadget, int value)
709{
710 struct dummy *dum;
711
712 dum = gadget_to_dummy (_gadget);
713 if (value)
714 dum->devstatus |= (1 << USB_DEVICE_SELF_POWERED);
715 else
716 dum->devstatus &= ~(1 << USB_DEVICE_SELF_POWERED);
717 return 0;
718}
719
f1c39fad
AS		 720static int dummy_pullup (struct usb_gadget *_gadget, int value)
721{
722 struct dummy *dum;
723 unsigned long flags;
724
725 dum = gadget_to_dummy (_gadget);
726 spin_lock_irqsave (&dum->lock, flags);
727 dum->pullup = (value != 0);
728 set_link_state (dum);
729 spin_unlock_irqrestore (&dum->lock, flags);
685eb93f
AS		 730
731 usb_hcd_poll_rh_status (dummy_to_hcd (dum));
f1c39fad
AS		 732 return 0;
733}
734
1da177e4
LT		 735static const struct usb_gadget_ops dummy_ops = {
736 .get_frame = dummy_g_get_frame,
737 .wakeup = dummy_wakeup,
738 .set_selfpowered = dummy_set_selfpowered,
f1c39fad 739 .pullup = dummy_pullup,
1da177e4
LT		 740};
741
742/*-------------------------------------------------------------------------*/
743
744/* "function" sysfs attribute */
745static ssize_t
10523b3b 746show_function (struct device *dev, struct device_attribute *attr, char *buf)
1da177e4
LT		 747{
748 struct dummy *dum = gadget_dev_to_dummy (dev);
749
750 if (!dum->driver || !dum->driver->function)
751 return 0;
752 return scnprintf (buf, PAGE_SIZE, "%s\n", dum->driver->function);
753}
cc095b0b 754static DEVICE_ATTR (function, S_IRUGO, show_function, NULL);
1da177e4
LT		 755
756/*-------------------------------------------------------------------------*/
757
758/*
759 * Driver registration/unregistration.
760 *
761 * This is basically hardware-specific; there's usually only one real USB
762 * device (not host) controller since that's how USB devices are intended
763 * to work. So most implementations of these api calls will rely on the
764 * fact that only one driver will ever bind to the hardware. But curious
765 * hardware can be built with discrete components, so the gadget API doesn't
766 * require that assumption.
767 *
768 * For this emulator, it might be convenient to create a usb slave device
769 * for each driver that registers: just add to a big root hub.
770 */
771
1da177e4
LT		 772int
773usb_gadget_register_driver (struct usb_gadget_driver *driver)
774{
775 struct dummy *dum = the_controller;
776 int retval, i;
777
778 if (!dum)
779 return -EINVAL;
780 if (dum->driver)
781 return -EBUSY;
782 if (!driver->bind || !driver->unbind || !driver->setup
783 || driver->speed == USB_SPEED_UNKNOWN)
784 return -EINVAL;
785
786 /*
787 * SLAVE side init ... the layer above hardware, which
788 * can't enumerate without help from the driver we're binding.
789 */
5742b0c9 790
1da177e4 791 dum->devstatus = 0;
1da177e4
LT		 792
793 INIT_LIST_HEAD (&dum->gadget.ep_list);
794 for (i = 0; i < DUMMY_ENDPOINTS; i++) {
795 struct dummy_ep *ep = &dum->ep [i];
796
797 if (!ep_name [i])
798 break;
799 ep->ep.name = ep_name [i];
800 ep->ep.ops = &dummy_ep_ops;
801 list_add_tail (&ep->ep.ep_list, &dum->gadget.ep_list);
802 ep->halted = ep->already_seen = ep->setup_stage = 0;
803 ep->ep.maxpacket = ~0;
804 ep->last_io = jiffies;
805 ep->gadget = &dum->gadget;
806 ep->desc = NULL;
807 INIT_LIST_HEAD (&ep->queue);
808 }
809
810 dum->gadget.ep0 = &dum->ep [0].ep;
811 dum->ep [0].ep.maxpacket = 64;
812 list_del_init (&dum->ep [0].ep.ep_list);
813 INIT_LIST_HEAD(&dum->fifo_req.queue);
814
815 dum->driver = driver;
816 dum->gadget.dev.driver = &driver->driver;
d9b76251 817 dev_dbg (udc_dev(dum), "binding gadget driver '%s'\n",
1da177e4 818 driver->driver.name);
efd54a36
AS		 819 if ((retval = driver->bind (&dum->gadget)) != 0)
820 goto err_bind_gadget;
1da177e4 821
1da177e4 822 driver->driver.bus = dum->gadget.dev.parent->bus;
efd54a36
AS		 823 if ((retval = driver_register (&driver->driver)) != 0)
824 goto err_register;
825 if ((retval = device_bind_driver (&dum->gadget.dev)) != 0)
826 goto err_bind_driver;
1da177e4
LT		 827
828 /* khubd will enumerate this in a while */
f1c39fad
AS		 829 spin_lock_irq (&dum->lock);
830 dum->pullup = 1;
831 set_link_state (dum);
832 spin_unlock_irq (&dum->lock);
685eb93f
AS		 833
834 usb_hcd_poll_rh_status (dummy_to_hcd (dum));
1da177e4 835 return 0;
efd54a36
AS		 836
837err_bind_driver:
838 driver_unregister (&driver->driver);
839err_register:
840 driver->unbind (&dum->gadget);
841 spin_lock_irq (&dum->lock);
842 dum->pullup = 0;
843 set_link_state (dum);
844 spin_unlock_irq (&dum->lock);
845err_bind_gadget:
846 dum->driver = NULL;
847 dum->gadget.dev.driver = NULL;
848 return retval;
1da177e4
LT		 849}
850EXPORT_SYMBOL (usb_gadget_register_driver);
851
1da177e4
LT		 852int
853usb_gadget_unregister_driver (struct usb_gadget_driver *driver)
854{
855 struct dummy *dum = the_controller;
856 unsigned long flags;
857
858 if (!dum)
859 return -ENODEV;
860 if (!driver || driver != dum->driver)
861 return -EINVAL;
862
d9b76251 863 dev_dbg (udc_dev(dum), "unregister gadget driver '%s'\n",
1da177e4
LT		 864 driver->driver.name);
865
866 spin_lock_irqsave (&dum->lock, flags);
f1c39fad
AS		 867 dum->pullup = 0;
868 set_link_state (dum);
1da177e4
LT		 869 spin_unlock_irqrestore (&dum->lock, flags);
870
871 driver->unbind (&dum->gadget);
872 dum->driver = NULL;
873
874 device_release_driver (&dum->gadget.dev);
1da177e4
LT		 875 driver_unregister (&driver->driver);
876
f1c39fad
AS		 877 spin_lock_irqsave (&dum->lock, flags);
878 dum->pullup = 0;
879 set_link_state (dum);
880 spin_unlock_irqrestore (&dum->lock, flags);
881
685eb93f 882 usb_hcd_poll_rh_status (dummy_to_hcd (dum));
1da177e4
LT		 883 return 0;
884}
885EXPORT_SYMBOL (usb_gadget_unregister_driver);
886
887#undef is_enabled
888
cc095b0b
AS		 889/* just declare this in any driver that really need it */
890extern int net2280_set_fifo_mode (struct usb_gadget *gadget, int mode);
891
1da177e4
LT		 892int net2280_set_fifo_mode (struct usb_gadget *gadget, int mode)
893{
894 return -ENOSYS;
895}
896EXPORT_SYMBOL (net2280_set_fifo_mode);
897
d9b76251
AS		 898
899/* The gadget structure is stored inside the hcd structure and will be
900 * released along with it. */
901static void
902dummy_gadget_release (struct device *dev)
903{
d9b76251
AS		 904 struct dummy *dum = gadget_dev_to_dummy (dev);
905
17200583 906 usb_put_hcd (dummy_to_hcd (dum));
d9b76251
AS		 907}
908
8364d6b0 909static int dummy_udc_probe (struct platform_device *pdev)
d9b76251
AS		 910{
911 struct dummy *dum = the_controller;
912 int rc;
913
914 dum->gadget.name = gadget_name;
915 dum->gadget.ops = &dummy_ops;
916 dum->gadget.is_dualspeed = 1;
917
918 /* maybe claim OTG support, though we won't complete HNP */
919 dum->gadget.is_otg = (dummy_to_hcd(dum)->self.otg_port != 0);
920
921 strcpy (dum->gadget.dev.bus_id, "gadget");
8364d6b0 922 dum->gadget.dev.parent = &pdev->dev;
d9b76251
AS		 923 dum->gadget.dev.release = dummy_gadget_release;
924 rc = device_register (&dum->gadget.dev);
925 if (rc < 0)
926 return rc;
927
17200583 928 usb_get_hcd (dummy_to_hcd (dum));
d9b76251 929
8364d6b0 930 platform_set_drvdata (pdev, dum);
efd54a36
AS		 931 rc = device_create_file (&dum->gadget.dev, &dev_attr_function);
932 if (rc < 0)
933 device_unregister (&dum->gadget.dev);
d9b76251
AS		 934 return rc;
935}
936
8364d6b0 937static int dummy_udc_remove (struct platform_device *pdev)
d9b76251 938{
8364d6b0 939 struct dummy *dum = platform_get_drvdata (pdev);
d9b76251 940
8364d6b0 941 platform_set_drvdata (pdev, NULL);
d9b76251
AS		 942 device_remove_file (&dum->gadget.dev, &dev_attr_function);
943 device_unregister (&dum->gadget.dev);
944 return 0;
945}
946
8364d6b0 947static int dummy_udc_suspend (struct platform_device *pdev, pm_message_t state)
391eca9d 948{
8364d6b0 949 struct dummy *dum = platform_get_drvdata(pdev);
391eca9d 950
8364d6b0 951 dev_dbg (&pdev->dev, "%s\n", __FUNCTION__);
391eca9d
AS		 952 spin_lock_irq (&dum->lock);
953 dum->udc_suspended = 1;
954 set_link_state (dum);
955 spin_unlock_irq (&dum->lock);
956
8364d6b0 957 pdev->dev.power.power_state = state;
391eca9d
AS		 958 usb_hcd_poll_rh_status (dummy_to_hcd (dum));
959 return 0;
960}
961
8364d6b0 962static int dummy_udc_resume (struct platform_device *pdev)
391eca9d 963{
8364d6b0 964 struct dummy *dum = platform_get_drvdata(pdev);
391eca9d 965
8364d6b0 966 dev_dbg (&pdev->dev, "%s\n", __FUNCTION__);
391eca9d
AS		 967 spin_lock_irq (&dum->lock);
968 dum->udc_suspended = 0;
969 set_link_state (dum);
970 spin_unlock_irq (&dum->lock);
971
8364d6b0 972 pdev->dev.power.power_state = PMSG_ON;
391eca9d
AS		 973 usb_hcd_poll_rh_status (dummy_to_hcd (dum));
974 return 0;
975}
976
3ae5eaec 977static struct platform_driver dummy_udc_driver = {
d9b76251
AS		 978 .probe = dummy_udc_probe,
979 .remove = dummy_udc_remove,
391eca9d
AS		 980 .suspend = dummy_udc_suspend,
981 .resume = dummy_udc_resume,
3ae5eaec
RK		 982 .driver = {
983 .name = (char *) gadget_name,
984 .owner = THIS_MODULE,
985 },
d9b76251
AS		 986};
987
1da177e4
LT		 988/*-------------------------------------------------------------------------*/
989
990/* MASTER/HOST SIDE DRIVER
991 *
992 * this uses the hcd framework to hook up to host side drivers.
993 * its root hub will only have one device, otherwise it acts like
994 * a normal host controller.
995 *
996 * when urbs are queued, they're just stuck on a list that we
997 * scan in a timer callback. that callback connects writes from
998 * the host with reads from the device, and so on, based on the
999 * usb 2.0 rules.
1000 */
1001
1002static int dummy_urb_enqueue (
1003 struct usb_hcd *hcd,
1004 struct usb_host_endpoint *ep,
1005 struct urb *urb,
55016f10 1006 gfp_t mem_flags
1da177e4
LT		 1007) {
1008 struct dummy *dum;
1009 struct urbp *urbp;
1010 unsigned long flags;
1011
1012 if (!urb->transfer_buffer && urb->transfer_buffer_length)
1013 return -EINVAL;
1014
1015 urbp = kmalloc (sizeof *urbp, mem_flags);
1016 if (!urbp)
1017 return -ENOMEM;
1018 urbp->urb = urb;
1019
1020 dum = hcd_to_dummy (hcd);
1021 spin_lock_irqsave (&dum->lock, flags);
1022
1023 if (!dum->udev) {
1024 dum->udev = urb->dev;
1025 usb_get_dev (dum->udev);
1026 } else if (unlikely (dum->udev != urb->dev))
1027 dev_err (dummy_dev(dum), "usb_device address has changed!\n");
1028
1029 list_add_tail (&urbp->urbp_list, &dum->urbp_list);
1030 urb->hcpriv = urbp;
1031 if (usb_pipetype (urb->pipe) == PIPE_CONTROL)
1032 urb->error_count = 1; /* mark as a new urb */
1033
1034 /* kick the scheduler, it'll do the rest */
1035 if (!timer_pending (&dum->timer))
1036 mod_timer (&dum->timer, jiffies + 1);
1037
1038 spin_unlock_irqrestore (&dum->lock, flags);
1039 return 0;
1040}
1041
1042static int dummy_urb_dequeue (struct usb_hcd *hcd, struct urb *urb)
1043{
391eca9d
AS		 1044 struct dummy *dum;
1045 unsigned long flags;
1046
1047 /* giveback happens automatically in timer callback,
1048 * so make sure the callback happens */
1049 dum = hcd_to_dummy (hcd);
1050 spin_lock_irqsave (&dum->lock, flags);
1051 if (dum->rh_state != DUMMY_RH_RUNNING && !list_empty(&dum->urbp_list))
1052 mod_timer (&dum->timer, jiffies);
1053 spin_unlock_irqrestore (&dum->lock, flags);
1da177e4
LT		 1054 return 0;
1055}
1056
1057static void maybe_set_status (struct urb *urb, int status)
1058{
1059 spin_lock (&urb->lock);
1060 if (urb->status == -EINPROGRESS)
1061 urb->status = status;
1062 spin_unlock (&urb->lock);
1063}
1064
1065/* transfer up to a frame's worth; caller must own lock */
1066static int
1067transfer (struct dummy *dum, struct urb *urb, struct dummy_ep *ep, int limit)
1068{
1069 struct dummy_request *req;
1070
1071top:
1072 /* if there's no request queued, the device is NAKing; return */
1073 list_for_each_entry (req, &ep->queue, queue) {
1074 unsigned host_len, dev_len, len;
1075 int is_short, to_host;
1076 int rescan = 0;
1077
1078 /* 1..N packets of ep->ep.maxpacket each ... the last one
1079 * may be short (including zero length).
1080 *
1081 * writer can send a zlp explicitly (length 0) or implicitly
1082 * (length mod maxpacket zero, and 'zero' flag); they always
1083 * terminate reads.
1084 */
1085 host_len = urb->transfer_buffer_length - urb->actual_length;
1086 dev_len = req->req.length - req->req.actual;
1087 len = min (host_len, dev_len);
1088
1089 /* FIXME update emulated data toggle too */
1090
1091 to_host = usb_pipein (urb->pipe);
1092 if (unlikely (len == 0))
1093 is_short = 1;
1094 else {
1095 char *ubuf, *rbuf;
1096
1097 /* not enough bandwidth left? */
1098 if (limit < ep->ep.maxpacket && limit < len)
1099 break;
1100 len = min (len, (unsigned) limit);
1101 if (len == 0)
1102 break;
1103
1104 /* use an extra pass for the final short packet */
1105 if (len > ep->ep.maxpacket) {
1106 rescan = 1;
1107 len -= (len % ep->ep.maxpacket);
1108 }
1109 is_short = (len % ep->ep.maxpacket) != 0;
1110
1111 /* else transfer packet(s) */
1112 ubuf = urb->transfer_buffer + urb->actual_length;
1113 rbuf = req->req.buf + req->req.actual;
1114 if (to_host)
1115 memcpy (ubuf, rbuf, len);
1116 else
1117 memcpy (rbuf, ubuf, len);
1118 ep->last_io = jiffies;
1119
1120 limit -= len;
1121 urb->actual_length += len;
1122 req->req.actual += len;
1123 }
1124
1125 /* short packets terminate, maybe with overflow/underflow.
1126 * it's only really an error to write too much.
1127 *
1128 * partially filling a buffer optionally blocks queue advances
1129 * (so completion handlers can clean up the queue) but we don't
1130 * need to emulate such data-in-flight. so we only show part
1131 * of the URB_SHORT_NOT_OK effect: completion status.
1132 */
1133 if (is_short) {
1134 if (host_len == dev_len) {
1135 req->req.status = 0;
1136 maybe_set_status (urb, 0);
1137 } else if (to_host) {
1138 req->req.status = 0;
1139 if (dev_len > host_len)
1140 maybe_set_status (urb, -EOVERFLOW);
1141 else
1142 maybe_set_status (urb,
1143 (urb->transfer_flags
1144 & URB_SHORT_NOT_OK)
1145 ? -EREMOTEIO : 0);
1146 } else if (!to_host) {
1147 maybe_set_status (urb, 0);
1148 if (host_len > dev_len)
1149 req->req.status = -EOVERFLOW;
1150 else
1151 req->req.status = 0;
1152 }
1153
1154 /* many requests terminate without a short packet */
1155 } else {
1156 if (req->req.length == req->req.actual
1157 && !req->req.zero)
1158 req->req.status = 0;
1159 if (urb->transfer_buffer_length == urb->actual_length
1160 && !(urb->transfer_flags
1161 & URB_ZERO_PACKET)) {
1162 maybe_set_status (urb, 0);
1163 }
1164 }
1165
1166 /* device side completion --> continuable */
1167 if (req->req.status != -EINPROGRESS) {
1168 list_del_init (&req->queue);
1169
1170 spin_unlock (&dum->lock);
1171 req->req.complete (&ep->ep, &req->req);
1172 spin_lock (&dum->lock);
1173
1174 /* requests might have been unlinked... */
1175 rescan = 1;
1176 }
1177
1178 /* host side completion --> terminate */
1179 if (urb->status != -EINPROGRESS)
1180 break;
1181
1182 /* rescan to continue with any other queued i/o */
1183 if (rescan)
1184 goto top;
1185 }
1186 return limit;
1187}
1188
1189static int periodic_bytes (struct dummy *dum, struct dummy_ep *ep)
1190{
1191 int limit = ep->ep.maxpacket;
1192
1193 if (dum->gadget.speed == USB_SPEED_HIGH) {
1194 int tmp;
1195
1196 /* high bandwidth mode */
1197 tmp = le16_to_cpu(ep->desc->wMaxPacketSize);
1da177e4
LT		 1198 tmp = (tmp >> 11) & 0x03;
1199 tmp *= 8 /* applies to entire frame */;
1200 limit += limit * tmp;
1201 }
1202 return limit;
1203}
1204
1205#define is_active(dum) ((dum->port_status & \
1206 (USB_PORT_STAT_CONNECTION | USB_PORT_STAT_ENABLE | \
1207 USB_PORT_STAT_SUSPEND)) \
1208 == (USB_PORT_STAT_CONNECTION | USB_PORT_STAT_ENABLE))
1209
1210static struct dummy_ep *find_endpoint (struct dummy *dum, u8 address)
1211{
1212 int i;
1213
1214 if (!is_active (dum))
1215 return NULL;
1216 if ((address & ~USB_DIR_IN) == 0)
1217 return &dum->ep [0];
1218 for (i = 1; i < DUMMY_ENDPOINTS; i++) {
1219 struct dummy_ep *ep = &dum->ep [i];
1220
1221 if (!ep->desc)
1222 continue;
1223 if (ep->desc->bEndpointAddress == address)
1224 return ep;
1225 }
1226 return NULL;
1227}
1228
1229#undef is_active
1230
1231#define Dev_Request (USB_TYPE_STANDARD | USB_RECIP_DEVICE)
1232#define Dev_InRequest (Dev_Request | USB_DIR_IN)
1233#define Intf_Request (USB_TYPE_STANDARD | USB_RECIP_INTERFACE)
1234#define Intf_InRequest (Intf_Request | USB_DIR_IN)
1235#define Ep_Request (USB_TYPE_STANDARD | USB_RECIP_ENDPOINT)
1236#define Ep_InRequest (Ep_Request | USB_DIR_IN)
1237
1238/* drive both sides of the transfers; looks like irq handlers to
1239 * both drivers except the callbacks aren't in_irq().
1240 */
1241static void dummy_timer (unsigned long _dum)
1242{
1243 struct dummy *dum = (struct dummy *) _dum;
1244 struct urbp *urbp, *tmp;
1245 unsigned long flags;
1246 int limit, total;
1247 int i;
1248
1249 /* simplistic model for one frame's bandwidth */
1250 switch (dum->gadget.speed) {
1251 case USB_SPEED_LOW:
1252 total = 8/*bytes*/ * 12/*packets*/;
1253 break;
1254 case USB_SPEED_FULL:
1255 total = 64/*bytes*/ * 19/*packets*/;
1256 break;
1257 case USB_SPEED_HIGH:
1258 total = 512/*bytes*/ * 13/*packets*/ * 8/*uframes*/;
1259 break;
1260 default:
1261 dev_err (dummy_dev(dum), "bogus device speed\n");
1262 return;
1263 }
1264
1265 /* FIXME if HZ != 1000 this will probably misbehave ... */
1266
1267 /* look at each urb queued by the host side driver */
1268 spin_lock_irqsave (&dum->lock, flags);
1269
1270 if (!dum->udev) {
1271 dev_err (dummy_dev(dum),
1272 "timer fired with no URBs pending?\n");
1273 spin_unlock_irqrestore (&dum->lock, flags);
1274 return;
1275 }
1276
1277 for (i = 0; i < DUMMY_ENDPOINTS; i++) {
1278 if (!ep_name [i])
1279 break;
1280 dum->ep [i].already_seen = 0;
1281 }
1282
1283restart:
1284 list_for_each_entry_safe (urbp, tmp, &dum->urbp_list, urbp_list) {
1285 struct urb *urb;
1286 struct dummy_request *req;
1287 u8 address;
1288 struct dummy_ep *ep = NULL;
1289 int type;
1290
1291 urb = urbp->urb;
1292 if (urb->status != -EINPROGRESS) {
1293 /* likely it was just unlinked */
1294 goto return_urb;
391eca9d
AS		 1295 } else if (dum->rh_state != DUMMY_RH_RUNNING)
1296 continue;
1da177e4
LT		 1297 type = usb_pipetype (urb->pipe);
1298
1299 /* used up this frame's non-periodic bandwidth?
1300 * FIXME there's infinite bandwidth for control and
1301 * periodic transfers ... unrealistic.
1302 */
1303 if (total <= 0 && type == PIPE_BULK)
1304 continue;
1305
1306 /* find the gadget's ep for this request (if configured) */
1307 address = usb_pipeendpoint (urb->pipe);
1308 if (usb_pipein (urb->pipe))
1309 address |= USB_DIR_IN;
1310 ep = find_endpoint(dum, address);
1311 if (!ep) {
1312 /* set_configuration() disagreement */
1313 dev_dbg (dummy_dev(dum),
1314 "no ep configured for urb %p\n",
1315 urb);
1316 maybe_set_status (urb, -EPROTO);
1317 goto return_urb;
1318 }
1319
1320 if (ep->already_seen)
1321 continue;
1322 ep->already_seen = 1;
1323 if (ep == &dum->ep [0] && urb->error_count) {
1324 ep->setup_stage = 1; /* a new urb */
1325 urb->error_count = 0;
1326 }
1327 if (ep->halted && !ep->setup_stage) {
1328 /* NOTE: must not be iso! */
1329 dev_dbg (dummy_dev(dum), "ep %s halted, urb %p\n",
1330 ep->ep.name, urb);
1331 maybe_set_status (urb, -EPIPE);
1332 goto return_urb;
1333 }
1334 /* FIXME make sure both ends agree on maxpacket */
1335
1336 /* handle control requests */
1337 if (ep == &dum->ep [0] && ep->setup_stage) {
1338 struct usb_ctrlrequest setup;
1339 int value = 1;
1340 struct dummy_ep *ep2;
cc095b0b
AS		 1341 unsigned w_index;
1342 unsigned w_value;
1da177e4
LT		 1343
1344 setup = *(struct usb_ctrlrequest*) urb->setup_packet;
cc095b0b
AS		 1345 w_index = le16_to_cpu(setup.wIndex);
1346 w_value = le16_to_cpu(setup.wValue);
1347 if (le16_to_cpu(setup.wLength) !=
1348 urb->transfer_buffer_length) {
1da177e4
LT		 1349 maybe_set_status (urb, -EOVERFLOW);
1350 goto return_urb;
1351 }
1352
1353 /* paranoia, in case of stale queued data */
1354 list_for_each_entry (req, &ep->queue, queue) {
1355 list_del_init (&req->queue);
1356 req->req.status = -EOVERFLOW;
d9b76251 1357 dev_dbg (udc_dev(dum), "stale req = %p\n",
1da177e4
LT		 1358 req);
1359
1360 spin_unlock (&dum->lock);
1361 req->req.complete (&ep->ep, &req->req);
1362 spin_lock (&dum->lock);
1363 ep->already_seen = 0;
1364 goto restart;
1365 }
1366
1367 /* gadget driver never sees set_address or operations
1368 * on standard feature flags. some hardware doesn't
1369 * even expose them.
1370 */
1371 ep->last_io = jiffies;
1372 ep->setup_stage = 0;
1373 ep->halted = 0;
1374 switch (setup.bRequest) {
1375 case USB_REQ_SET_ADDRESS:
1376 if (setup.bRequestType != Dev_Request)
1377 break;
cc095b0b 1378 dum->address = w_value;
1da177e4 1379 maybe_set_status (urb, 0);
d9b76251 1380 dev_dbg (udc_dev(dum), "set_address = %d\n",
cc095b0b 1381 w_value);
1da177e4
LT		 1382 value = 0;
1383 break;
1384 case USB_REQ_SET_FEATURE:
1385 if (setup.bRequestType == Dev_Request) {
1386 value = 0;
cc095b0b 1387 switch (w_value) {
1da177e4
LT		 1388 case USB_DEVICE_REMOTE_WAKEUP:
1389 break;
5742b0c9
AS		 1390 case USB_DEVICE_B_HNP_ENABLE:
1391 dum->gadget.b_hnp_enable = 1;
1392 break;
1393 case USB_DEVICE_A_HNP_SUPPORT:
1394 dum->gadget.a_hnp_support = 1;
1395 break;
1396 case USB_DEVICE_A_ALT_HNP_SUPPORT:
1397 dum->gadget.a_alt_hnp_support
1398 = 1;
1399 break;
1da177e4
LT		 1400 default:
1401 value = -EOPNOTSUPP;
1402 }
1403 if (value == 0) {
1404 dum->devstatus |=
cc095b0b 1405 (1 << w_value);
1da177e4
LT		 1406 maybe_set_status (urb, 0);
1407 }
1408
1409 } else if (setup.bRequestType == Ep_Request) {
1410 // endpoint halt
cc095b0b 1411 ep2 = find_endpoint (dum, w_index);
1da177e4
LT		 1412 if (!ep2) {
1413 value = -EOPNOTSUPP;
1414 break;
1415 }
1416 ep2->halted = 1;
1417 value = 0;
1418 maybe_set_status (urb, 0);
1419 }
1420 break;
1421 case USB_REQ_CLEAR_FEATURE:
1422 if (setup.bRequestType == Dev_Request) {
cc095b0b 1423 switch (w_value) {
1da177e4
LT		 1424 case USB_DEVICE_REMOTE_WAKEUP:
1425 dum->devstatus &= ~(1 <<
1426 USB_DEVICE_REMOTE_WAKEUP);
1427 value = 0;
1428 maybe_set_status (urb, 0);
1429 break;
1430 default:
1431 value = -EOPNOTSUPP;
1432 break;
1433 }
1434 } else if (setup.bRequestType == Ep_Request) {
1435 // endpoint halt
cc095b0b 1436 ep2 = find_endpoint (dum, w_index);
1da177e4
LT		 1437 if (!ep2) {
1438 value = -EOPNOTSUPP;
1439 break;
1440 }
1441 ep2->halted = 0;
1442 value = 0;
1443 maybe_set_status (urb, 0);
1444 }
1445 break;
1446 case USB_REQ_GET_STATUS:
1447 if (setup.bRequestType == Dev_InRequest
1448 || setup.bRequestType
1449 == Intf_InRequest
1450 || setup.bRequestType
1451 == Ep_InRequest
1452 ) {
1453 char *buf;
1454
1455 // device: remote wakeup, selfpowered
1456 // interface: nothing
1457 // endpoint: halt
1458 buf = (char *)urb->transfer_buffer;
1459 if (urb->transfer_buffer_length > 0) {
1460 if (setup.bRequestType ==
1461 Ep_InRequest) {
cc095b0b 1462 ep2 = find_endpoint (dum, w_index);
1da177e4
LT		 1463 if (!ep2) {
1464 value = -EOPNOTSUPP;
1465 break;
1466 }
1467 buf [0] = ep2->halted;
1468 } else if (setup.bRequestType ==
1469 Dev_InRequest) {
1470 buf [0] = (u8)
1471 dum->devstatus;
1472 } else
1473 buf [0] = 0;
1474 }
1475 if (urb->transfer_buffer_length > 1)
1476 buf [1] = 0;
1477 urb->actual_length = min (2,
1478 urb->transfer_buffer_length);
1479 value = 0;
1480 maybe_set_status (urb, 0);
1481 }
1482 break;
1483 }
1484
1485 /* gadget driver handles all other requests. block
1486 * until setup() returns; no reentrancy issues etc.
1487 */
1488 if (value > 0) {
1489 spin_unlock (&dum->lock);
1490 value = dum->driver->setup (&dum->gadget,
1491 &setup);
1492 spin_lock (&dum->lock);
1493
1494 if (value >= 0) {
1495 /* no delays (max 64KB data stage) */
1496 limit = 64*1024;
1497 goto treat_control_like_bulk;
1498 }
1499 /* error, see below */
1500 }
1501
1502 if (value < 0) {
1503 if (value != -EOPNOTSUPP)
d9b76251 1504 dev_dbg (udc_dev(dum),
1da177e4
LT		 1505 "setup --> %d\n",
1506 value);
1507 maybe_set_status (urb, -EPIPE);
1508 urb->actual_length = 0;
1509 }
1510
1511 goto return_urb;
1512 }
1513
1514 /* non-control requests */
1515 limit = total;
1516 switch (usb_pipetype (urb->pipe)) {
1517 case PIPE_ISOCHRONOUS:
1518 /* FIXME is it urb->interval since the last xfer?
1519 * use urb->iso_frame_desc[i].
1520 * complete whether or not ep has requests queued.
1521 * report random errors, to debug drivers.
1522 */
1523 limit = max (limit, periodic_bytes (dum, ep));
1524 maybe_set_status (urb, -ENOSYS);
1525 break;
1526
1527 case PIPE_INTERRUPT:
1528 /* FIXME is it urb->interval since the last xfer?
1529 * this almost certainly polls too fast.
1530 */
1531 limit = max (limit, periodic_bytes (dum, ep));
1532 /* FALLTHROUGH */
1533
1534 // case PIPE_BULK: case PIPE_CONTROL:
1535 default:
1536 treat_control_like_bulk:
1537 ep->last_io = jiffies;
1538 total = transfer (dum, urb, ep, limit);
1539 break;
1540 }
1541
1542 /* incomplete transfer? */
1543 if (urb->status == -EINPROGRESS)
1544 continue;
1545
1546return_urb:
1547 urb->hcpriv = NULL;
1548 list_del (&urbp->urbp_list);
1549 kfree (urbp);
1550 if (ep)
1551 ep->already_seen = ep->setup_stage = 0;
1552
1553 spin_unlock (&dum->lock);
1554 usb_hcd_giveback_urb (dummy_to_hcd(dum), urb, NULL);
1555 spin_lock (&dum->lock);
1556
1557 goto restart;
1558 }
1559
391eca9d 1560 if (list_empty (&dum->urbp_list)) {
1da177e4
LT		 1561 usb_put_dev (dum->udev);
1562 dum->udev = NULL;
391eca9d
AS		 1563 } else if (dum->rh_state == DUMMY_RH_RUNNING) {
1564 /* want a 1 msec delay here */
1565 mod_timer (&dum->timer, jiffies + msecs_to_jiffies(1));
1da177e4
LT		 1566 }
1567
1568 spin_unlock_irqrestore (&dum->lock, flags);
1569}
1570
1571/*-------------------------------------------------------------------------*/
1572
1573#define PORT_C_MASK \
c2db8b5e
AS		 1574 ((USB_PORT_STAT_C_CONNECTION \
1575 | USB_PORT_STAT_C_ENABLE \
1576 | USB_PORT_STAT_C_SUSPEND \
1577 | USB_PORT_STAT_C_OVERCURRENT \
1578 | USB_PORT_STAT_C_RESET) << 16)
1da177e4
LT		 1579
1580static int dummy_hub_status (struct usb_hcd *hcd, char *buf)
1581{
1582 struct dummy *dum;
1583 unsigned long flags;
391eca9d 1584 int retval = 0;
1da177e4
LT		 1585
1586 dum = hcd_to_dummy (hcd);
1587
1588 spin_lock_irqsave (&dum->lock, flags);
3cf0a22e 1589 if (!test_bit(HCD_FLAG_HW_ACCESSIBLE, &hcd->flags))
391eca9d 1590 goto done;
f1c39fad
AS		 1591
1592 if (dum->resuming && time_after_eq (jiffies, dum->re_timeout)) {
1593 dum->port_status |= (USB_PORT_STAT_C_SUSPEND << 16);
1594 dum->port_status &= ~USB_PORT_STAT_SUSPEND;
1595 set_link_state (dum);
1596 }
1597
391eca9d 1598 if ((dum->port_status & PORT_C_MASK) != 0) {
1da177e4
LT		 1599 *buf = (1 << 1);
1600 dev_dbg (dummy_dev(dum), "port status 0x%08x has changes\n",
391eca9d 1601 dum->port_status);
1da177e4 1602 retval = 1;
391eca9d
AS		 1603 if (dum->rh_state == DUMMY_RH_SUSPENDED)
1604 usb_hcd_resume_root_hub (hcd);
1da177e4 1605 }
391eca9d 1606done:
1da177e4
LT		 1607 spin_unlock_irqrestore (&dum->lock, flags);
1608 return retval;
1609}
1610
1611static inline void
1612hub_descriptor (struct usb_hub_descriptor *desc)
1613{
1614 memset (desc, 0, sizeof *desc);
1615 desc->bDescriptorType = 0x29;
1616 desc->bDescLength = 9;
cc095b0b
AS		 1617 desc->wHubCharacteristics = (__force __u16)
1618 (__constant_cpu_to_le16 (0x0001));
1da177e4
LT		 1619 desc->bNbrPorts = 1;
1620 desc->bitmap [0] = 0xff;
1621 desc->bitmap [1] = 0xff;
1622}
1623
1624static int dummy_hub_control (
1625 struct usb_hcd *hcd,
1626 u16 typeReq,
1627 u16 wValue,
1628 u16 wIndex,
1629 char *buf,
1630 u16 wLength
1631) {
1632 struct dummy *dum;
1633 int retval = 0;
1634 unsigned long flags;
1635
3cf0a22e 1636 if (!test_bit(HCD_FLAG_HW_ACCESSIBLE, &hcd->flags))
391eca9d
AS		 1637 return -ETIMEDOUT;
1638
1da177e4
LT		 1639 dum = hcd_to_dummy (hcd);
1640 spin_lock_irqsave (&dum->lock, flags);
1641 switch (typeReq) {
1642 case ClearHubFeature:
1643 break;
1644 case ClearPortFeature:
1645 switch (wValue) {
1646 case USB_PORT_FEAT_SUSPEND:
c2db8b5e 1647 if (dum->port_status & USB_PORT_STAT_SUSPEND) {
1da177e4
LT		 1648 /* 20msec resume signaling */
1649 dum->resuming = 1;
1650 dum->re_timeout = jiffies +
f1c39fad 1651 msecs_to_jiffies(20);
1da177e4
LT		 1652 }
1653 break;
1654 case USB_PORT_FEAT_POWER:
f1c39fad
AS		 1655 if (dum->port_status & USB_PORT_STAT_POWER)
1656 dev_dbg (dummy_dev(dum), "power-off\n");
1657 /* FALLS THROUGH */
1da177e4
LT		 1658 default:
1659 dum->port_status &= ~(1 << wValue);
f1c39fad 1660 set_link_state (dum);
1da177e4
LT		 1661 }
1662 break;
1663 case GetHubDescriptor:
1664 hub_descriptor ((struct usb_hub_descriptor *) buf);
1665 break;
1666 case GetHubStatus:
cc095b0b 1667 *(__le32 *) buf = __constant_cpu_to_le32 (0);
1da177e4
LT		 1668 break;
1669 case GetPortStatus:
1670 if (wIndex != 1)
1671 retval = -EPIPE;
1672
1673 /* whoever resets or resumes must GetPortStatus to
1674 * complete it!!
1675 */
f1c39fad
AS		 1676 if (dum->resuming &&
1677 time_after_eq (jiffies, dum->re_timeout)) {
c2db8b5e
AS		 1678 dum->port_status |= (USB_PORT_STAT_C_SUSPEND << 16);
1679 dum->port_status &= ~USB_PORT_STAT_SUSPEND;
1da177e4 1680 }
f1c39fad
AS		 1681 if ((dum->port_status & USB_PORT_STAT_RESET) != 0 &&
1682 time_after_eq (jiffies, dum->re_timeout)) {
c2db8b5e
AS		 1683 dum->port_status |= (USB_PORT_STAT_C_RESET << 16);
1684 dum->port_status &= ~USB_PORT_STAT_RESET;
f1c39fad 1685 if (dum->pullup) {
1da177e4
LT		 1686 dum->port_status |= USB_PORT_STAT_ENABLE;
1687 /* give it the best speed we agree on */
1688 dum->gadget.speed = dum->driver->speed;
1689 dum->gadget.ep0->maxpacket = 64;
1690 switch (dum->gadget.speed) {
1691 case USB_SPEED_HIGH:
1692 dum->port_status |=
1693 USB_PORT_STAT_HIGH_SPEED;
1694 break;
1695 case USB_SPEED_LOW:
1696 dum->gadget.ep0->maxpacket = 8;
1697 dum->port_status |=
1698 USB_PORT_STAT_LOW_SPEED;
1699 break;
1700 default:
1701 dum->gadget.speed = USB_SPEED_FULL;
1702 break;
1703 }
1704 }
1705 }
f1c39fad 1706 set_link_state (dum);
cc095b0b
AS		 1707 ((__le16 *) buf)[0] = cpu_to_le16 (dum->port_status);
1708 ((__le16 *) buf)[1] = cpu_to_le16 (dum->port_status >> 16);
1da177e4
LT		 1709 break;
1710 case SetHubFeature:
1711 retval = -EPIPE;
1712 break;
1713 case SetPortFeature:
1714 switch (wValue) {
1715 case USB_PORT_FEAT_SUSPEND:
f1c39fad 1716 if (dum->active) {
c2db8b5e 1717 dum->port_status |= USB_PORT_STAT_SUSPEND;
f1c39fad
AS		 1718
1719 /* HNP would happen here; for now we
1720 * assume b_bus_req is always true.
1721 */
1722 set_link_state (dum);
1723 if (((1 << USB_DEVICE_B_HNP_ENABLE)
1724 & dum->devstatus) != 0)
1725 dev_dbg (dummy_dev(dum),
5742b0c9 1726 "no HNP yet!\n");
1da177e4
LT		 1727 }
1728 break;
f1c39fad
AS		 1729 case USB_PORT_FEAT_POWER:
1730 dum->port_status |= USB_PORT_STAT_POWER;
1731 set_link_state (dum);
1732 break;
1da177e4 1733 case USB_PORT_FEAT_RESET:
f1c39fad
AS		 1734 /* if it's already enabled, disable */
1735 dum->port_status &= ~(USB_PORT_STAT_ENABLE
1736 | USB_PORT_STAT_LOW_SPEED
1737 | USB_PORT_STAT_HIGH_SPEED);
391eca9d 1738 dum->devstatus = 0;
1da177e4
LT		 1739 /* 50msec reset signaling */
1740 dum->re_timeout = jiffies + msecs_to_jiffies(50);
f1c39fad 1741 /* FALLS THROUGH */
1da177e4 1742 default:
f1c39fad
AS		 1743 if ((dum->port_status & USB_PORT_STAT_POWER) != 0) {
1744 dum->port_status |= (1 << wValue);
1745 set_link_state (dum);
1746 }
1da177e4
LT		 1747 }
1748 break;
1749
1750 default:
1751 dev_dbg (dummy_dev(dum),
1752 "hub control req%04x v%04x i%04x l%d\n",
1753 typeReq, wValue, wIndex, wLength);
1754
1755 /* "protocol stall" on error */
1756 retval = -EPIPE;
1757 }
1758 spin_unlock_irqrestore (&dum->lock, flags);
685eb93f
AS		 1759
1760 if ((dum->port_status & PORT_C_MASK) != 0)
1761 usb_hcd_poll_rh_status (hcd);
1da177e4
LT		 1762 return retval;
1763}
1764
0c0382e3 1765static int dummy_bus_suspend (struct usb_hcd *hcd)
391eca9d
AS		 1766{
1767 struct dummy *dum = hcd_to_dummy (hcd);
1768
3cf0a22e
AS		 1769 dev_dbg (&hcd->self.root_hub->dev, "%s\n", __FUNCTION__);
1770
391eca9d
AS		 1771 spin_lock_irq (&dum->lock);
1772 dum->rh_state = DUMMY_RH_SUSPENDED;
1773 set_link_state (dum);
3cf0a22e 1774 hcd->state = HC_STATE_SUSPENDED;
391eca9d
AS		 1775 spin_unlock_irq (&dum->lock);
1776 return 0;
1777}
1778
0c0382e3 1779static int dummy_bus_resume (struct usb_hcd *hcd)
391eca9d
AS		 1780{
1781 struct dummy *dum = hcd_to_dummy (hcd);
3cf0a22e
AS		 1782 int rc = 0;
1783
1784 dev_dbg (&hcd->self.root_hub->dev, "%s\n", __FUNCTION__);
391eca9d
AS		 1785
1786 spin_lock_irq (&dum->lock);
3cf0a22e
AS		 1787 if (!test_bit(HCD_FLAG_HW_ACCESSIBLE, &hcd->flags)) {
1788 dev_warn (&hcd->self.root_hub->dev, "HC isn't running!\n");
1789 rc = -ENODEV;
1790 } else {
1791 dum->rh_state = DUMMY_RH_RUNNING;
1792 set_link_state (dum);
1793 if (!list_empty(&dum->urbp_list))
1794 mod_timer (&dum->timer, jiffies);
1795 hcd->state = HC_STATE_RUNNING;
1796 }
391eca9d 1797 spin_unlock_irq (&dum->lock);
3cf0a22e 1798 return rc;
391eca9d 1799}
1da177e4
LT		 1800
1801/*-------------------------------------------------------------------------*/
1802
1803static inline ssize_t
1804show_urb (char *buf, size_t size, struct urb *urb)
1805{
1806 int ep = usb_pipeendpoint (urb->pipe);
1807
1808 return snprintf (buf, size,
1809 "urb/%p %s ep%d%s%s len %d/%d\n",
1810 urb,
1811 ({ char *s;
1812 switch (urb->dev->speed) {
1813 case USB_SPEED_LOW: s = "ls"; break;
1814 case USB_SPEED_FULL: s = "fs"; break;
1815 case USB_SPEED_HIGH: s = "hs"; break;
1816 default: s = "?"; break;
1817 }; s; }),
1818 ep, ep ? (usb_pipein (urb->pipe) ? "in" : "out") : "",
1819 ({ char *s; \
1820 switch (usb_pipetype (urb->pipe)) { \
1821 case PIPE_CONTROL: s = ""; break; \
1822 case PIPE_BULK: s = "-bulk"; break; \
1823 case PIPE_INTERRUPT: s = "-int"; break; \
1824 default: s = "-iso"; break; \
1825 }; s;}),
1826 urb->actual_length, urb->transfer_buffer_length);
1827}
1828
1829static ssize_t
10523b3b 1830show_urbs (struct device *dev, struct device_attribute *attr, char *buf)
1da177e4
LT		 1831{
1832 struct usb_hcd *hcd = dev_get_drvdata (dev);
1833 struct dummy *dum = hcd_to_dummy (hcd);
1834 struct urbp *urbp;
1835 size_t size = 0;
1836 unsigned long flags;
1837
1838 spin_lock_irqsave (&dum->lock, flags);
1839 list_for_each_entry (urbp, &dum->urbp_list, urbp_list) {
1840 size_t temp;
1841
1842 temp = show_urb (buf, PAGE_SIZE - size, urbp->urb);
1843 buf += temp;
1844 size += temp;
1845 }
1846 spin_unlock_irqrestore (&dum->lock, flags);
1847
1848 return size;
1849}
1850static DEVICE_ATTR (urbs, S_IRUGO, show_urbs, NULL);
1851
1852static int dummy_start (struct usb_hcd *hcd)
1853{
1854 struct dummy *dum;
1da177e4
LT		 1855
1856 dum = hcd_to_dummy (hcd);
1857
1858 /*
1859 * MASTER side init ... we emulate a root hub that'll only ever
1860 * talk to one device (the slave side). Also appears in sysfs,
1861 * just like more familiar pci-based HCDs.
1862 */
1863 spin_lock_init (&dum->lock);
1864 init_timer (&dum->timer);
1865 dum->timer.function = dummy_timer;
1866 dum->timer.data = (unsigned long) dum;
391eca9d 1867 dum->rh_state = DUMMY_RH_RUNNING;
1da177e4
LT		 1868
1869 INIT_LIST_HEAD (&dum->urbp_list);
1870
bc96c0ad
AS		 1871 /* only show a low-power port: just 8mA */
1872 hcd->power_budget = 8;
1da177e4 1873 hcd->state = HC_STATE_RUNNING;
685eb93f 1874 hcd->uses_new_polling = 1;
1da177e4 1875
5742b0c9
AS		 1876#ifdef CONFIG_USB_OTG
1877 hcd->self.otg_port = 1;
1878#endif
1879
1da177e4 1880 /* FIXME 'urbs' should be a per-device thing, maybe in usbcore */
efd54a36 1881 return device_create_file (dummy_dev(dum), &dev_attr_urbs);
1da177e4
LT		 1882}
1883
1884static void dummy_stop (struct usb_hcd *hcd)
1885{
1886 struct dummy *dum;
1887
1888 dum = hcd_to_dummy (hcd);
1889
1890 device_remove_file (dummy_dev(dum), &dev_attr_urbs);
1da177e4 1891 usb_gadget_unregister_driver (dum->driver);
1da177e4
LT		 1892 dev_info (dummy_dev(dum), "stopped\n");
1893}
1894
1895/*-------------------------------------------------------------------------*/
1896
1897static int dummy_h_get_frame (struct usb_hcd *hcd)
1898{
1899 return dummy_g_get_frame (NULL);
1900}
1901
1902static const struct hc_driver dummy_hcd = {
1903 .description = (char *) driver_name,
1904 .product_desc = "Dummy host controller",
1905 .hcd_priv_size = sizeof(struct dummy),
1906
1907 .flags = HCD_USB2,
1908
1909 .start = dummy_start,
1910 .stop = dummy_stop,
1911
1912 .urb_enqueue = dummy_urb_enqueue,
1913 .urb_dequeue = dummy_urb_dequeue,
1914
1915 .get_frame_number = dummy_h_get_frame,
1916
1917 .hub_status_data = dummy_hub_status,
1918 .hub_control = dummy_hub_control,
0c0382e3
AS		 1919 .bus_suspend = dummy_bus_suspend,
1920 .bus_resume = dummy_bus_resume,
1da177e4
LT		 1921};
1922
8364d6b0 1923static int dummy_hcd_probe(struct platform_device *pdev)
1da177e4
LT		 1924{
1925 struct usb_hcd *hcd;
1926 int retval;
1927
8364d6b0 1928 dev_info(&pdev->dev, "%s, driver " DRIVER_VERSION "\n", driver_desc);
1da177e4 1929
8364d6b0 1930 hcd = usb_create_hcd(&dummy_hcd, &pdev->dev, pdev->dev.bus_id);
1da177e4
LT		 1931 if (!hcd)
1932 return -ENOMEM;
1933 the_controller = hcd_to_dummy (hcd);
1934
1935 retval = usb_add_hcd(hcd, 0, 0);
1936 if (retval != 0) {
1937 usb_put_hcd (hcd);
1938 the_controller = NULL;
1939 }
1940 return retval;
1941}
1942
8364d6b0 1943static int dummy_hcd_remove (struct platform_device *pdev)
1da177e4
LT		 1944{
1945 struct usb_hcd *hcd;
1946
8364d6b0 1947 hcd = platform_get_drvdata (pdev);
1da177e4
LT		 1948 usb_remove_hcd (hcd);
1949 usb_put_hcd (hcd);
1950 the_controller = NULL;
d9b76251 1951 return 0;
1da177e4
LT		 1952}
1953
8364d6b0 1954static int dummy_hcd_suspend (struct platform_device *pdev, pm_message_t state)
391eca9d
AS		 1955{
1956 struct usb_hcd *hcd;
3cf0a22e
AS		 1957 struct dummy *dum;
1958 int rc = 0;
391eca9d 1959
8364d6b0 1960 dev_dbg (&pdev->dev, "%s\n", __FUNCTION__);
391eca9d 1961
3cf0a22e
AS		 1962 hcd = platform_get_drvdata (pdev);
1963 dum = hcd_to_dummy (hcd);
1964 if (dum->rh_state == DUMMY_RH_RUNNING) {
1965 dev_warn(&pdev->dev, "Root hub isn't suspended!\n");
1966 rc = -EBUSY;
1967 } else
1968 clear_bit(HCD_FLAG_HW_ACCESSIBLE, &hcd->flags);
1969 return rc;
391eca9d
AS		 1970}
1971
8364d6b0 1972static int dummy_hcd_resume (struct platform_device *pdev)
391eca9d
AS		 1973{
1974 struct usb_hcd *hcd;
1975
8364d6b0 1976 dev_dbg (&pdev->dev, "%s\n", __FUNCTION__);
391eca9d 1977
3cf0a22e
AS		 1978 hcd = platform_get_drvdata (pdev);
1979 set_bit(HCD_FLAG_HW_ACCESSIBLE, &hcd->flags);
391eca9d
AS		 1980 usb_hcd_poll_rh_status (hcd);
1981 return 0;
1982}
1983
3ae5eaec 1984static struct platform_driver dummy_hcd_driver = {
d9b76251
AS		 1985 .probe = dummy_hcd_probe,
1986 .remove = dummy_hcd_remove,
391eca9d
AS		 1987 .suspend = dummy_hcd_suspend,
1988 .resume = dummy_hcd_resume,
3ae5eaec
RK		 1989 .driver = {
1990 .name = (char *) driver_name,
1991 .owner = THIS_MODULE,
1992 },
d9b76251 1993};
1da177e4 1994
d9b76251 1995/*-------------------------------------------------------------------------*/
1da177e4 1996
d9b76251
AS		 1997/* These don't need to do anything because the pdev structures are
1998 * statically allocated. */
1999static void
2000dummy_udc_release (struct device *dev) {}
1da177e4 2001
d9b76251
AS		 2002static void
2003dummy_hcd_release (struct device *dev) {}
2004
2005static struct platform_device the_udc_pdev = {
2006 .name = (char *) gadget_name,
2007 .id = -1,
2008 .dev = {
2009 .release = dummy_udc_release,
2010 },
2011};
1da177e4 2012
d9b76251
AS		 2013static struct platform_device the_hcd_pdev = {
2014 .name = (char *) driver_name,
2015 .id = -1,
2016 .dev = {
2017 .release = dummy_hcd_release,
2018 },
2019};
1da177e4
LT		 2020
2021static int __init init (void)
2022{
2023 int retval;
2024
2025 if (usb_disabled ())
2026 return -ENODEV;
d9b76251 2027
3ae5eaec 2028 retval = platform_driver_register (&dummy_hcd_driver);
d9b76251 2029 if (retval < 0)
1da177e4 2030 return retval;
d9b76251 2031
3ae5eaec 2032 retval = platform_driver_register (&dummy_udc_driver);
d9b76251
AS		 2033 if (retval < 0)
2034 goto err_register_udc_driver;
2035
2036 retval = platform_device_register (&the_hcd_pdev);
2037 if (retval < 0)
2038 goto err_register_hcd;
2039
2040 retval = platform_device_register (&the_udc_pdev);
2041 if (retval < 0)
2042 goto err_register_udc;
2043 return retval;
2044
2045err_register_udc:
2046 platform_device_unregister (&the_hcd_pdev);
2047err_register_hcd:
3ae5eaec 2048 platform_driver_unregister (&dummy_udc_driver);
d9b76251 2049err_register_udc_driver:
3ae5eaec 2050 platform_driver_unregister (&dummy_hcd_driver);
1da177e4
LT		 2051 return retval;
2052}
2053module_init (init);
2054
2055static void __exit cleanup (void)
2056{
d9b76251
AS		 2057 platform_device_unregister (&the_udc_pdev);
2058 platform_device_unregister (&the_hcd_pdev);
3ae5eaec
RK		 2059 platform_driver_unregister (&dummy_udc_driver);
2060 platform_driver_unregister (&dummy_hcd_driver);
1da177e4
LT		 2061}
2062module_exit (cleanup);
Linux 6.x block layer and io_uring tree(s)