blob: 0cb032526ca2f5318979df79f28c48780341192e [file] [log] [blame]
Linus Torvalds1da177e2005-04-16 15:20:36 -07001/*
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
Linus Torvalds1da177e2005-04-16 15:20:36 -070037#include <linux/module.h>
38#include <linux/kernel.h>
39#include <linux/delay.h>
40#include <linux/ioport.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070041#include <linux/slab.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070042#include <linux/errno.h>
43#include <linux/init.h>
44#include <linux/timer.h>
45#include <linux/list.h>
46#include <linux/interrupt.h>
Russell Kingd052d1b2005-10-29 19:07:23 +010047#include <linux/platform_device.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070048#include <linux/usb.h>
49#include <linux/usb_gadget.h>
50
51#include <asm/byteorder.h>
52#include <asm/io.h>
53#include <asm/irq.h>
54#include <asm/system.h>
55#include <asm/unaligned.h>
56
57
58#include "../core/hcd.h"
59
60
61#define DRIVER_DESC "USB Host+Gadget Emulator"
Alan Stern391eca92005-05-10 15:34:16 -040062#define DRIVER_VERSION "02 May 2005"
Linus Torvalds1da177e2005-04-16 15:20:36 -070063
64static const char driver_name [] = "dummy_hcd";
65static const char driver_desc [] = "USB Host+Gadget Emulator";
66
67static const char gadget_name [] = "dummy_udc";
68
69MODULE_DESCRIPTION (DRIVER_DESC);
70MODULE_AUTHOR ("David Brownell");
71MODULE_LICENSE ("GPL");
72
73/*-------------------------------------------------------------------------*/
74
75/* gadget side driver data structres */
76struct dummy_ep {
77 struct list_head queue;
78 unsigned long last_io; /* jiffies timestamp */
79 struct usb_gadget *gadget;
80 const struct usb_endpoint_descriptor *desc;
81 struct usb_ep ep;
82 unsigned halted : 1;
83 unsigned already_seen : 1;
84 unsigned setup_stage : 1;
85};
86
87struct dummy_request {
88 struct list_head queue; /* ep's requests */
89 struct usb_request req;
90};
91
92static inline struct dummy_ep *usb_ep_to_dummy_ep (struct usb_ep *_ep)
93{
94 return container_of (_ep, struct dummy_ep, ep);
95}
96
97static inline struct dummy_request *usb_request_to_dummy_request
98 (struct usb_request *_req)
99{
100 return container_of (_req, struct dummy_request, req);
101}
102
103/*-------------------------------------------------------------------------*/
104
105/*
106 * Every device has ep0 for control requests, plus up to 30 more endpoints,
107 * in one of two types:
108 *
109 * - Configurable: direction (in/out), type (bulk, iso, etc), and endpoint
110 * number can be changed. Names like "ep-a" are used for this type.
111 *
112 * - Fixed Function: in other cases. some characteristics may be mutable;
113 * that'd be hardware-specific. Names like "ep12out-bulk" are used.
114 *
115 * Gadget drivers are responsible for not setting up conflicting endpoint
116 * configurations, illegal or unsupported packet lengths, and so on.
117 */
118
119static const char ep0name [] = "ep0";
120
121static const char *const ep_name [] = {
122 ep0name, /* everyone has ep0 */
123
124 /* act like a net2280: high speed, six configurable endpoints */
125 "ep-a", "ep-b", "ep-c", "ep-d", "ep-e", "ep-f",
126
127 /* or like pxa250: fifteen fixed function endpoints */
128 "ep1in-bulk", "ep2out-bulk", "ep3in-iso", "ep4out-iso", "ep5in-int",
129 "ep6in-bulk", "ep7out-bulk", "ep8in-iso", "ep9out-iso", "ep10in-int",
130 "ep11in-bulk", "ep12out-bulk", "ep13in-iso", "ep14out-iso",
131 "ep15in-int",
132
133 /* or like sa1100: two fixed function endpoints */
134 "ep1out-bulk", "ep2in-bulk",
135};
Tobias Klauser52950ed2005-12-11 16:20:08 +0100136#define DUMMY_ENDPOINTS ARRAY_SIZE(ep_name)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700137
Alan Sternd9b76252005-05-03 16:15:43 -0400138/*-------------------------------------------------------------------------*/
139
Linus Torvalds1da177e2005-04-16 15:20:36 -0700140#define FIFO_SIZE 64
141
142struct urbp {
143 struct urb *urb;
144 struct list_head urbp_list;
145};
146
Alan Stern391eca92005-05-10 15:34:16 -0400147
148enum dummy_rh_state {
149 DUMMY_RH_RESET,
150 DUMMY_RH_SUSPENDED,
151 DUMMY_RH_RUNNING
152};
153
Linus Torvalds1da177e2005-04-16 15:20:36 -0700154struct dummy {
155 spinlock_t lock;
156
157 /*
158 * SLAVE/GADGET side support
159 */
160 struct dummy_ep ep [DUMMY_ENDPOINTS];
161 int address;
162 struct usb_gadget gadget;
163 struct usb_gadget_driver *driver;
164 struct dummy_request fifo_req;
165 u8 fifo_buf [FIFO_SIZE];
166 u16 devstatus;
Alan Stern391eca92005-05-10 15:34:16 -0400167 unsigned udc_suspended:1;
Alan Sternf1c39fa2005-05-03 16:24:04 -0400168 unsigned pullup:1;
169 unsigned active:1;
170 unsigned old_active:1;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700171
172 /*
173 * MASTER/HOST side support
174 */
Alan Stern391eca92005-05-10 15:34:16 -0400175 enum dummy_rh_state rh_state;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700176 struct timer_list timer;
177 u32 port_status;
Alan Sternf1c39fa2005-05-03 16:24:04 -0400178 u32 old_status;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700179 unsigned resuming:1;
180 unsigned long re_timeout;
181
182 struct usb_device *udev;
183 struct list_head urbp_list;
184};
185
186static inline struct dummy *hcd_to_dummy (struct usb_hcd *hcd)
187{
188 return (struct dummy *) (hcd->hcd_priv);
189}
190
191static inline struct usb_hcd *dummy_to_hcd (struct dummy *dum)
192{
193 return container_of((void *) dum, struct usb_hcd, hcd_priv);
194}
195
196static inline struct device *dummy_dev (struct dummy *dum)
197{
198 return dummy_to_hcd(dum)->self.controller;
199}
200
Alan Sternd9b76252005-05-03 16:15:43 -0400201static inline struct device *udc_dev (struct dummy *dum)
202{
203 return dum->gadget.dev.parent;
204}
205
Linus Torvalds1da177e2005-04-16 15:20:36 -0700206static inline struct dummy *ep_to_dummy (struct dummy_ep *ep)
207{
208 return container_of (ep->gadget, struct dummy, gadget);
209}
210
211static inline struct dummy *gadget_to_dummy (struct usb_gadget *gadget)
212{
213 return container_of (gadget, struct dummy, gadget);
214}
215
216static inline struct dummy *gadget_dev_to_dummy (struct device *dev)
217{
218 return container_of (dev, struct dummy, gadget.dev);
219}
220
221static struct dummy *the_controller;
222
223/*-------------------------------------------------------------------------*/
224
Alan Sternf1c39fa2005-05-03 16:24:04 -0400225/* SLAVE/GADGET SIDE UTILITY ROUTINES */
226
227/* called with spinlock held */
228static void nuke (struct dummy *dum, struct dummy_ep *ep)
229{
230 while (!list_empty (&ep->queue)) {
231 struct dummy_request *req;
232
233 req = list_entry (ep->queue.next, struct dummy_request, queue);
234 list_del_init (&req->queue);
235 req->req.status = -ESHUTDOWN;
236
237 spin_unlock (&dum->lock);
238 req->req.complete (&ep->ep, &req->req);
239 spin_lock (&dum->lock);
240 }
241}
242
243/* caller must hold lock */
244static void
245stop_activity (struct dummy *dum)
246{
247 struct dummy_ep *ep;
248
249 /* prevent any more requests */
250 dum->address = 0;
251
252 /* The timer is left running so that outstanding URBs can fail */
253
254 /* nuke any pending requests first, so driver i/o is quiesced */
255 list_for_each_entry (ep, &dum->gadget.ep_list, ep.ep_list)
256 nuke (dum, ep);
257
258 /* driver now does any non-usb quiescing necessary */
259}
260
261/* caller must hold lock */
262static void
263set_link_state (struct dummy *dum)
264{
265 dum->active = 0;
266 if ((dum->port_status & USB_PORT_STAT_POWER) == 0)
267 dum->port_status = 0;
Alan Stern391eca92005-05-10 15:34:16 -0400268
269 /* UDC suspend must cause a disconnect */
270 else if (!dum->pullup || dum->udc_suspended) {
Alan Sternf1c39fa2005-05-03 16:24:04 -0400271 dum->port_status &= ~(USB_PORT_STAT_CONNECTION |
272 USB_PORT_STAT_ENABLE |
273 USB_PORT_STAT_LOW_SPEED |
274 USB_PORT_STAT_HIGH_SPEED |
275 USB_PORT_STAT_SUSPEND);
276 if ((dum->old_status & USB_PORT_STAT_CONNECTION) != 0)
277 dum->port_status |= (USB_PORT_STAT_C_CONNECTION << 16);
278 } else {
279 dum->port_status |= USB_PORT_STAT_CONNECTION;
280 if ((dum->old_status & USB_PORT_STAT_CONNECTION) == 0)
281 dum->port_status |= (USB_PORT_STAT_C_CONNECTION << 16);
282 if ((dum->port_status & USB_PORT_STAT_ENABLE) == 0)
283 dum->port_status &= ~USB_PORT_STAT_SUSPEND;
Alan Stern391eca92005-05-10 15:34:16 -0400284 else if ((dum->port_status & USB_PORT_STAT_SUSPEND) == 0 &&
285 dum->rh_state != DUMMY_RH_SUSPENDED)
Alan Sternf1c39fa2005-05-03 16:24:04 -0400286 dum->active = 1;
287 }
288
289 if ((dum->port_status & USB_PORT_STAT_ENABLE) == 0 || dum->active)
290 dum->resuming = 0;
291
292 if ((dum->port_status & USB_PORT_STAT_CONNECTION) == 0 ||
293 (dum->port_status & USB_PORT_STAT_RESET) != 0) {
294 if ((dum->old_status & USB_PORT_STAT_CONNECTION) != 0 &&
295 (dum->old_status & USB_PORT_STAT_RESET) == 0 &&
296 dum->driver) {
297 stop_activity (dum);
298 spin_unlock (&dum->lock);
299 dum->driver->disconnect (&dum->gadget);
300 spin_lock (&dum->lock);
301 }
302 } else if (dum->active != dum->old_active) {
303 if (dum->old_active && dum->driver->suspend) {
304 spin_unlock (&dum->lock);
305 dum->driver->suspend (&dum->gadget);
306 spin_lock (&dum->lock);
307 } else if (!dum->old_active && dum->driver->resume) {
308 spin_unlock (&dum->lock);
309 dum->driver->resume (&dum->gadget);
310 spin_lock (&dum->lock);
311 }
312 }
313
314 dum->old_status = dum->port_status;
315 dum->old_active = dum->active;
316}
317
318/*-------------------------------------------------------------------------*/
319
Linus Torvalds1da177e2005-04-16 15:20:36 -0700320/* SLAVE/GADGET SIDE DRIVER
321 *
322 * This only tracks gadget state. All the work is done when the host
323 * side tries some (emulated) i/o operation. Real device controller
324 * drivers would do real i/o using dma, fifos, irqs, timers, etc.
325 */
326
327#define is_enabled(dum) \
328 (dum->port_status & USB_PORT_STAT_ENABLE)
329
330static int
331dummy_enable (struct usb_ep *_ep, const struct usb_endpoint_descriptor *desc)
332{
333 struct dummy *dum;
334 struct dummy_ep *ep;
335 unsigned max;
336 int retval;
337
338 ep = usb_ep_to_dummy_ep (_ep);
339 if (!_ep || !desc || ep->desc || _ep->name == ep0name
340 || desc->bDescriptorType != USB_DT_ENDPOINT)
341 return -EINVAL;
342 dum = ep_to_dummy (ep);
343 if (!dum->driver || !is_enabled (dum))
344 return -ESHUTDOWN;
345 max = le16_to_cpu(desc->wMaxPacketSize) & 0x3ff;
346
347 /* drivers must not request bad settings, since lower levels
348 * (hardware or its drivers) may not check. some endpoints
349 * can't do iso, many have maxpacket limitations, etc.
350 *
351 * since this "hardware" driver is here to help debugging, we
352 * have some extra sanity checks. (there could be more though,
353 * especially for "ep9out" style fixed function ones.)
354 */
355 retval = -EINVAL;
356 switch (desc->bmAttributes & 0x03) {
357 case USB_ENDPOINT_XFER_BULK:
358 if (strstr (ep->ep.name, "-iso")
359 || strstr (ep->ep.name, "-int")) {
360 goto done;
361 }
362 switch (dum->gadget.speed) {
363 case USB_SPEED_HIGH:
364 if (max == 512)
365 break;
366 /* conserve return statements */
367 default:
368 switch (max) {
369 case 8: case 16: case 32: case 64:
370 /* we'll fake any legal size */
371 break;
372 default:
373 case USB_SPEED_LOW:
374 goto done;
375 }
376 }
377 break;
378 case USB_ENDPOINT_XFER_INT:
379 if (strstr (ep->ep.name, "-iso")) /* bulk is ok */
380 goto done;
381 /* real hardware might not handle all packet sizes */
382 switch (dum->gadget.speed) {
383 case USB_SPEED_HIGH:
384 if (max <= 1024)
385 break;
386 /* save a return statement */
387 case USB_SPEED_FULL:
388 if (max <= 64)
389 break;
390 /* save a return statement */
391 default:
392 if (max <= 8)
393 break;
394 goto done;
395 }
396 break;
397 case USB_ENDPOINT_XFER_ISOC:
398 if (strstr (ep->ep.name, "-bulk")
399 || strstr (ep->ep.name, "-int"))
400 goto done;
401 /* real hardware might not handle all packet sizes */
402 switch (dum->gadget.speed) {
403 case USB_SPEED_HIGH:
404 if (max <= 1024)
405 break;
406 /* save a return statement */
407 case USB_SPEED_FULL:
408 if (max <= 1023)
409 break;
410 /* save a return statement */
411 default:
412 goto done;
413 }
414 break;
415 default:
416 /* few chips support control except on ep0 */
417 goto done;
418 }
419
420 _ep->maxpacket = max;
421 ep->desc = desc;
422
Alan Sternd9b76252005-05-03 16:15:43 -0400423 dev_dbg (udc_dev(dum), "enabled %s (ep%d%s-%s) maxpacket %d\n",
Linus Torvalds1da177e2005-04-16 15:20:36 -0700424 _ep->name,
425 desc->bEndpointAddress & 0x0f,
426 (desc->bEndpointAddress & USB_DIR_IN) ? "in" : "out",
427 ({ char *val;
428 switch (desc->bmAttributes & 0x03) {
429 case USB_ENDPOINT_XFER_BULK: val = "bulk"; break;
430 case USB_ENDPOINT_XFER_ISOC: val = "iso"; break;
431 case USB_ENDPOINT_XFER_INT: val = "intr"; break;
432 default: val = "ctrl"; break;
433 }; val; }),
434 max);
435
436 /* at this point real hardware should be NAKing transfers
437 * to that endpoint, until a buffer is queued to it.
438 */
439 retval = 0;
440done:
441 return retval;
442}
443
Linus Torvalds1da177e2005-04-16 15:20:36 -0700444static int dummy_disable (struct usb_ep *_ep)
445{
446 struct dummy_ep *ep;
447 struct dummy *dum;
448 unsigned long flags;
449 int retval;
450
451 ep = usb_ep_to_dummy_ep (_ep);
452 if (!_ep || !ep->desc || _ep->name == ep0name)
453 return -EINVAL;
454 dum = ep_to_dummy (ep);
455
456 spin_lock_irqsave (&dum->lock, flags);
457 ep->desc = NULL;
458 retval = 0;
459 nuke (dum, ep);
460 spin_unlock_irqrestore (&dum->lock, flags);
461
Alan Sternd9b76252005-05-03 16:15:43 -0400462 dev_dbg (udc_dev(dum), "disabled %s\n", _ep->name);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700463 return retval;
464}
465
466static struct usb_request *
Al Viro55016f12005-10-21 03:21:58 -0400467dummy_alloc_request (struct usb_ep *_ep, gfp_t mem_flags)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700468{
469 struct dummy_ep *ep;
470 struct dummy_request *req;
471
472 if (!_ep)
473 return NULL;
474 ep = usb_ep_to_dummy_ep (_ep);
475
Eric Sesterhenn7039f422006-02-27 13:34:10 -0800476 req = kzalloc(sizeof(*req), mem_flags);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700477 if (!req)
478 return NULL;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700479 INIT_LIST_HEAD (&req->queue);
480 return &req->req;
481}
482
483static void
484dummy_free_request (struct usb_ep *_ep, struct usb_request *_req)
485{
486 struct dummy_ep *ep;
487 struct dummy_request *req;
488
489 ep = usb_ep_to_dummy_ep (_ep);
490 if (!ep || !_req || (!ep->desc && _ep->name != ep0name))
491 return;
492
493 req = usb_request_to_dummy_request (_req);
494 WARN_ON (!list_empty (&req->queue));
495 kfree (req);
496}
497
Linus Torvalds1da177e2005-04-16 15:20:36 -0700498static void
499fifo_complete (struct usb_ep *ep, struct usb_request *req)
500{
501}
502
503static int
Olav Kongas5db539e2005-06-23 20:25:36 +0300504dummy_queue (struct usb_ep *_ep, struct usb_request *_req,
Al Viro55016f12005-10-21 03:21:58 -0400505 gfp_t mem_flags)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700506{
507 struct dummy_ep *ep;
508 struct dummy_request *req;
509 struct dummy *dum;
510 unsigned long flags;
511
512 req = usb_request_to_dummy_request (_req);
513 if (!_req || !list_empty (&req->queue) || !_req->complete)
514 return -EINVAL;
515
516 ep = usb_ep_to_dummy_ep (_ep);
517 if (!_ep || (!ep->desc && _ep->name != ep0name))
518 return -EINVAL;
519
520 dum = ep_to_dummy (ep);
521 if (!dum->driver || !is_enabled (dum))
522 return -ESHUTDOWN;
523
524#if 0
Alan Sternd9b76252005-05-03 16:15:43 -0400525 dev_dbg (udc_dev(dum), "ep %p queue req %p to %s, len %d buf %p\n",
Linus Torvalds1da177e2005-04-16 15:20:36 -0700526 ep, _req, _ep->name, _req->length, _req->buf);
527#endif
528
529 _req->status = -EINPROGRESS;
530 _req->actual = 0;
531 spin_lock_irqsave (&dum->lock, flags);
532
533 /* implement an emulated single-request FIFO */
534 if (ep->desc && (ep->desc->bEndpointAddress & USB_DIR_IN) &&
535 list_empty (&dum->fifo_req.queue) &&
536 list_empty (&ep->queue) &&
537 _req->length <= FIFO_SIZE) {
538 req = &dum->fifo_req;
539 req->req = *_req;
540 req->req.buf = dum->fifo_buf;
541 memcpy (dum->fifo_buf, _req->buf, _req->length);
542 req->req.context = dum;
543 req->req.complete = fifo_complete;
544
545 spin_unlock (&dum->lock);
546 _req->actual = _req->length;
547 _req->status = 0;
548 _req->complete (_ep, _req);
549 spin_lock (&dum->lock);
550 }
551 list_add_tail (&req->queue, &ep->queue);
552 spin_unlock_irqrestore (&dum->lock, flags);
553
554 /* real hardware would likely enable transfers here, in case
555 * it'd been left NAKing.
556 */
557 return 0;
558}
559
560static int dummy_dequeue (struct usb_ep *_ep, struct usb_request *_req)
561{
562 struct dummy_ep *ep;
563 struct dummy *dum;
564 int retval = -EINVAL;
565 unsigned long flags;
566 struct dummy_request *req = NULL;
567
568 if (!_ep || !_req)
569 return retval;
570 ep = usb_ep_to_dummy_ep (_ep);
571 dum = ep_to_dummy (ep);
572
573 if (!dum->driver)
574 return -ESHUTDOWN;
575
Alan Sternb4dbda12006-07-28 17:07:34 -0400576 local_irq_save (flags);
577 spin_lock (&dum->lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700578 list_for_each_entry (req, &ep->queue, queue) {
579 if (&req->req == _req) {
580 list_del_init (&req->queue);
581 _req->status = -ECONNRESET;
582 retval = 0;
583 break;
584 }
585 }
Alan Sternb4dbda12006-07-28 17:07:34 -0400586 spin_unlock (&dum->lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700587
588 if (retval == 0) {
Alan Sternd9b76252005-05-03 16:15:43 -0400589 dev_dbg (udc_dev(dum),
Linus Torvalds1da177e2005-04-16 15:20:36 -0700590 "dequeued req %p from %s, len %d buf %p\n",
591 req, _ep->name, _req->length, _req->buf);
592 _req->complete (_ep, _req);
593 }
Alan Sternb4dbda12006-07-28 17:07:34 -0400594 local_irq_restore (flags);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700595 return retval;
596}
597
598static int
599dummy_set_halt (struct usb_ep *_ep, int value)
600{
601 struct dummy_ep *ep;
602 struct dummy *dum;
603
604 if (!_ep)
605 return -EINVAL;
606 ep = usb_ep_to_dummy_ep (_ep);
607 dum = ep_to_dummy (ep);
608 if (!dum->driver)
609 return -ESHUTDOWN;
610 if (!value)
611 ep->halted = 0;
612 else if (ep->desc && (ep->desc->bEndpointAddress & USB_DIR_IN) &&
613 !list_empty (&ep->queue))
614 return -EAGAIN;
615 else
616 ep->halted = 1;
617 /* FIXME clear emulated data toggle too */
618 return 0;
619}
620
621static const struct usb_ep_ops dummy_ep_ops = {
622 .enable = dummy_enable,
623 .disable = dummy_disable,
624
625 .alloc_request = dummy_alloc_request,
626 .free_request = dummy_free_request,
627
Linus Torvalds1da177e2005-04-16 15:20:36 -0700628 .queue = dummy_queue,
629 .dequeue = dummy_dequeue,
630
631 .set_halt = dummy_set_halt,
632};
633
634/*-------------------------------------------------------------------------*/
635
636/* there are both host and device side versions of this call ... */
637static int dummy_g_get_frame (struct usb_gadget *_gadget)
638{
639 struct timeval tv;
640
641 do_gettimeofday (&tv);
642 return tv.tv_usec / 1000;
643}
644
645static int dummy_wakeup (struct usb_gadget *_gadget)
646{
647 struct dummy *dum;
648
649 dum = gadget_to_dummy (_gadget);
Alan Stern391eca92005-05-10 15:34:16 -0400650 if (!(dum->devstatus & ( (1 << USB_DEVICE_B_HNP_ENABLE)
Alan Stern5742b0c2005-05-02 11:25:17 -0400651 | (1 << USB_DEVICE_REMOTE_WAKEUP))))
Linus Torvalds1da177e2005-04-16 15:20:36 -0700652 return -EINVAL;
Alan Stern391eca92005-05-10 15:34:16 -0400653 if ((dum->port_status & USB_PORT_STAT_CONNECTION) == 0)
654 return -ENOLINK;
655 if ((dum->port_status & USB_PORT_STAT_SUSPEND) == 0 &&
656 dum->rh_state != DUMMY_RH_SUSPENDED)
657 return -EIO;
658
659 /* FIXME: What if the root hub is suspended but the port isn't? */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700660
661 /* hub notices our request, issues downstream resume, etc */
662 dum->resuming = 1;
Alan Sternf1c39fa2005-05-03 16:24:04 -0400663 dum->re_timeout = jiffies + msecs_to_jiffies(20);
Alan Stern685eb932005-05-03 16:27:26 -0400664 mod_timer (&dummy_to_hcd (dum)->rh_timer, dum->re_timeout);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700665 return 0;
666}
667
668static int dummy_set_selfpowered (struct usb_gadget *_gadget, int value)
669{
670 struct dummy *dum;
671
672 dum = gadget_to_dummy (_gadget);
673 if (value)
674 dum->devstatus |= (1 << USB_DEVICE_SELF_POWERED);
675 else
676 dum->devstatus &= ~(1 << USB_DEVICE_SELF_POWERED);
677 return 0;
678}
679
Alan Sternf1c39fa2005-05-03 16:24:04 -0400680static int dummy_pullup (struct usb_gadget *_gadget, int value)
681{
682 struct dummy *dum;
683 unsigned long flags;
684
685 dum = gadget_to_dummy (_gadget);
686 spin_lock_irqsave (&dum->lock, flags);
687 dum->pullup = (value != 0);
688 set_link_state (dum);
689 spin_unlock_irqrestore (&dum->lock, flags);
Alan Stern685eb932005-05-03 16:27:26 -0400690
691 usb_hcd_poll_rh_status (dummy_to_hcd (dum));
Alan Sternf1c39fa2005-05-03 16:24:04 -0400692 return 0;
693}
694
Linus Torvalds1da177e2005-04-16 15:20:36 -0700695static const struct usb_gadget_ops dummy_ops = {
696 .get_frame = dummy_g_get_frame,
697 .wakeup = dummy_wakeup,
698 .set_selfpowered = dummy_set_selfpowered,
Alan Sternf1c39fa2005-05-03 16:24:04 -0400699 .pullup = dummy_pullup,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700700};
701
702/*-------------------------------------------------------------------------*/
703
704/* "function" sysfs attribute */
705static ssize_t
Yani Ioannou10523b32005-05-17 06:43:37 -0400706show_function (struct device *dev, struct device_attribute *attr, char *buf)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700707{
708 struct dummy *dum = gadget_dev_to_dummy (dev);
709
710 if (!dum->driver || !dum->driver->function)
711 return 0;
712 return scnprintf (buf, PAGE_SIZE, "%s\n", dum->driver->function);
713}
Alan Sterncc095b02005-05-10 15:28:38 -0400714static DEVICE_ATTR (function, S_IRUGO, show_function, NULL);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700715
716/*-------------------------------------------------------------------------*/
717
718/*
719 * Driver registration/unregistration.
720 *
721 * This is basically hardware-specific; there's usually only one real USB
722 * device (not host) controller since that's how USB devices are intended
723 * to work. So most implementations of these api calls will rely on the
724 * fact that only one driver will ever bind to the hardware. But curious
725 * hardware can be built with discrete components, so the gadget API doesn't
726 * require that assumption.
727 *
728 * For this emulator, it might be convenient to create a usb slave device
729 * for each driver that registers: just add to a big root hub.
730 */
731
Linus Torvalds1da177e2005-04-16 15:20:36 -0700732int
733usb_gadget_register_driver (struct usb_gadget_driver *driver)
734{
735 struct dummy *dum = the_controller;
736 int retval, i;
737
738 if (!dum)
739 return -EINVAL;
740 if (dum->driver)
741 return -EBUSY;
David Brownell6bea4762006-12-05 03:15:33 -0800742 if (!driver->bind || !driver->setup
Linus Torvalds1da177e2005-04-16 15:20:36 -0700743 || driver->speed == USB_SPEED_UNKNOWN)
744 return -EINVAL;
745
746 /*
747 * SLAVE side init ... the layer above hardware, which
748 * can't enumerate without help from the driver we're binding.
749 */
Alan Stern5742b0c2005-05-02 11:25:17 -0400750
Linus Torvalds1da177e2005-04-16 15:20:36 -0700751 dum->devstatus = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700752
753 INIT_LIST_HEAD (&dum->gadget.ep_list);
754 for (i = 0; i < DUMMY_ENDPOINTS; i++) {
755 struct dummy_ep *ep = &dum->ep [i];
756
757 if (!ep_name [i])
758 break;
759 ep->ep.name = ep_name [i];
760 ep->ep.ops = &dummy_ep_ops;
761 list_add_tail (&ep->ep.ep_list, &dum->gadget.ep_list);
762 ep->halted = ep->already_seen = ep->setup_stage = 0;
763 ep->ep.maxpacket = ~0;
764 ep->last_io = jiffies;
765 ep->gadget = &dum->gadget;
766 ep->desc = NULL;
767 INIT_LIST_HEAD (&ep->queue);
768 }
769
770 dum->gadget.ep0 = &dum->ep [0].ep;
771 dum->ep [0].ep.maxpacket = 64;
772 list_del_init (&dum->ep [0].ep.ep_list);
773 INIT_LIST_HEAD(&dum->fifo_req.queue);
774
775 dum->driver = driver;
776 dum->gadget.dev.driver = &driver->driver;
Alan Sternd9b76252005-05-03 16:15:43 -0400777 dev_dbg (udc_dev(dum), "binding gadget driver '%s'\n",
Linus Torvalds1da177e2005-04-16 15:20:36 -0700778 driver->driver.name);
Alan Sternefd54a32006-09-25 11:55:56 -0400779 if ((retval = driver->bind (&dum->gadget)) != 0)
780 goto err_bind_gadget;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700781
Linus Torvalds1da177e2005-04-16 15:20:36 -0700782 driver->driver.bus = dum->gadget.dev.parent->bus;
Alan Sternefd54a32006-09-25 11:55:56 -0400783 if ((retval = driver_register (&driver->driver)) != 0)
784 goto err_register;
785 if ((retval = device_bind_driver (&dum->gadget.dev)) != 0)
786 goto err_bind_driver;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700787
788 /* khubd will enumerate this in a while */
Alan Sternf1c39fa2005-05-03 16:24:04 -0400789 spin_lock_irq (&dum->lock);
790 dum->pullup = 1;
791 set_link_state (dum);
792 spin_unlock_irq (&dum->lock);
Alan Stern685eb932005-05-03 16:27:26 -0400793
794 usb_hcd_poll_rh_status (dummy_to_hcd (dum));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700795 return 0;
Alan Sternefd54a32006-09-25 11:55:56 -0400796
797err_bind_driver:
798 driver_unregister (&driver->driver);
799err_register:
David Brownell6bea4762006-12-05 03:15:33 -0800800 if (driver->unbind)
801 driver->unbind (&dum->gadget);
Alan Sternefd54a32006-09-25 11:55:56 -0400802 spin_lock_irq (&dum->lock);
803 dum->pullup = 0;
804 set_link_state (dum);
805 spin_unlock_irq (&dum->lock);
806err_bind_gadget:
807 dum->driver = NULL;
808 dum->gadget.dev.driver = NULL;
809 return retval;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700810}
811EXPORT_SYMBOL (usb_gadget_register_driver);
812
Linus Torvalds1da177e2005-04-16 15:20:36 -0700813int
814usb_gadget_unregister_driver (struct usb_gadget_driver *driver)
815{
816 struct dummy *dum = the_controller;
817 unsigned long flags;
818
819 if (!dum)
820 return -ENODEV;
David Brownell6bea4762006-12-05 03:15:33 -0800821 if (!driver || driver != dum->driver || !driver->unbind)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700822 return -EINVAL;
823
Alan Sternd9b76252005-05-03 16:15:43 -0400824 dev_dbg (udc_dev(dum), "unregister gadget driver '%s'\n",
Linus Torvalds1da177e2005-04-16 15:20:36 -0700825 driver->driver.name);
826
827 spin_lock_irqsave (&dum->lock, flags);
Alan Sternf1c39fa2005-05-03 16:24:04 -0400828 dum->pullup = 0;
829 set_link_state (dum);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700830 spin_unlock_irqrestore (&dum->lock, flags);
831
832 driver->unbind (&dum->gadget);
833 dum->driver = NULL;
834
835 device_release_driver (&dum->gadget.dev);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700836 driver_unregister (&driver->driver);
837
Alan Sternf1c39fa2005-05-03 16:24:04 -0400838 spin_lock_irqsave (&dum->lock, flags);
839 dum->pullup = 0;
840 set_link_state (dum);
841 spin_unlock_irqrestore (&dum->lock, flags);
842
Alan Stern685eb932005-05-03 16:27:26 -0400843 usb_hcd_poll_rh_status (dummy_to_hcd (dum));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700844 return 0;
845}
846EXPORT_SYMBOL (usb_gadget_unregister_driver);
847
848#undef is_enabled
849
Alan Sterncc095b02005-05-10 15:28:38 -0400850/* just declare this in any driver that really need it */
851extern int net2280_set_fifo_mode (struct usb_gadget *gadget, int mode);
852
Linus Torvalds1da177e2005-04-16 15:20:36 -0700853int net2280_set_fifo_mode (struct usb_gadget *gadget, int mode)
854{
855 return -ENOSYS;
856}
857EXPORT_SYMBOL (net2280_set_fifo_mode);
858
Alan Sternd9b76252005-05-03 16:15:43 -0400859
860/* The gadget structure is stored inside the hcd structure and will be
861 * released along with it. */
862static void
863dummy_gadget_release (struct device *dev)
864{
Alan Sternd9b76252005-05-03 16:15:43 -0400865 struct dummy *dum = gadget_dev_to_dummy (dev);
866
Alan Stern17200582006-08-30 11:32:52 -0400867 usb_put_hcd (dummy_to_hcd (dum));
Alan Sternd9b76252005-05-03 16:15:43 -0400868}
869
Alan Stern8364d6b2005-11-14 12:16:30 -0500870static int dummy_udc_probe (struct platform_device *pdev)
Alan Sternd9b76252005-05-03 16:15:43 -0400871{
872 struct dummy *dum = the_controller;
873 int rc;
874
875 dum->gadget.name = gadget_name;
876 dum->gadget.ops = &dummy_ops;
877 dum->gadget.is_dualspeed = 1;
878
879 /* maybe claim OTG support, though we won't complete HNP */
880 dum->gadget.is_otg = (dummy_to_hcd(dum)->self.otg_port != 0);
881
882 strcpy (dum->gadget.dev.bus_id, "gadget");
Alan Stern8364d6b2005-11-14 12:16:30 -0500883 dum->gadget.dev.parent = &pdev->dev;
Alan Sternd9b76252005-05-03 16:15:43 -0400884 dum->gadget.dev.release = dummy_gadget_release;
885 rc = device_register (&dum->gadget.dev);
886 if (rc < 0)
887 return rc;
888
Alan Stern17200582006-08-30 11:32:52 -0400889 usb_get_hcd (dummy_to_hcd (dum));
Alan Sternd9b76252005-05-03 16:15:43 -0400890
Alan Stern8364d6b2005-11-14 12:16:30 -0500891 platform_set_drvdata (pdev, dum);
Alan Sternefd54a32006-09-25 11:55:56 -0400892 rc = device_create_file (&dum->gadget.dev, &dev_attr_function);
893 if (rc < 0)
894 device_unregister (&dum->gadget.dev);
Alan Sternd9b76252005-05-03 16:15:43 -0400895 return rc;
896}
897
Alan Stern8364d6b2005-11-14 12:16:30 -0500898static int dummy_udc_remove (struct platform_device *pdev)
Alan Sternd9b76252005-05-03 16:15:43 -0400899{
Alan Stern8364d6b2005-11-14 12:16:30 -0500900 struct dummy *dum = platform_get_drvdata (pdev);
Alan Sternd9b76252005-05-03 16:15:43 -0400901
Alan Stern8364d6b2005-11-14 12:16:30 -0500902 platform_set_drvdata (pdev, NULL);
Alan Sternd9b76252005-05-03 16:15:43 -0400903 device_remove_file (&dum->gadget.dev, &dev_attr_function);
904 device_unregister (&dum->gadget.dev);
905 return 0;
906}
907
Alan Stern8364d6b2005-11-14 12:16:30 -0500908static int dummy_udc_suspend (struct platform_device *pdev, pm_message_t state)
Alan Stern391eca92005-05-10 15:34:16 -0400909{
Alan Stern8364d6b2005-11-14 12:16:30 -0500910 struct dummy *dum = platform_get_drvdata(pdev);
Alan Stern391eca92005-05-10 15:34:16 -0400911
Alan Stern8364d6b2005-11-14 12:16:30 -0500912 dev_dbg (&pdev->dev, "%s\n", __FUNCTION__);
Alan Stern391eca92005-05-10 15:34:16 -0400913 spin_lock_irq (&dum->lock);
914 dum->udc_suspended = 1;
915 set_link_state (dum);
916 spin_unlock_irq (&dum->lock);
917
Alan Stern8364d6b2005-11-14 12:16:30 -0500918 pdev->dev.power.power_state = state;
Alan Stern391eca92005-05-10 15:34:16 -0400919 usb_hcd_poll_rh_status (dummy_to_hcd (dum));
920 return 0;
921}
922
Alan Stern8364d6b2005-11-14 12:16:30 -0500923static int dummy_udc_resume (struct platform_device *pdev)
Alan Stern391eca92005-05-10 15:34:16 -0400924{
Alan Stern8364d6b2005-11-14 12:16:30 -0500925 struct dummy *dum = platform_get_drvdata(pdev);
Alan Stern391eca92005-05-10 15:34:16 -0400926
Alan Stern8364d6b2005-11-14 12:16:30 -0500927 dev_dbg (&pdev->dev, "%s\n", __FUNCTION__);
Alan Stern391eca92005-05-10 15:34:16 -0400928 spin_lock_irq (&dum->lock);
929 dum->udc_suspended = 0;
930 set_link_state (dum);
931 spin_unlock_irq (&dum->lock);
932
Alan Stern8364d6b2005-11-14 12:16:30 -0500933 pdev->dev.power.power_state = PMSG_ON;
Alan Stern391eca92005-05-10 15:34:16 -0400934 usb_hcd_poll_rh_status (dummy_to_hcd (dum));
935 return 0;
936}
937
Russell King3ae5eae2005-11-09 22:32:44 +0000938static struct platform_driver dummy_udc_driver = {
Alan Sternd9b76252005-05-03 16:15:43 -0400939 .probe = dummy_udc_probe,
940 .remove = dummy_udc_remove,
Alan Stern391eca92005-05-10 15:34:16 -0400941 .suspend = dummy_udc_suspend,
942 .resume = dummy_udc_resume,
Russell King3ae5eae2005-11-09 22:32:44 +0000943 .driver = {
944 .name = (char *) gadget_name,
945 .owner = THIS_MODULE,
946 },
Alan Sternd9b76252005-05-03 16:15:43 -0400947};
948
Linus Torvalds1da177e2005-04-16 15:20:36 -0700949/*-------------------------------------------------------------------------*/
950
951/* MASTER/HOST SIDE DRIVER
952 *
953 * this uses the hcd framework to hook up to host side drivers.
954 * its root hub will only have one device, otherwise it acts like
955 * a normal host controller.
956 *
957 * when urbs are queued, they're just stuck on a list that we
958 * scan in a timer callback. that callback connects writes from
959 * the host with reads from the device, and so on, based on the
960 * usb 2.0 rules.
961 */
962
963static int dummy_urb_enqueue (
964 struct usb_hcd *hcd,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700965 struct urb *urb,
Al Viro55016f12005-10-21 03:21:58 -0400966 gfp_t mem_flags
Linus Torvalds1da177e2005-04-16 15:20:36 -0700967) {
968 struct dummy *dum;
969 struct urbp *urbp;
970 unsigned long flags;
Alan Sterne9df41c2007-08-08 11:48:02 -0400971 int rc;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700972
973 if (!urb->transfer_buffer && urb->transfer_buffer_length)
974 return -EINVAL;
975
976 urbp = kmalloc (sizeof *urbp, mem_flags);
977 if (!urbp)
978 return -ENOMEM;
979 urbp->urb = urb;
980
981 dum = hcd_to_dummy (hcd);
982 spin_lock_irqsave (&dum->lock, flags);
Alan Sterne9df41c2007-08-08 11:48:02 -0400983 rc = usb_hcd_link_urb_to_ep(hcd, urb);
984 if (rc) {
985 kfree(urbp);
986 goto done;
987 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700988
989 if (!dum->udev) {
990 dum->udev = urb->dev;
991 usb_get_dev (dum->udev);
992 } else if (unlikely (dum->udev != urb->dev))
993 dev_err (dummy_dev(dum), "usb_device address has changed!\n");
994
995 list_add_tail (&urbp->urbp_list, &dum->urbp_list);
996 urb->hcpriv = urbp;
997 if (usb_pipetype (urb->pipe) == PIPE_CONTROL)
998 urb->error_count = 1; /* mark as a new urb */
999
1000 /* kick the scheduler, it'll do the rest */
1001 if (!timer_pending (&dum->timer))
1002 mod_timer (&dum->timer, jiffies + 1);
1003
1004 spin_unlock_irqrestore (&dum->lock, flags);
Alan Sterne9df41c2007-08-08 11:48:02 -04001005 done:
1006 return rc;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001007}
1008
Alan Sterne9df41c2007-08-08 11:48:02 -04001009static int dummy_urb_dequeue(struct usb_hcd *hcd, struct urb *urb, int status)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001010{
Alan Stern391eca92005-05-10 15:34:16 -04001011 struct dummy *dum;
1012 unsigned long flags;
Alan Sterne9df41c2007-08-08 11:48:02 -04001013 int rc;
Alan Stern391eca92005-05-10 15:34:16 -04001014
1015 /* giveback happens automatically in timer callback,
1016 * so make sure the callback happens */
1017 dum = hcd_to_dummy (hcd);
1018 spin_lock_irqsave (&dum->lock, flags);
Alan Sterne9df41c2007-08-08 11:48:02 -04001019
1020 rc = usb_hcd_check_unlink_urb(hcd, urb, status);
1021 if (!rc && dum->rh_state != DUMMY_RH_RUNNING &&
1022 !list_empty(&dum->urbp_list))
Alan Stern391eca92005-05-10 15:34:16 -04001023 mod_timer (&dum->timer, jiffies);
Alan Sterne9df41c2007-08-08 11:48:02 -04001024
Alan Stern391eca92005-05-10 15:34:16 -04001025 spin_unlock_irqrestore (&dum->lock, flags);
Alan Sterne9df41c2007-08-08 11:48:02 -04001026 return rc;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001027}
1028
1029static void maybe_set_status (struct urb *urb, int status)
1030{
1031 spin_lock (&urb->lock);
1032 if (urb->status == -EINPROGRESS)
1033 urb->status = status;
1034 spin_unlock (&urb->lock);
1035}
1036
1037/* transfer up to a frame's worth; caller must own lock */
1038static int
1039transfer (struct dummy *dum, struct urb *urb, struct dummy_ep *ep, int limit)
1040{
1041 struct dummy_request *req;
1042
1043top:
1044 /* if there's no request queued, the device is NAKing; return */
1045 list_for_each_entry (req, &ep->queue, queue) {
1046 unsigned host_len, dev_len, len;
1047 int is_short, to_host;
1048 int rescan = 0;
1049
1050 /* 1..N packets of ep->ep.maxpacket each ... the last one
1051 * may be short (including zero length).
1052 *
1053 * writer can send a zlp explicitly (length 0) or implicitly
1054 * (length mod maxpacket zero, and 'zero' flag); they always
1055 * terminate reads.
1056 */
1057 host_len = urb->transfer_buffer_length - urb->actual_length;
1058 dev_len = req->req.length - req->req.actual;
1059 len = min (host_len, dev_len);
1060
1061 /* FIXME update emulated data toggle too */
1062
1063 to_host = usb_pipein (urb->pipe);
1064 if (unlikely (len == 0))
1065 is_short = 1;
1066 else {
1067 char *ubuf, *rbuf;
1068
1069 /* not enough bandwidth left? */
1070 if (limit < ep->ep.maxpacket && limit < len)
1071 break;
1072 len = min (len, (unsigned) limit);
1073 if (len == 0)
1074 break;
1075
1076 /* use an extra pass for the final short packet */
1077 if (len > ep->ep.maxpacket) {
1078 rescan = 1;
1079 len -= (len % ep->ep.maxpacket);
1080 }
1081 is_short = (len % ep->ep.maxpacket) != 0;
1082
1083 /* else transfer packet(s) */
1084 ubuf = urb->transfer_buffer + urb->actual_length;
1085 rbuf = req->req.buf + req->req.actual;
1086 if (to_host)
1087 memcpy (ubuf, rbuf, len);
1088 else
1089 memcpy (rbuf, ubuf, len);
1090 ep->last_io = jiffies;
1091
1092 limit -= len;
1093 urb->actual_length += len;
1094 req->req.actual += len;
1095 }
1096
1097 /* short packets terminate, maybe with overflow/underflow.
1098 * it's only really an error to write too much.
1099 *
1100 * partially filling a buffer optionally blocks queue advances
1101 * (so completion handlers can clean up the queue) but we don't
Alan Sternb0d9efb2007-08-21 15:39:21 -04001102 * need to emulate such data-in-flight.
Linus Torvalds1da177e2005-04-16 15:20:36 -07001103 */
1104 if (is_short) {
1105 if (host_len == dev_len) {
1106 req->req.status = 0;
1107 maybe_set_status (urb, 0);
1108 } else if (to_host) {
1109 req->req.status = 0;
1110 if (dev_len > host_len)
1111 maybe_set_status (urb, -EOVERFLOW);
1112 else
Alan Sternb0d9efb2007-08-21 15:39:21 -04001113 maybe_set_status (urb, 0);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001114 } else if (!to_host) {
1115 maybe_set_status (urb, 0);
1116 if (host_len > dev_len)
1117 req->req.status = -EOVERFLOW;
1118 else
1119 req->req.status = 0;
1120 }
1121
1122 /* many requests terminate without a short packet */
1123 } else {
1124 if (req->req.length == req->req.actual
1125 && !req->req.zero)
1126 req->req.status = 0;
1127 if (urb->transfer_buffer_length == urb->actual_length
1128 && !(urb->transfer_flags
1129 & URB_ZERO_PACKET)) {
1130 maybe_set_status (urb, 0);
1131 }
1132 }
1133
1134 /* device side completion --> continuable */
1135 if (req->req.status != -EINPROGRESS) {
1136 list_del_init (&req->queue);
1137
1138 spin_unlock (&dum->lock);
1139 req->req.complete (&ep->ep, &req->req);
1140 spin_lock (&dum->lock);
1141
1142 /* requests might have been unlinked... */
1143 rescan = 1;
1144 }
1145
1146 /* host side completion --> terminate */
1147 if (urb->status != -EINPROGRESS)
1148 break;
1149
1150 /* rescan to continue with any other queued i/o */
1151 if (rescan)
1152 goto top;
1153 }
1154 return limit;
1155}
1156
1157static int periodic_bytes (struct dummy *dum, struct dummy_ep *ep)
1158{
1159 int limit = ep->ep.maxpacket;
1160
1161 if (dum->gadget.speed == USB_SPEED_HIGH) {
1162 int tmp;
1163
1164 /* high bandwidth mode */
1165 tmp = le16_to_cpu(ep->desc->wMaxPacketSize);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001166 tmp = (tmp >> 11) & 0x03;
1167 tmp *= 8 /* applies to entire frame */;
1168 limit += limit * tmp;
1169 }
1170 return limit;
1171}
1172
1173#define is_active(dum) ((dum->port_status & \
1174 (USB_PORT_STAT_CONNECTION | USB_PORT_STAT_ENABLE | \
1175 USB_PORT_STAT_SUSPEND)) \
1176 == (USB_PORT_STAT_CONNECTION | USB_PORT_STAT_ENABLE))
1177
1178static struct dummy_ep *find_endpoint (struct dummy *dum, u8 address)
1179{
1180 int i;
1181
1182 if (!is_active (dum))
1183 return NULL;
1184 if ((address & ~USB_DIR_IN) == 0)
1185 return &dum->ep [0];
1186 for (i = 1; i < DUMMY_ENDPOINTS; i++) {
1187 struct dummy_ep *ep = &dum->ep [i];
1188
1189 if (!ep->desc)
1190 continue;
1191 if (ep->desc->bEndpointAddress == address)
1192 return ep;
1193 }
1194 return NULL;
1195}
1196
1197#undef is_active
1198
1199#define Dev_Request (USB_TYPE_STANDARD | USB_RECIP_DEVICE)
1200#define Dev_InRequest (Dev_Request | USB_DIR_IN)
1201#define Intf_Request (USB_TYPE_STANDARD | USB_RECIP_INTERFACE)
1202#define Intf_InRequest (Intf_Request | USB_DIR_IN)
1203#define Ep_Request (USB_TYPE_STANDARD | USB_RECIP_ENDPOINT)
1204#define Ep_InRequest (Ep_Request | USB_DIR_IN)
1205
1206/* drive both sides of the transfers; looks like irq handlers to
1207 * both drivers except the callbacks aren't in_irq().
1208 */
1209static void dummy_timer (unsigned long _dum)
1210{
1211 struct dummy *dum = (struct dummy *) _dum;
1212 struct urbp *urbp, *tmp;
1213 unsigned long flags;
1214 int limit, total;
1215 int i;
1216
1217 /* simplistic model for one frame's bandwidth */
1218 switch (dum->gadget.speed) {
1219 case USB_SPEED_LOW:
1220 total = 8/*bytes*/ * 12/*packets*/;
1221 break;
1222 case USB_SPEED_FULL:
1223 total = 64/*bytes*/ * 19/*packets*/;
1224 break;
1225 case USB_SPEED_HIGH:
1226 total = 512/*bytes*/ * 13/*packets*/ * 8/*uframes*/;
1227 break;
1228 default:
1229 dev_err (dummy_dev(dum), "bogus device speed\n");
1230 return;
1231 }
1232
1233 /* FIXME if HZ != 1000 this will probably misbehave ... */
1234
1235 /* look at each urb queued by the host side driver */
1236 spin_lock_irqsave (&dum->lock, flags);
1237
1238 if (!dum->udev) {
1239 dev_err (dummy_dev(dum),
1240 "timer fired with no URBs pending?\n");
1241 spin_unlock_irqrestore (&dum->lock, flags);
1242 return;
1243 }
1244
1245 for (i = 0; i < DUMMY_ENDPOINTS; i++) {
1246 if (!ep_name [i])
1247 break;
1248 dum->ep [i].already_seen = 0;
1249 }
1250
1251restart:
1252 list_for_each_entry_safe (urbp, tmp, &dum->urbp_list, urbp_list) {
1253 struct urb *urb;
1254 struct dummy_request *req;
1255 u8 address;
1256 struct dummy_ep *ep = NULL;
1257 int type;
1258
1259 urb = urbp->urb;
1260 if (urb->status != -EINPROGRESS) {
1261 /* likely it was just unlinked */
1262 goto return_urb;
Alan Stern391eca92005-05-10 15:34:16 -04001263 } else if (dum->rh_state != DUMMY_RH_RUNNING)
1264 continue;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001265 type = usb_pipetype (urb->pipe);
1266
1267 /* used up this frame's non-periodic bandwidth?
1268 * FIXME there's infinite bandwidth for control and
1269 * periodic transfers ... unrealistic.
1270 */
1271 if (total <= 0 && type == PIPE_BULK)
1272 continue;
1273
1274 /* find the gadget's ep for this request (if configured) */
1275 address = usb_pipeendpoint (urb->pipe);
1276 if (usb_pipein (urb->pipe))
1277 address |= USB_DIR_IN;
1278 ep = find_endpoint(dum, address);
1279 if (!ep) {
1280 /* set_configuration() disagreement */
1281 dev_dbg (dummy_dev(dum),
1282 "no ep configured for urb %p\n",
1283 urb);
1284 maybe_set_status (urb, -EPROTO);
1285 goto return_urb;
1286 }
1287
1288 if (ep->already_seen)
1289 continue;
1290 ep->already_seen = 1;
1291 if (ep == &dum->ep [0] && urb->error_count) {
1292 ep->setup_stage = 1; /* a new urb */
1293 urb->error_count = 0;
1294 }
1295 if (ep->halted && !ep->setup_stage) {
1296 /* NOTE: must not be iso! */
1297 dev_dbg (dummy_dev(dum), "ep %s halted, urb %p\n",
1298 ep->ep.name, urb);
1299 maybe_set_status (urb, -EPIPE);
1300 goto return_urb;
1301 }
1302 /* FIXME make sure both ends agree on maxpacket */
1303
1304 /* handle control requests */
1305 if (ep == &dum->ep [0] && ep->setup_stage) {
1306 struct usb_ctrlrequest setup;
1307 int value = 1;
1308 struct dummy_ep *ep2;
Alan Sterncc095b02005-05-10 15:28:38 -04001309 unsigned w_index;
1310 unsigned w_value;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001311
1312 setup = *(struct usb_ctrlrequest*) urb->setup_packet;
Alan Sterncc095b02005-05-10 15:28:38 -04001313 w_index = le16_to_cpu(setup.wIndex);
1314 w_value = le16_to_cpu(setup.wValue);
1315 if (le16_to_cpu(setup.wLength) !=
1316 urb->transfer_buffer_length) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001317 maybe_set_status (urb, -EOVERFLOW);
1318 goto return_urb;
1319 }
1320
1321 /* paranoia, in case of stale queued data */
1322 list_for_each_entry (req, &ep->queue, queue) {
1323 list_del_init (&req->queue);
1324 req->req.status = -EOVERFLOW;
Alan Sternd9b76252005-05-03 16:15:43 -04001325 dev_dbg (udc_dev(dum), "stale req = %p\n",
Linus Torvalds1da177e2005-04-16 15:20:36 -07001326 req);
1327
1328 spin_unlock (&dum->lock);
1329 req->req.complete (&ep->ep, &req->req);
1330 spin_lock (&dum->lock);
1331 ep->already_seen = 0;
1332 goto restart;
1333 }
1334
1335 /* gadget driver never sees set_address or operations
1336 * on standard feature flags. some hardware doesn't
1337 * even expose them.
1338 */
1339 ep->last_io = jiffies;
1340 ep->setup_stage = 0;
1341 ep->halted = 0;
1342 switch (setup.bRequest) {
1343 case USB_REQ_SET_ADDRESS:
1344 if (setup.bRequestType != Dev_Request)
1345 break;
Alan Sterncc095b02005-05-10 15:28:38 -04001346 dum->address = w_value;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001347 maybe_set_status (urb, 0);
Alan Sternd9b76252005-05-03 16:15:43 -04001348 dev_dbg (udc_dev(dum), "set_address = %d\n",
Alan Sterncc095b02005-05-10 15:28:38 -04001349 w_value);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001350 value = 0;
1351 break;
1352 case USB_REQ_SET_FEATURE:
1353 if (setup.bRequestType == Dev_Request) {
1354 value = 0;
Alan Sterncc095b02005-05-10 15:28:38 -04001355 switch (w_value) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001356 case USB_DEVICE_REMOTE_WAKEUP:
1357 break;
Alan Stern5742b0c2005-05-02 11:25:17 -04001358 case USB_DEVICE_B_HNP_ENABLE:
1359 dum->gadget.b_hnp_enable = 1;
1360 break;
1361 case USB_DEVICE_A_HNP_SUPPORT:
1362 dum->gadget.a_hnp_support = 1;
1363 break;
1364 case USB_DEVICE_A_ALT_HNP_SUPPORT:
1365 dum->gadget.a_alt_hnp_support
1366 = 1;
1367 break;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001368 default:
1369 value = -EOPNOTSUPP;
1370 }
1371 if (value == 0) {
1372 dum->devstatus |=
Alan Sterncc095b02005-05-10 15:28:38 -04001373 (1 << w_value);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001374 maybe_set_status (urb, 0);
1375 }
1376
1377 } else if (setup.bRequestType == Ep_Request) {
1378 // endpoint halt
Alan Sterncc095b02005-05-10 15:28:38 -04001379 ep2 = find_endpoint (dum, w_index);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001380 if (!ep2) {
1381 value = -EOPNOTSUPP;
1382 break;
1383 }
1384 ep2->halted = 1;
1385 value = 0;
1386 maybe_set_status (urb, 0);
1387 }
1388 break;
1389 case USB_REQ_CLEAR_FEATURE:
1390 if (setup.bRequestType == Dev_Request) {
Alan Sterncc095b02005-05-10 15:28:38 -04001391 switch (w_value) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001392 case USB_DEVICE_REMOTE_WAKEUP:
1393 dum->devstatus &= ~(1 <<
1394 USB_DEVICE_REMOTE_WAKEUP);
1395 value = 0;
1396 maybe_set_status (urb, 0);
1397 break;
1398 default:
1399 value = -EOPNOTSUPP;
1400 break;
1401 }
1402 } else if (setup.bRequestType == Ep_Request) {
1403 // endpoint halt
Alan Sterncc095b02005-05-10 15:28:38 -04001404 ep2 = find_endpoint (dum, w_index);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001405 if (!ep2) {
1406 value = -EOPNOTSUPP;
1407 break;
1408 }
1409 ep2->halted = 0;
1410 value = 0;
1411 maybe_set_status (urb, 0);
1412 }
1413 break;
1414 case USB_REQ_GET_STATUS:
1415 if (setup.bRequestType == Dev_InRequest
1416 || setup.bRequestType
1417 == Intf_InRequest
1418 || setup.bRequestType
1419 == Ep_InRequest
1420 ) {
1421 char *buf;
1422
1423 // device: remote wakeup, selfpowered
1424 // interface: nothing
1425 // endpoint: halt
1426 buf = (char *)urb->transfer_buffer;
1427 if (urb->transfer_buffer_length > 0) {
1428 if (setup.bRequestType ==
1429 Ep_InRequest) {
Alan Sterncc095b02005-05-10 15:28:38 -04001430 ep2 = find_endpoint (dum, w_index);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001431 if (!ep2) {
1432 value = -EOPNOTSUPP;
1433 break;
1434 }
1435 buf [0] = ep2->halted;
1436 } else if (setup.bRequestType ==
1437 Dev_InRequest) {
1438 buf [0] = (u8)
1439 dum->devstatus;
1440 } else
1441 buf [0] = 0;
1442 }
1443 if (urb->transfer_buffer_length > 1)
1444 buf [1] = 0;
1445 urb->actual_length = min (2,
1446 urb->transfer_buffer_length);
1447 value = 0;
1448 maybe_set_status (urb, 0);
1449 }
1450 break;
1451 }
1452
1453 /* gadget driver handles all other requests. block
1454 * until setup() returns; no reentrancy issues etc.
1455 */
1456 if (value > 0) {
1457 spin_unlock (&dum->lock);
1458 value = dum->driver->setup (&dum->gadget,
1459 &setup);
1460 spin_lock (&dum->lock);
1461
1462 if (value >= 0) {
1463 /* no delays (max 64KB data stage) */
1464 limit = 64*1024;
1465 goto treat_control_like_bulk;
1466 }
1467 /* error, see below */
1468 }
1469
1470 if (value < 0) {
1471 if (value != -EOPNOTSUPP)
Alan Sternd9b76252005-05-03 16:15:43 -04001472 dev_dbg (udc_dev(dum),
Linus Torvalds1da177e2005-04-16 15:20:36 -07001473 "setup --> %d\n",
1474 value);
1475 maybe_set_status (urb, -EPIPE);
1476 urb->actual_length = 0;
1477 }
1478
1479 goto return_urb;
1480 }
1481
1482 /* non-control requests */
1483 limit = total;
1484 switch (usb_pipetype (urb->pipe)) {
1485 case PIPE_ISOCHRONOUS:
1486 /* FIXME is it urb->interval since the last xfer?
1487 * use urb->iso_frame_desc[i].
1488 * complete whether or not ep has requests queued.
1489 * report random errors, to debug drivers.
1490 */
1491 limit = max (limit, periodic_bytes (dum, ep));
1492 maybe_set_status (urb, -ENOSYS);
1493 break;
1494
1495 case PIPE_INTERRUPT:
1496 /* FIXME is it urb->interval since the last xfer?
1497 * this almost certainly polls too fast.
1498 */
1499 limit = max (limit, periodic_bytes (dum, ep));
1500 /* FALLTHROUGH */
1501
1502 // case PIPE_BULK: case PIPE_CONTROL:
1503 default:
1504 treat_control_like_bulk:
1505 ep->last_io = jiffies;
1506 total = transfer (dum, urb, ep, limit);
1507 break;
1508 }
1509
1510 /* incomplete transfer? */
1511 if (urb->status == -EINPROGRESS)
1512 continue;
1513
1514return_urb:
Linus Torvalds1da177e2005-04-16 15:20:36 -07001515 list_del (&urbp->urbp_list);
1516 kfree (urbp);
1517 if (ep)
1518 ep->already_seen = ep->setup_stage = 0;
1519
Alan Sterne9df41c2007-08-08 11:48:02 -04001520 usb_hcd_unlink_urb_from_ep(dummy_to_hcd(dum), urb);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001521 spin_unlock (&dum->lock);
Al Viro28431142006-10-08 15:00:12 +01001522 usb_hcd_giveback_urb (dummy_to_hcd(dum), urb);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001523 spin_lock (&dum->lock);
1524
1525 goto restart;
1526 }
1527
Alan Stern391eca92005-05-10 15:34:16 -04001528 if (list_empty (&dum->urbp_list)) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001529 usb_put_dev (dum->udev);
1530 dum->udev = NULL;
Alan Stern391eca92005-05-10 15:34:16 -04001531 } else if (dum->rh_state == DUMMY_RH_RUNNING) {
1532 /* want a 1 msec delay here */
1533 mod_timer (&dum->timer, jiffies + msecs_to_jiffies(1));
Linus Torvalds1da177e2005-04-16 15:20:36 -07001534 }
1535
1536 spin_unlock_irqrestore (&dum->lock, flags);
1537}
1538
1539/*-------------------------------------------------------------------------*/
1540
1541#define PORT_C_MASK \
Alan Sternc2db8b52005-04-29 16:30:48 -04001542 ((USB_PORT_STAT_C_CONNECTION \
1543 | USB_PORT_STAT_C_ENABLE \
1544 | USB_PORT_STAT_C_SUSPEND \
1545 | USB_PORT_STAT_C_OVERCURRENT \
1546 | USB_PORT_STAT_C_RESET) << 16)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001547
1548static int dummy_hub_status (struct usb_hcd *hcd, char *buf)
1549{
1550 struct dummy *dum;
1551 unsigned long flags;
Alan Stern391eca92005-05-10 15:34:16 -04001552 int retval = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001553
1554 dum = hcd_to_dummy (hcd);
1555
1556 spin_lock_irqsave (&dum->lock, flags);
Alan Stern3cf0a222005-11-29 12:08:15 -05001557 if (!test_bit(HCD_FLAG_HW_ACCESSIBLE, &hcd->flags))
Alan Stern391eca92005-05-10 15:34:16 -04001558 goto done;
Alan Sternf1c39fa2005-05-03 16:24:04 -04001559
1560 if (dum->resuming && time_after_eq (jiffies, dum->re_timeout)) {
1561 dum->port_status |= (USB_PORT_STAT_C_SUSPEND << 16);
1562 dum->port_status &= ~USB_PORT_STAT_SUSPEND;
1563 set_link_state (dum);
1564 }
1565
Alan Stern391eca92005-05-10 15:34:16 -04001566 if ((dum->port_status & PORT_C_MASK) != 0) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001567 *buf = (1 << 1);
1568 dev_dbg (dummy_dev(dum), "port status 0x%08x has changes\n",
Alan Stern391eca92005-05-10 15:34:16 -04001569 dum->port_status);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001570 retval = 1;
Alan Stern391eca92005-05-10 15:34:16 -04001571 if (dum->rh_state == DUMMY_RH_SUSPENDED)
1572 usb_hcd_resume_root_hub (hcd);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001573 }
Alan Stern391eca92005-05-10 15:34:16 -04001574done:
Linus Torvalds1da177e2005-04-16 15:20:36 -07001575 spin_unlock_irqrestore (&dum->lock, flags);
1576 return retval;
1577}
1578
1579static inline void
1580hub_descriptor (struct usb_hub_descriptor *desc)
1581{
1582 memset (desc, 0, sizeof *desc);
1583 desc->bDescriptorType = 0x29;
1584 desc->bDescLength = 9;
Alan Sterncc095b02005-05-10 15:28:38 -04001585 desc->wHubCharacteristics = (__force __u16)
1586 (__constant_cpu_to_le16 (0x0001));
Linus Torvalds1da177e2005-04-16 15:20:36 -07001587 desc->bNbrPorts = 1;
1588 desc->bitmap [0] = 0xff;
1589 desc->bitmap [1] = 0xff;
1590}
1591
1592static int dummy_hub_control (
1593 struct usb_hcd *hcd,
1594 u16 typeReq,
1595 u16 wValue,
1596 u16 wIndex,
1597 char *buf,
1598 u16 wLength
1599) {
1600 struct dummy *dum;
1601 int retval = 0;
1602 unsigned long flags;
1603
Alan Stern3cf0a222005-11-29 12:08:15 -05001604 if (!test_bit(HCD_FLAG_HW_ACCESSIBLE, &hcd->flags))
Alan Stern391eca92005-05-10 15:34:16 -04001605 return -ETIMEDOUT;
1606
Linus Torvalds1da177e2005-04-16 15:20:36 -07001607 dum = hcd_to_dummy (hcd);
1608 spin_lock_irqsave (&dum->lock, flags);
1609 switch (typeReq) {
1610 case ClearHubFeature:
1611 break;
1612 case ClearPortFeature:
1613 switch (wValue) {
1614 case USB_PORT_FEAT_SUSPEND:
Alan Sternc2db8b52005-04-29 16:30:48 -04001615 if (dum->port_status & USB_PORT_STAT_SUSPEND) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001616 /* 20msec resume signaling */
1617 dum->resuming = 1;
1618 dum->re_timeout = jiffies +
Alan Sternf1c39fa2005-05-03 16:24:04 -04001619 msecs_to_jiffies(20);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001620 }
1621 break;
1622 case USB_PORT_FEAT_POWER:
Alan Sternf1c39fa2005-05-03 16:24:04 -04001623 if (dum->port_status & USB_PORT_STAT_POWER)
1624 dev_dbg (dummy_dev(dum), "power-off\n");
1625 /* FALLS THROUGH */
Linus Torvalds1da177e2005-04-16 15:20:36 -07001626 default:
1627 dum->port_status &= ~(1 << wValue);
Alan Sternf1c39fa2005-05-03 16:24:04 -04001628 set_link_state (dum);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001629 }
1630 break;
1631 case GetHubDescriptor:
1632 hub_descriptor ((struct usb_hub_descriptor *) buf);
1633 break;
1634 case GetHubStatus:
Alan Sterncc095b02005-05-10 15:28:38 -04001635 *(__le32 *) buf = __constant_cpu_to_le32 (0);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001636 break;
1637 case GetPortStatus:
1638 if (wIndex != 1)
1639 retval = -EPIPE;
1640
1641 /* whoever resets or resumes must GetPortStatus to
1642 * complete it!!
1643 */
Alan Sternf1c39fa2005-05-03 16:24:04 -04001644 if (dum->resuming &&
1645 time_after_eq (jiffies, dum->re_timeout)) {
Alan Sternc2db8b52005-04-29 16:30:48 -04001646 dum->port_status |= (USB_PORT_STAT_C_SUSPEND << 16);
1647 dum->port_status &= ~USB_PORT_STAT_SUSPEND;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001648 }
Alan Sternf1c39fa2005-05-03 16:24:04 -04001649 if ((dum->port_status & USB_PORT_STAT_RESET) != 0 &&
1650 time_after_eq (jiffies, dum->re_timeout)) {
Alan Sternc2db8b52005-04-29 16:30:48 -04001651 dum->port_status |= (USB_PORT_STAT_C_RESET << 16);
1652 dum->port_status &= ~USB_PORT_STAT_RESET;
Alan Sternf1c39fa2005-05-03 16:24:04 -04001653 if (dum->pullup) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001654 dum->port_status |= USB_PORT_STAT_ENABLE;
1655 /* give it the best speed we agree on */
1656 dum->gadget.speed = dum->driver->speed;
1657 dum->gadget.ep0->maxpacket = 64;
1658 switch (dum->gadget.speed) {
1659 case USB_SPEED_HIGH:
1660 dum->port_status |=
1661 USB_PORT_STAT_HIGH_SPEED;
1662 break;
1663 case USB_SPEED_LOW:
1664 dum->gadget.ep0->maxpacket = 8;
1665 dum->port_status |=
1666 USB_PORT_STAT_LOW_SPEED;
1667 break;
1668 default:
1669 dum->gadget.speed = USB_SPEED_FULL;
1670 break;
1671 }
1672 }
1673 }
Alan Sternf1c39fa2005-05-03 16:24:04 -04001674 set_link_state (dum);
Alan Sterncc095b02005-05-10 15:28:38 -04001675 ((__le16 *) buf)[0] = cpu_to_le16 (dum->port_status);
1676 ((__le16 *) buf)[1] = cpu_to_le16 (dum->port_status >> 16);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001677 break;
1678 case SetHubFeature:
1679 retval = -EPIPE;
1680 break;
1681 case SetPortFeature:
1682 switch (wValue) {
1683 case USB_PORT_FEAT_SUSPEND:
Alan Sternf1c39fa2005-05-03 16:24:04 -04001684 if (dum->active) {
Alan Sternc2db8b52005-04-29 16:30:48 -04001685 dum->port_status |= USB_PORT_STAT_SUSPEND;
Alan Sternf1c39fa2005-05-03 16:24:04 -04001686
1687 /* HNP would happen here; for now we
1688 * assume b_bus_req is always true.
1689 */
1690 set_link_state (dum);
1691 if (((1 << USB_DEVICE_B_HNP_ENABLE)
1692 & dum->devstatus) != 0)
1693 dev_dbg (dummy_dev(dum),
Alan Stern5742b0c2005-05-02 11:25:17 -04001694 "no HNP yet!\n");
Linus Torvalds1da177e2005-04-16 15:20:36 -07001695 }
1696 break;
Alan Sternf1c39fa2005-05-03 16:24:04 -04001697 case USB_PORT_FEAT_POWER:
1698 dum->port_status |= USB_PORT_STAT_POWER;
1699 set_link_state (dum);
1700 break;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001701 case USB_PORT_FEAT_RESET:
Alan Sternf1c39fa2005-05-03 16:24:04 -04001702 /* if it's already enabled, disable */
1703 dum->port_status &= ~(USB_PORT_STAT_ENABLE
1704 | USB_PORT_STAT_LOW_SPEED
1705 | USB_PORT_STAT_HIGH_SPEED);
Alan Stern391eca92005-05-10 15:34:16 -04001706 dum->devstatus = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001707 /* 50msec reset signaling */
1708 dum->re_timeout = jiffies + msecs_to_jiffies(50);
Alan Sternf1c39fa2005-05-03 16:24:04 -04001709 /* FALLS THROUGH */
Linus Torvalds1da177e2005-04-16 15:20:36 -07001710 default:
Alan Sternf1c39fa2005-05-03 16:24:04 -04001711 if ((dum->port_status & USB_PORT_STAT_POWER) != 0) {
1712 dum->port_status |= (1 << wValue);
1713 set_link_state (dum);
1714 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07001715 }
1716 break;
1717
1718 default:
1719 dev_dbg (dummy_dev(dum),
1720 "hub control req%04x v%04x i%04x l%d\n",
1721 typeReq, wValue, wIndex, wLength);
1722
1723 /* "protocol stall" on error */
1724 retval = -EPIPE;
1725 }
1726 spin_unlock_irqrestore (&dum->lock, flags);
Alan Stern685eb932005-05-03 16:27:26 -04001727
1728 if ((dum->port_status & PORT_C_MASK) != 0)
1729 usb_hcd_poll_rh_status (hcd);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001730 return retval;
1731}
1732
Alan Stern0c0382e2005-10-13 17:08:02 -04001733static int dummy_bus_suspend (struct usb_hcd *hcd)
Alan Stern391eca92005-05-10 15:34:16 -04001734{
1735 struct dummy *dum = hcd_to_dummy (hcd);
1736
Alan Stern3cf0a222005-11-29 12:08:15 -05001737 dev_dbg (&hcd->self.root_hub->dev, "%s\n", __FUNCTION__);
1738
Alan Stern391eca92005-05-10 15:34:16 -04001739 spin_lock_irq (&dum->lock);
1740 dum->rh_state = DUMMY_RH_SUSPENDED;
1741 set_link_state (dum);
Alan Stern3cf0a222005-11-29 12:08:15 -05001742 hcd->state = HC_STATE_SUSPENDED;
Alan Stern391eca92005-05-10 15:34:16 -04001743 spin_unlock_irq (&dum->lock);
1744 return 0;
1745}
1746
Alan Stern0c0382e2005-10-13 17:08:02 -04001747static int dummy_bus_resume (struct usb_hcd *hcd)
Alan Stern391eca92005-05-10 15:34:16 -04001748{
1749 struct dummy *dum = hcd_to_dummy (hcd);
Alan Stern3cf0a222005-11-29 12:08:15 -05001750 int rc = 0;
1751
1752 dev_dbg (&hcd->self.root_hub->dev, "%s\n", __FUNCTION__);
Alan Stern391eca92005-05-10 15:34:16 -04001753
1754 spin_lock_irq (&dum->lock);
Alan Stern3cf0a222005-11-29 12:08:15 -05001755 if (!test_bit(HCD_FLAG_HW_ACCESSIBLE, &hcd->flags)) {
Alan Sterncfa59da2007-06-21 16:25:35 -04001756 rc = -ESHUTDOWN;
Alan Stern3cf0a222005-11-29 12:08:15 -05001757 } else {
1758 dum->rh_state = DUMMY_RH_RUNNING;
1759 set_link_state (dum);
1760 if (!list_empty(&dum->urbp_list))
1761 mod_timer (&dum->timer, jiffies);
1762 hcd->state = HC_STATE_RUNNING;
1763 }
Alan Stern391eca92005-05-10 15:34:16 -04001764 spin_unlock_irq (&dum->lock);
Alan Stern3cf0a222005-11-29 12:08:15 -05001765 return rc;
Alan Stern391eca92005-05-10 15:34:16 -04001766}
Linus Torvalds1da177e2005-04-16 15:20:36 -07001767
1768/*-------------------------------------------------------------------------*/
1769
1770static inline ssize_t
1771show_urb (char *buf, size_t size, struct urb *urb)
1772{
1773 int ep = usb_pipeendpoint (urb->pipe);
1774
1775 return snprintf (buf, size,
1776 "urb/%p %s ep%d%s%s len %d/%d\n",
1777 urb,
1778 ({ char *s;
1779 switch (urb->dev->speed) {
1780 case USB_SPEED_LOW: s = "ls"; break;
1781 case USB_SPEED_FULL: s = "fs"; break;
1782 case USB_SPEED_HIGH: s = "hs"; break;
1783 default: s = "?"; break;
1784 }; s; }),
1785 ep, ep ? (usb_pipein (urb->pipe) ? "in" : "out") : "",
1786 ({ char *s; \
1787 switch (usb_pipetype (urb->pipe)) { \
1788 case PIPE_CONTROL: s = ""; break; \
1789 case PIPE_BULK: s = "-bulk"; break; \
1790 case PIPE_INTERRUPT: s = "-int"; break; \
1791 default: s = "-iso"; break; \
1792 }; s;}),
1793 urb->actual_length, urb->transfer_buffer_length);
1794}
1795
1796static ssize_t
Yani Ioannou10523b32005-05-17 06:43:37 -04001797show_urbs (struct device *dev, struct device_attribute *attr, char *buf)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001798{
1799 struct usb_hcd *hcd = dev_get_drvdata (dev);
1800 struct dummy *dum = hcd_to_dummy (hcd);
1801 struct urbp *urbp;
1802 size_t size = 0;
1803 unsigned long flags;
1804
1805 spin_lock_irqsave (&dum->lock, flags);
1806 list_for_each_entry (urbp, &dum->urbp_list, urbp_list) {
1807 size_t temp;
1808
1809 temp = show_urb (buf, PAGE_SIZE - size, urbp->urb);
1810 buf += temp;
1811 size += temp;
1812 }
1813 spin_unlock_irqrestore (&dum->lock, flags);
1814
1815 return size;
1816}
1817static DEVICE_ATTR (urbs, S_IRUGO, show_urbs, NULL);
1818
1819static int dummy_start (struct usb_hcd *hcd)
1820{
1821 struct dummy *dum;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001822
1823 dum = hcd_to_dummy (hcd);
1824
1825 /*
1826 * MASTER side init ... we emulate a root hub that'll only ever
1827 * talk to one device (the slave side). Also appears in sysfs,
1828 * just like more familiar pci-based HCDs.
1829 */
1830 spin_lock_init (&dum->lock);
1831 init_timer (&dum->timer);
1832 dum->timer.function = dummy_timer;
1833 dum->timer.data = (unsigned long) dum;
Alan Stern391eca92005-05-10 15:34:16 -04001834 dum->rh_state = DUMMY_RH_RUNNING;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001835
1836 INIT_LIST_HEAD (&dum->urbp_list);
1837
Alan Sternbc96c0a2005-04-25 11:21:31 -04001838 /* only show a low-power port: just 8mA */
1839 hcd->power_budget = 8;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001840 hcd->state = HC_STATE_RUNNING;
Alan Stern685eb932005-05-03 16:27:26 -04001841 hcd->uses_new_polling = 1;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001842
Alan Stern5742b0c2005-05-02 11:25:17 -04001843#ifdef CONFIG_USB_OTG
1844 hcd->self.otg_port = 1;
1845#endif
1846
Linus Torvalds1da177e2005-04-16 15:20:36 -07001847 /* FIXME 'urbs' should be a per-device thing, maybe in usbcore */
Alan Sternefd54a32006-09-25 11:55:56 -04001848 return device_create_file (dummy_dev(dum), &dev_attr_urbs);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001849}
1850
1851static void dummy_stop (struct usb_hcd *hcd)
1852{
1853 struct dummy *dum;
1854
1855 dum = hcd_to_dummy (hcd);
1856
1857 device_remove_file (dummy_dev(dum), &dev_attr_urbs);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001858 usb_gadget_unregister_driver (dum->driver);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001859 dev_info (dummy_dev(dum), "stopped\n");
1860}
1861
1862/*-------------------------------------------------------------------------*/
1863
1864static int dummy_h_get_frame (struct usb_hcd *hcd)
1865{
1866 return dummy_g_get_frame (NULL);
1867}
1868
1869static const struct hc_driver dummy_hcd = {
1870 .description = (char *) driver_name,
1871 .product_desc = "Dummy host controller",
1872 .hcd_priv_size = sizeof(struct dummy),
1873
1874 .flags = HCD_USB2,
1875
1876 .start = dummy_start,
1877 .stop = dummy_stop,
1878
1879 .urb_enqueue = dummy_urb_enqueue,
1880 .urb_dequeue = dummy_urb_dequeue,
1881
1882 .get_frame_number = dummy_h_get_frame,
1883
1884 .hub_status_data = dummy_hub_status,
1885 .hub_control = dummy_hub_control,
Alan Stern0c0382e2005-10-13 17:08:02 -04001886 .bus_suspend = dummy_bus_suspend,
1887 .bus_resume = dummy_bus_resume,
Linus Torvalds1da177e2005-04-16 15:20:36 -07001888};
1889
Alan Stern8364d6b2005-11-14 12:16:30 -05001890static int dummy_hcd_probe(struct platform_device *pdev)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001891{
1892 struct usb_hcd *hcd;
1893 int retval;
1894
Alan Stern8364d6b2005-11-14 12:16:30 -05001895 dev_info(&pdev->dev, "%s, driver " DRIVER_VERSION "\n", driver_desc);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001896
Alan Stern8364d6b2005-11-14 12:16:30 -05001897 hcd = usb_create_hcd(&dummy_hcd, &pdev->dev, pdev->dev.bus_id);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001898 if (!hcd)
1899 return -ENOMEM;
1900 the_controller = hcd_to_dummy (hcd);
1901
1902 retval = usb_add_hcd(hcd, 0, 0);
1903 if (retval != 0) {
1904 usb_put_hcd (hcd);
1905 the_controller = NULL;
1906 }
1907 return retval;
1908}
1909
Alan Stern8364d6b2005-11-14 12:16:30 -05001910static int dummy_hcd_remove (struct platform_device *pdev)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001911{
1912 struct usb_hcd *hcd;
1913
Alan Stern8364d6b2005-11-14 12:16:30 -05001914 hcd = platform_get_drvdata (pdev);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001915 usb_remove_hcd (hcd);
1916 usb_put_hcd (hcd);
1917 the_controller = NULL;
Alan Sternd9b76252005-05-03 16:15:43 -04001918 return 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001919}
1920
Alan Stern8364d6b2005-11-14 12:16:30 -05001921static int dummy_hcd_suspend (struct platform_device *pdev, pm_message_t state)
Alan Stern391eca92005-05-10 15:34:16 -04001922{
1923 struct usb_hcd *hcd;
Alan Stern3cf0a222005-11-29 12:08:15 -05001924 struct dummy *dum;
1925 int rc = 0;
Alan Stern391eca92005-05-10 15:34:16 -04001926
Alan Stern8364d6b2005-11-14 12:16:30 -05001927 dev_dbg (&pdev->dev, "%s\n", __FUNCTION__);
Alan Stern391eca92005-05-10 15:34:16 -04001928
Alan Stern3cf0a222005-11-29 12:08:15 -05001929 hcd = platform_get_drvdata (pdev);
1930 dum = hcd_to_dummy (hcd);
1931 if (dum->rh_state == DUMMY_RH_RUNNING) {
1932 dev_warn(&pdev->dev, "Root hub isn't suspended!\n");
1933 rc = -EBUSY;
1934 } else
1935 clear_bit(HCD_FLAG_HW_ACCESSIBLE, &hcd->flags);
1936 return rc;
Alan Stern391eca92005-05-10 15:34:16 -04001937}
1938
Alan Stern8364d6b2005-11-14 12:16:30 -05001939static int dummy_hcd_resume (struct platform_device *pdev)
Alan Stern391eca92005-05-10 15:34:16 -04001940{
1941 struct usb_hcd *hcd;
1942
Alan Stern8364d6b2005-11-14 12:16:30 -05001943 dev_dbg (&pdev->dev, "%s\n", __FUNCTION__);
Alan Stern391eca92005-05-10 15:34:16 -04001944
Alan Stern3cf0a222005-11-29 12:08:15 -05001945 hcd = platform_get_drvdata (pdev);
1946 set_bit(HCD_FLAG_HW_ACCESSIBLE, &hcd->flags);
Alan Stern391eca92005-05-10 15:34:16 -04001947 usb_hcd_poll_rh_status (hcd);
1948 return 0;
1949}
1950
Russell King3ae5eae2005-11-09 22:32:44 +00001951static struct platform_driver dummy_hcd_driver = {
Alan Sternd9b76252005-05-03 16:15:43 -04001952 .probe = dummy_hcd_probe,
1953 .remove = dummy_hcd_remove,
Alan Stern391eca92005-05-10 15:34:16 -04001954 .suspend = dummy_hcd_suspend,
1955 .resume = dummy_hcd_resume,
Russell King3ae5eae2005-11-09 22:32:44 +00001956 .driver = {
1957 .name = (char *) driver_name,
1958 .owner = THIS_MODULE,
1959 },
Alan Sternd9b76252005-05-03 16:15:43 -04001960};
1961
Linus Torvalds1da177e2005-04-16 15:20:36 -07001962/*-------------------------------------------------------------------------*/
1963
Alan Sternd9b76252005-05-03 16:15:43 -04001964/* These don't need to do anything because the pdev structures are
1965 * statically allocated. */
1966static void
1967dummy_udc_release (struct device *dev) {}
Linus Torvalds1da177e2005-04-16 15:20:36 -07001968
Alan Sternd9b76252005-05-03 16:15:43 -04001969static void
1970dummy_hcd_release (struct device *dev) {}
Linus Torvalds1da177e2005-04-16 15:20:36 -07001971
Alan Sternd9b76252005-05-03 16:15:43 -04001972static struct platform_device the_udc_pdev = {
1973 .name = (char *) gadget_name,
1974 .id = -1,
1975 .dev = {
1976 .release = dummy_udc_release,
1977 },
1978};
Linus Torvalds1da177e2005-04-16 15:20:36 -07001979
Alan Sternd9b76252005-05-03 16:15:43 -04001980static struct platform_device the_hcd_pdev = {
1981 .name = (char *) driver_name,
1982 .id = -1,
1983 .dev = {
1984 .release = dummy_hcd_release,
1985 },
1986};
Linus Torvalds1da177e2005-04-16 15:20:36 -07001987
1988static int __init init (void)
1989{
1990 int retval;
1991
1992 if (usb_disabled ())
1993 return -ENODEV;
Alan Sternd9b76252005-05-03 16:15:43 -04001994
Russell King3ae5eae2005-11-09 22:32:44 +00001995 retval = platform_driver_register (&dummy_hcd_driver);
Alan Sternd9b76252005-05-03 16:15:43 -04001996 if (retval < 0)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001997 return retval;
Alan Sternd9b76252005-05-03 16:15:43 -04001998
Russell King3ae5eae2005-11-09 22:32:44 +00001999 retval = platform_driver_register (&dummy_udc_driver);
Alan Sternd9b76252005-05-03 16:15:43 -04002000 if (retval < 0)
2001 goto err_register_udc_driver;
2002
2003 retval = platform_device_register (&the_hcd_pdev);
2004 if (retval < 0)
2005 goto err_register_hcd;
2006
2007 retval = platform_device_register (&the_udc_pdev);
2008 if (retval < 0)
2009 goto err_register_udc;
2010 return retval;
2011
2012err_register_udc:
2013 platform_device_unregister (&the_hcd_pdev);
2014err_register_hcd:
Russell King3ae5eae2005-11-09 22:32:44 +00002015 platform_driver_unregister (&dummy_udc_driver);
Alan Sternd9b76252005-05-03 16:15:43 -04002016err_register_udc_driver:
Russell King3ae5eae2005-11-09 22:32:44 +00002017 platform_driver_unregister (&dummy_hcd_driver);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002018 return retval;
2019}
2020module_init (init);
2021
2022static void __exit cleanup (void)
2023{
Alan Sternd9b76252005-05-03 16:15:43 -04002024 platform_device_unregister (&the_udc_pdev);
2025 platform_device_unregister (&the_hcd_pdev);
Russell King3ae5eae2005-11-09 22:32:44 +00002026 platform_driver_unregister (&dummy_udc_driver);
2027 platform_driver_unregister (&dummy_hcd_driver);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002028}
2029module_exit (cleanup);