drivers/usb/gadget/dummy_hcd.c

   1 /*
   2  * dummy_hcd.c -- Dummy/Loopback USB host and device emulator driver.
   3  *
   4  * Maintainer: Alan Stern <stern@rowland.harvard.edu>
   5  *
   6  * Copyright (C) 2003 David Brownell
   7  * Copyright (C) 2003, 2004 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
  39 #include <linux/config.h>
  40 #include <linux/module.h>
  41 #include <linux/kernel.h>
  42 #include <linux/delay.h>
  43 #include <linux/ioport.h>
  44 #include <linux/sched.h>
  45 #include <linux/slab.h>
  46 #include <linux/smp_lock.h>
  47 #include <linux/errno.h>
  48 #include <linux/init.h>
  49 #include <linux/timer.h>
  50 #include <linux/list.h>
  51 #include <linux/interrupt.h>
  52 #include <linux/version.h>
  53
  54 #include <linux/usb.h>
  55 #include <linux/usb_gadget.h>
  56
  57 #include <asm/byteorder.h>
  58 #include <asm/io.h>
  59 #include <asm/irq.h>
  60 #include <asm/system.h>
  61 #include <asm/unaligned.h>
  62
  63
  64 #include "../core/hcd.h"
  65
  66
  67 #define DRIVER_DESC     "USB Host+Gadget Emulator"
  68 #define DRIVER_VERSION  "14 Mar 2004"
  69
  70 static const char       driver_name [] = "dummy_hcd";
  71 static const char       driver_desc [] = "USB Host+Gadget Emulator";
  72
  73 static const char       gadget_name [] = "dummy_udc";
  74
  75 MODULE_DESCRIPTION (DRIVER_DESC);
  76 MODULE_AUTHOR ("David Brownell");
  77 MODULE_LICENSE ("GPL");
  78
  79 /*-------------------------------------------------------------------------*/
  80
  81 /* gadget side driver data structres */
  82 struct dummy_ep {
  83         struct list_head                queue;
  84         unsigned long                   last_io;        /* jiffies timestamp */
  85         struct usb_gadget               *gadget;
  86         const struct usb_endpoint_descriptor *desc;
  87         struct usb_ep                   ep;
  88         unsigned                        halted : 1;
  89         unsigned                        already_seen : 1;
  90         unsigned                        setup_stage : 1;
  91 };
  92
  93 struct dummy_request {
  94         struct list_head                queue;          /* ep's requests */
  95         struct usb_request              req;
  96 };
  97
  98 /*-------------------------------------------------------------------------*/
  99
 100 /*
 101  * Every device has ep0 for control requests, plus up to 30 more endpoints,
 102  * in one of two types:
 103  *
 104  *   - Configurable:  direction (in/out), type (bulk, iso, etc), and endpoint
 105  *     number can be changed.  Names like "ep-a" are used for this type.
 106  *
 107  *   - Fixed Function:  in other cases.  some characteristics may be mutable;
 108  *     that'd be hardware-specific.  Names like "ep12out-bulk" are used.
 109  *
 110  * Gadget drivers are responsible for not setting up conflicting endpoint
 111  * configurations, illegal or unsupported packet lengths, and so on.
 112  */
 113
 114 static const char ep0name [] = "ep0";
 115
 116 static const char *const ep_name [] = {
 117         ep0name,                                /* everyone has ep0 */
 118
 119         /* act like a net2280: high speed, six configurable endpoints */
 120         "ep-a", "ep-b", "ep-c", "ep-d", "ep-e", "ep-f",
 121
 122         /* or like pxa250: fifteen fixed function endpoints */
 123         "ep1in-bulk", "ep2out-bulk", "ep3in-iso", "ep4out-iso", "ep5in-int",
 124         "ep6in-bulk", "ep7out-bulk", "ep8in-iso", "ep9out-iso", "ep10in-int",
 125         "ep11in-bulk", "ep12out-bulk", "ep13in-iso", "ep14out-iso",
 126                 "ep15in-int",
 127
 128         /* or like sa1100: two fixed function endpoints */
 129         "ep1out-bulk", "ep2in-bulk",
 130 };
 131 #define DUMMY_ENDPOINTS (sizeof(ep_name)/sizeof(char *))
 132
 133 #define FIFO_SIZE               64
 134
 135 struct dummy {
 136         spinlock_t                      lock;
 137
 138         /*
 139          * SLAVE/GADGET side support
 140          */
 141         struct dummy_ep                 ep [DUMMY_ENDPOINTS];
 142         int                             address;
 143         struct usb_gadget               gadget;
 144         struct usb_gadget_driver        *driver;
 145         struct dummy_request            fifo_req;
 146         u8                              fifo_buf [FIFO_SIZE];
 147
 148         struct hcd_dev                  *hdev;
 149
 150         /*
 151          * MASTER/HOST side support
 152          */
 153         struct usb_hcd                  hcd;
 154         struct platform_device          pdev;
 155         struct timer_list               timer;
 156         u32                             port_status;
 157         int                             started;
 158         struct completion               released;
 159 };
 160
 161 static struct dummy     *the_controller;
 162
 163 static inline struct dummy *ep_to_dummy (struct dummy_ep *ep)
 164 {
 165         return container_of (ep->gadget, struct dummy, gadget);
 166 }
 167
 168 static inline struct dummy *gadget_dev_to_dummy (struct device *dev)
 169 {
 170         return container_of (dev, struct dummy, gadget.dev);
 171 }
 172
 173 /*
 174  * This "hardware" may look a bit odd in diagnostics since it's got both
 175  * host and device sides; and it binds different drivers to each side.
 176  */
 177 #define hardware        (&the_controller->pdev.dev)
 178
 179 /*-------------------------------------------------------------------------*/
 180
 181 static struct device_driver dummy_driver = {
 182         .name           = (char *) driver_name,
 183         .bus            = &platform_bus_type,
 184 };
 185
 186 /*-------------------------------------------------------------------------*/
 187
 188 /* SLAVE/GADGET SIDE DRIVER
 189  *
 190  * This only tracks gadget state.  All the work is done when the host
 191  * side tries some (emulated) i/o operation.  Real device controller
 192  * drivers would do real i/o using dma, fifos, irqs, timers, etc.
 193  */
 194
 195 #define is_enabled() \
 196         (the_controller->port_status & USB_PORT_STAT_ENABLE)
 197
 198 static int
 199 dummy_enable (struct usb_ep *_ep, const struct usb_endpoint_descriptor *desc)
 200 {
 201         struct dummy            *dum;
 202         struct dummy_ep         *ep;
 203         unsigned                max;
 204         int                     retval;
 205
 206         ep = container_of (_ep, struct dummy_ep, ep);
 207         if (!_ep || !desc || ep->desc || _ep->name == ep0name
 208                         || desc->bDescriptorType != USB_DT_ENDPOINT)
 209         if (!the_controller->driver || !is_enabled ())
 210                 return -ESHUTDOWN;
 211         max = desc->wMaxPacketSize & 0x3ff;
 212
 213         /* drivers must not request bad settings, since lower levels
 214          * (hardware or its drivers) may not check.  some endpoints
 215          * can't do iso, many have maxpacket limitations, etc.
 216          *
 217          * since this "hardware" driver is here to help debugging, we
 218          * have some extra sanity checks.  (there could be more though,
 219          * especially for "ep9out" style fixed function ones.)
 220          */
 221         dum = container_of (ep->gadget, struct dummy, gadget);
 222         retval = -EINVAL;
 223         switch (desc->bmAttributes & 0x03) {
 224         case USB_ENDPOINT_XFER_BULK:
 225                 if (strstr (ep->ep.name, "-iso")
 226                                 || strstr (ep->ep.name, "-int")) {
 227                         goto done;
 228                 }
 229                 switch (dum->gadget.speed) {
 230                 case USB_SPEED_HIGH:
 231                         if (max == 512)
 232                                 break;
 233                         /* conserve return statements */
 234                 default:
 235                         switch (max) {
 236                         case 8: case 16: case 32: case 64:
 237                                 /* we'll fake any legal size */
 238                                 break;
 239                         default:
 240                 case USB_SPEED_LOW:
 241                                 goto done;
 242                         }
 243                 }
 244                 break;
 245         case USB_ENDPOINT_XFER_INT:
 246                 if (strstr (ep->ep.name, "-iso")) /* bulk is ok */
 247                         goto done;
 248                 /* real hardware might not handle all packet sizes */
 249                 switch (dum->gadget.speed) {
 250                 case USB_SPEED_HIGH:
 251                         if (max <= 1024)
 252                                 break;
 253                         /* save a return statement */
 254                 case USB_SPEED_FULL:
 255                         if (max <= 64)
 256                                 break;
 257                         /* save a return statement */
 258                 default:
 259                         if (max <= 8)
 260                                 break;
 261                         goto done;
 262                 }
 263                 break;
 264         case USB_ENDPOINT_XFER_ISOC:
 265                 if (strstr (ep->ep.name, "-bulk")
 266                                 || strstr (ep->ep.name, "-int"))
 267                         goto done;
 268                 /* real hardware might not handle all packet sizes */
 269                 switch (dum->gadget.speed) {
 270                 case USB_SPEED_HIGH:
 271                         if (max <= 1024)
 272                                 break;
 273                         /* save a return statement */
 274                 case USB_SPEED_FULL:
 275                         if (max <= 1023)
 276                                 break;
 277                         /* save a return statement */
 278                 default:
 279                         goto done;
 280                 }
 281                 break;
 282         default:
 283                 /* few chips support control except on ep0 */
 284                 goto done;
 285         }
 286
 287         _ep->maxpacket = max;
 288         ep->desc = desc;
 289
 290         dev_dbg (hardware, "enabled %s (ep%d%s-%s) maxpacket %d\n",
 291                 _ep->name,
 292                 desc->bEndpointAddress & 0x0f,
 293                 (desc->bEndpointAddress & USB_DIR_IN) ? "in" : "out",
 294                 ({ char *val;
 295                  switch (desc->bmAttributes & 0x03) {
 296                  case USB_ENDPOINT_XFER_BULK: val = "bulk"; break;
 297                  case USB_ENDPOINT_XFER_ISOC: val = "iso"; break;
 298                  case USB_ENDPOINT_XFER_INT: val = "intr"; break;
 299                  default: val = "ctrl"; break;
 300                  }; val; }),
 301                 max);
 302
 303         /* at this point real hardware should be NAKing transfers
 304          * to that endpoint, until a buffer is queued to it.
 305          */
 306         retval = 0;
 307 done:
 308         return retval;
 309 }
 310
 311 /* called with spinlock held */
 312 static void nuke (struct dummy *dum, struct dummy_ep *ep)
 313 {
 314         while (!list_empty (&ep->queue)) {
 315                 struct dummy_request    *req;
 316
 317                 req = list_entry (ep->queue.next, struct dummy_request, queue);
 318                 list_del_init (&req->queue);
 319                 req->req.status = -ESHUTDOWN;
 320
 321                 spin_unlock (&dum->lock);
 322                 req->req.complete (&ep->ep, &req->req);
 323                 spin_lock (&dum->lock);
 324         }
 325 }
 326
 327 static int dummy_disable (struct usb_ep *_ep)
 328 {
 329         struct dummy_ep         *ep;
 330         struct dummy            *dum;
 331         unsigned long           flags;
 332         int                     retval;
 333
 334         ep = container_of (_ep, struct dummy_ep, ep);
 335         if (!_ep || !ep->desc || _ep->name == ep0name)
 336                 return -EINVAL;
 337         dum = ep_to_dummy (ep);
 338
 339         spin_lock_irqsave (&dum->lock, flags);
 340         ep->desc = 0;
 341         retval = 0;
 342         nuke (dum, ep);
 343         spin_unlock_irqrestore (&dum->lock, flags);
 344
 345         dev_dbg (hardware, "disabled %s\n", _ep->name);
 346         return retval;
 347 }
 348
 349 static struct usb_request *
 350 dummy_alloc_request (struct usb_ep *_ep, int mem_flags)
 351 {
 352         struct dummy_ep         *ep;
 353         struct dummy_request    *req;
 354
 355         ep = container_of (_ep, struct dummy_ep, ep);
 356         if (!_ep)
 357                 return 0;
 358
 359         req = kmalloc (sizeof *req, mem_flags);
 360         if (!req)
 361                 return 0;
 362         memset (req, 0, sizeof *req);
 363         INIT_LIST_HEAD (&req->queue);
 364         return &req->req;
 365 }
 366
 367 static void
 368 dummy_free_request (struct usb_ep *_ep, struct usb_request *_req)
 369 {
 370         struct dummy_ep         *ep;
 371         struct dummy_request    *req;
 372
 373         ep = container_of (_ep, struct dummy_ep, ep);
 374         if (!ep || !_req || (!ep->desc && _ep->name != ep0name))
 375                 return;
 376
 377         req = container_of (_req, struct dummy_request, req);
 378         WARN_ON (!list_empty (&req->queue));
 379         kfree (req);
 380 }
 381
 382 static void *
 383 dummy_alloc_buffer (
 384         struct usb_ep *_ep,
 385         unsigned bytes,
 386         dma_addr_t *dma,
 387         int mem_flags
 388 ) {
 389         char *retval;
 390
 391         if (!the_controller->driver)
 392                 return 0;
 393         retval = kmalloc (bytes, mem_flags);
 394         *dma = (dma_addr_t) retval;
 395         return retval;
 396 }
 397
 398 static void
 399 dummy_free_buffer (
 400         struct usb_ep *_ep,
 401         void *buf,
 402         dma_addr_t dma,
 403         unsigned bytes
 404 ) {
 405         if (bytes)
 406                 kfree (buf);
 407 }
 408
 409 static void
 410 fifo_complete (struct usb_ep *ep, struct usb_request *req)
 411 {
 412 #if 0
 413         dev_dbg (hardware, "fifo_complete: %d\n", req->status);
 414 #endif
 415 }
 416
 417 static int
 418 dummy_queue (struct usb_ep *_ep, struct usb_request *_req, int mem_flags)
 419 {
 420         struct dummy_ep         *ep;
 421         struct dummy_request    *req;
 422         struct dummy            *dum;
 423         unsigned long           flags;
 424
 425         req = container_of (_req, struct dummy_request, req);
 426         if (!_req || !list_empty (&req->queue) || !_req->complete)
 427                 return -EINVAL;
 428
 429         ep = container_of (_ep, struct dummy_ep, ep);
 430         if (!_ep || (!ep->desc && _ep->name != ep0name))
 431                 return -EINVAL;
 432
 433         if (!the_controller->driver || !is_enabled ())
 434                 return -ESHUTDOWN;
 435
 436         dum = container_of (ep->gadget, struct dummy, gadget);
 437
 438 #if 0
 439         dev_dbg (hardware, "ep %p queue req %p to %s, len %d buf %p\n",
 440                         ep, _req, _ep->name, _req->length, _req->buf);
 441 #endif
 442
 443         _req->status = -EINPROGRESS;
 444         _req->actual = 0;
 445         spin_lock_irqsave (&dum->lock, flags);
 446
 447         /* implement an emulated single-request FIFO */
 448         if (ep->desc && (ep->desc->bEndpointAddress & USB_DIR_IN) &&
 449                         list_empty (&dum->fifo_req.queue) &&
 450                         list_empty (&ep->queue) &&
 451                         _req->length <= FIFO_SIZE) {
 452                 req = &dum->fifo_req;
 453                 req->req = *_req;
 454                 req->req.buf = dum->fifo_buf;
 455                 memcpy (dum->fifo_buf, _req->buf, _req->length);
 456                 req->req.context = dum;
 457                 req->req.complete = fifo_complete;
 458
 459                 spin_unlock (&dum->lock);
 460                 _req->actual = _req->length;
 461                 _req->status = 0;
 462                 _req->complete (_ep, _req);
 463                 spin_lock (&dum->lock);
 464         }
 465         list_add_tail (&req->queue, &ep->queue);
 466         spin_unlock_irqrestore (&dum->lock, flags);
 467
 468         /* real hardware would likely enable transfers here, in case
 469          * it'd been left NAKing.
 470          */
 471         return 0;
 472 }
 473
 474 static int dummy_dequeue (struct usb_ep *_ep, struct usb_request *_req)
 475 {
 476         struct dummy_ep         *ep;
 477         struct dummy            *dum;
 478         int                     retval = -EINVAL;
 479         unsigned long           flags;
 480         struct dummy_request    *req = 0;
 481
 482         if (!the_controller->driver)
 483                 return -ESHUTDOWN;
 484
 485         if (!_ep || !_req)
 486                 return retval;
 487         ep = container_of (_ep, struct dummy_ep, ep);
 488         dum = container_of (ep->gadget, struct dummy, gadget);
 489
 490         spin_lock_irqsave (&dum->lock, flags);
 491         list_for_each_entry (req, &ep->queue, queue) {
 492                 if (&req->req == _req) {
 493                         list_del_init (&req->queue);
 494                         _req->status = -ECONNRESET;
 495                         retval = 0;
 496                         break;
 497                 }
 498         }
 499         spin_unlock_irqrestore (&dum->lock, flags);
 500
 501         if (retval == 0) {
 502                 dev_dbg (hardware, "dequeued req %p from %s, len %d buf %p\n",
 503                                 req, _ep->name, _req->length, _req->buf);
 504
 505                 _req->complete (_ep, _req);
 506         }
 507         return retval;
 508 }
 509
 510 static int
 511 dummy_set_halt (struct usb_ep *_ep, int value)
 512 {
 513         struct dummy_ep         *ep;
 514
 515         if (!_ep)
 516                 return -EINVAL;
 517         if (!the_controller->driver)
 518                 return -ESHUTDOWN;
 519         ep = container_of (_ep, struct dummy_ep, ep);
 520         if (!value)
 521                 ep->halted = 0;
 522         else if (ep->desc && (ep->desc->bEndpointAddress & USB_DIR_IN) &&
 523                         !list_empty (&ep->queue))
 524                 return -EAGAIN;
 525         else
 526                 ep->halted = 1;
 527         /* FIXME clear emulated data toggle too */
 528         return 0;
 529 }
 530
 531 static const struct usb_ep_ops dummy_ep_ops = {
 532         .enable         = dummy_enable,
 533         .disable        = dummy_disable,
 534
 535         .alloc_request  = dummy_alloc_request,
 536         .free_request   = dummy_free_request,
 537
 538         .alloc_buffer   = dummy_alloc_buffer,
 539         .free_buffer    = dummy_free_buffer,
 540         /* map, unmap, ... eventually hook the "generic" dma calls */
 541
 542         .queue          = dummy_queue,
 543         .dequeue        = dummy_dequeue,
 544
 545         .set_halt       = dummy_set_halt,
 546 };
 547
 548 /*-------------------------------------------------------------------------*/
 549
 550 /* there are both host and device side versions of this call ... */
 551 static int dummy_g_get_frame (struct usb_gadget *_gadget)
 552 {
 553         struct timeval  tv;
 554
 555         do_gettimeofday (&tv);
 556         return tv.tv_usec / 1000;
 557 }
 558
 559 static const struct usb_gadget_ops dummy_ops = {
 560         .get_frame      = dummy_g_get_frame,
 561 };
 562
 563 /*-------------------------------------------------------------------------*/
 564
 565 /* "function" sysfs attribute */
 566 static ssize_t
 567 show_function (struct device *_dev, char *buf)
 568 {
 569         struct dummy    *dum = the_controller;
 570
 571         if (!dum->driver->function
 572                         || strlen (dum->driver->function) > PAGE_SIZE)
 573                 return 0;
 574         return snprintf (buf, PAGE_SIZE, "%s\n", dum->driver->function);
 575 }
 576 DEVICE_ATTR (function, S_IRUGO, show_function, NULL);
 577
 578 /*-------------------------------------------------------------------------*/
 579
 580 /*
 581  * Driver registration/unregistration.
 582  *
 583  * This is basically hardware-specific; there's usually only one real USB
 584  * device (not host) controller since that's how USB devices are intended
 585  * to work.  So most implementations of these api calls will rely on the
 586  * fact that only one driver will ever bind to the hardware.  But curious
 587  * hardware can be built with discrete components, so the gadget API doesn't
 588  * require that assumption.
 589  *
 590  * For this emulator, it might be convenient to create a usb slave device
 591  * for each driver that registers:  just add to a big root hub.
 592  */
 593
 594 static void
 595 dummy_udc_release (struct device *dev)
 596 {
 597         struct dummy    *dum = gadget_dev_to_dummy (dev);
 598
 599         complete (&dum->released);
 600 }
 601
 602 static void
 603 dummy_hc_release (struct device *dev)
 604 {
 605         struct dummy    *dum = dev_get_drvdata (dev);
 606
 607         complete (&dum->released);
 608 }
 609
 610 static int
 611 dummy_register_udc (struct dummy *dum)
 612 {
 613         int             rc;
 614
 615         strcpy (dum->gadget.dev.bus_id, "udc");
 616         dum->gadget.dev.parent = &dum->pdev.dev;
 617         dum->gadget.dev.release = dummy_udc_release;
 618
 619         rc = device_register (&dum->gadget.dev);
 620         if (rc == 0)
 621                 device_create_file (&dum->gadget.dev, &dev_attr_function);
 622         return rc;
 623 }
 624
 625 static void
 626 dummy_unregister_udc (struct dummy *dum)
 627 {
 628         device_remove_file (&dum->gadget.dev, &dev_attr_function);
 629         init_completion (&dum->released);
 630         device_unregister (&dum->gadget.dev);
 631         wait_for_completion (&dum->released);
 632 }
 633
 634 int
 635 usb_gadget_register_driver (struct usb_gadget_driver *driver)
 636 {
 637         struct dummy    *dum = the_controller;
 638         int             retval, i;
 639
 640         if (!dum)
 641                 return -EINVAL;
 642         if (dum->driver)
 643                 return -EBUSY;
 644         if (!driver->bind || !driver->unbind || !driver->setup
 645                         || driver->speed == USB_SPEED_UNKNOWN)
 646                 return -EINVAL;
 647
 648         /*
 649          * SLAVE side init ... the layer above hardware, which
 650          * can't enumerate without help from the driver we're binding.
 651          */
 652         dum->gadget.name = gadget_name;
 653         dum->gadget.ops = &dummy_ops;
 654         dum->gadget.is_dualspeed = 1;
 655
 656         INIT_LIST_HEAD (&dum->gadget.ep_list);
 657         for (i = 0; i < DUMMY_ENDPOINTS; i++) {
 658                 struct dummy_ep *ep = &dum->ep [i];
 659
 660                 if (!ep_name [i])
 661                         break;
 662                 ep->ep.name = ep_name [i];
 663                 ep->ep.ops = &dummy_ep_ops;
 664                 list_add_tail (&ep->ep.ep_list, &dum->gadget.ep_list);
 665                 ep->halted = ep->already_seen = ep->setup_stage = 0;
 666                 ep->ep.maxpacket = ~0;
 667                 ep->last_io = jiffies;
 668                 ep->gadget = &dum->gadget;
 669                 ep->desc = 0;
 670                 INIT_LIST_HEAD (&ep->queue);
 671         }
 672
 673         dum->gadget.ep0 = &dum->ep [0].ep;
 674         dum->ep [0].ep.maxpacket = 64;
 675         list_del_init (&dum->ep [0].ep.ep_list);
 676         INIT_LIST_HEAD(&dum->fifo_req.queue);
 677
 678         dum->driver = driver;
 679         dum->gadget.dev.driver = &driver->driver;
 680         dev_dbg (hardware, "binding gadget driver '%s'\n", driver->driver.name);
 681         if ((retval = driver->bind (&dum->gadget)) != 0) {
 682                 dum->driver = 0;
 683                 dum->gadget.dev.driver = 0;
 684                 return retval;
 685         }
 686
 687         // FIXME: Check these calls for errors and re-order
 688         driver->driver.bus = dum->pdev.dev.bus;
 689         driver_register (&driver->driver);
 690
 691         device_bind_driver (&dum->gadget.dev);
 692
 693         /* khubd will enumerate this in a while */
 694         dum->port_status |= USB_PORT_STAT_CONNECTION
 695                 | (1 << USB_PORT_FEAT_C_CONNECTION);
 696         return 0;
 697 }
 698 EXPORT_SYMBOL (usb_gadget_register_driver);
 699
 700 /* caller must hold lock */
 701 static void
 702 stop_activity (struct dummy *dum, struct usb_gadget_driver *driver)
 703 {
 704         struct dummy_ep *ep;
 705
 706         /* prevent any more requests */
 707         dum->hdev = 0;
 708         dum->address = 0;
 709
 710         /* this might not succeed ... */
 711         del_timer (&dum->timer);
 712
 713         /* nuke any pending requests first, so driver i/o is quiesced */
 714         list_for_each_entry (ep, &dum->gadget.ep_list, ep.ep_list)
 715                 nuke (dum, ep);
 716
 717         /* driver now does any non-usb quiescing necessary */
 718         if (driver) {
 719                 spin_unlock (&dum->lock);
 720                 driver->disconnect (&dum->gadget);
 721                 spin_lock (&dum->lock);
 722         }
 723 }
 724
 725 int
 726 usb_gadget_unregister_driver (struct usb_gadget_driver *driver)
 727 {
 728         struct dummy    *dum = the_controller;
 729         unsigned long   flags;
 730
 731         if (!dum)
 732                 return -ENODEV;
 733         if (!driver || driver != dum->driver)
 734                 return -EINVAL;
 735
 736         dev_dbg (hardware, "unregister gadget driver '%s'\n",
 737                         driver->driver.name);
 738
 739         spin_lock_irqsave (&dum->lock, flags);
 740         stop_activity (dum, driver);
 741         dum->port_status &= ~USB_PORT_STAT_CONNECTION;
 742         dum->port_status |= (1 << USB_PORT_FEAT_C_CONNECTION);
 743         spin_unlock_irqrestore (&dum->lock, flags);
 744
 745         driver->unbind (&dum->gadget);
 746         dum->driver = 0;
 747
 748         device_release_driver (&dum->gadget.dev);
 749
 750         driver_unregister (&driver->driver);
 751
 752         del_timer_sync (&dum->timer);
 753         return 0;
 754 }
 755 EXPORT_SYMBOL (usb_gadget_unregister_driver);
 756
 757 #undef is_enabled
 758
 759 int net2280_set_fifo_mode (struct usb_gadget *gadget, int mode)
 760 {
 761         return -ENOSYS;
 762 }
 763 EXPORT_SYMBOL (net2280_set_fifo_mode);
 764
 765 /*-------------------------------------------------------------------------*/
 766
 767 /* MASTER/HOST SIDE DRIVER
 768  *
 769  * this uses the hcd framework to hook up to host side drivers.
 770  * its root hub will only have one device, otherwise it acts like
 771  * a normal host controller.
 772  *
 773  * when urbs are queued, they're just stuck on a list that we
 774  * scan in a timer callback.  that callback connects writes from
 775  * the host with reads from the device, and so on, based on the
 776  * usb 2.0 rules.
 777  */
 778
 779 static int dummy_urb_enqueue (
 780         struct usb_hcd  *hcd,
 781         struct urb      *urb,
 782         int             mem_flags
 783 ) {
 784         struct dummy    *dum;
 785         unsigned long   flags;
 786
 787         /* patch to usb_sg_init() is in 2.5.60 */
 788         BUG_ON (!urb->transfer_buffer && urb->transfer_buffer_length);
 789
 790         dum = container_of (hcd, struct dummy, hcd);
 791         spin_lock_irqsave (&dum->lock, flags);
 792
 793         if (!dum->hdev)
 794                 dum->hdev = urb->dev->hcpriv;
 795         urb->hcpriv = dum;
 796         if (usb_pipetype (urb->pipe) == PIPE_CONTROL)
 797                 urb->error_count = 1;           /* mark as a new urb */
 798
 799         /* kick the scheduler, it'll do the rest */
 800         if (!timer_pending (&dum->timer))
 801                 mod_timer (&dum->timer, jiffies + 1);
 802
 803         spin_unlock_irqrestore (&dum->lock, flags);
 804         return 0;
 805 }
 806
 807 static int dummy_urb_dequeue (struct usb_hcd *hcd, struct urb *urb)
 808 {
 809         /* giveback happens automatically in timer callback */
 810         return 0;
 811 }
 812
 813 static void maybe_set_status (struct urb *urb, int status)
 814 {
 815         spin_lock (&urb->lock);
 816         if (urb->status == -EINPROGRESS)
 817                 urb->status = status;
 818         spin_unlock (&urb->lock);
 819 }
 820
 821 /* transfer up to a frame's worth; caller must own lock */
 822 static int
 823 transfer (struct dummy *dum, struct urb *urb, struct dummy_ep *ep, int limit)
 824 {
 825         struct dummy_request    *req;
 826
 827 top:
 828         /* if there's no request queued, the device is NAKing; return */
 829         list_for_each_entry (req, &ep->queue, queue) {
 830                 unsigned        host_len, dev_len, len;
 831                 int             is_short, to_host;
 832                 int             rescan = 0;
 833
 834                 /* 1..N packets of ep->ep.maxpacket each ... the last one
 835                  * may be short (including zero length).
 836                  *
 837                  * writer can send a zlp explicitly (length 0) or implicitly
 838                  * (length mod maxpacket zero, and 'zero' flag); they always
 839                  * terminate reads.
 840                  */
 841                 host_len = urb->transfer_buffer_length - urb->actual_length;
 842                 dev_len = req->req.length - req->req.actual;
 843                 len = min (host_len, dev_len);
 844
 845                 /* FIXME update emulated data toggle too */
 846
 847                 to_host = usb_pipein (urb->pipe);
 848                 if (unlikely (len == 0))
 849                         is_short = 1;
 850                 else {
 851                         char            *ubuf, *rbuf;
 852
 853                         /* not enough bandwidth left? */
 854                         if (limit < ep->ep.maxpacket && limit < len)
 855                                 break;
 856                         len = min (len, (unsigned) limit);
 857                         if (len == 0)
 858                                 break;
 859
 860                         /* use an extra pass for the final short packet */
 861                         if (len > ep->ep.maxpacket) {
 862                                 rescan = 1;
 863                                 len -= (len % ep->ep.maxpacket);
 864                         }
 865                         is_short = (len % ep->ep.maxpacket) != 0;
 866
 867                         /* else transfer packet(s) */
 868                         ubuf = urb->transfer_buffer + urb->actual_length;
 869                         rbuf = req->req.buf + req->req.actual;
 870                         if (to_host)
 871                                 memcpy (ubuf, rbuf, len);
 872                         else
 873                                 memcpy (rbuf, ubuf, len);
 874                         ep->last_io = jiffies;
 875
 876                         limit -= len;
 877                         urb->actual_length += len;
 878                         req->req.actual += len;
 879                 }
 880
 881                 /* short packets terminate, maybe with overflow/underflow.
 882                  * it's only really an error to write too much.
 883                  *
 884                  * partially filling a buffer optionally blocks queue advances
 885                  * (so completion handlers can clean up the queue) but we don't
 886                  * need to emulate such data-in-flight.  so we only show part
 887                  * of the URB_SHORT_NOT_OK effect: completion status.
 888                  */
 889                 if (is_short) {
 890                         if (host_len == dev_len) {
 891                                 req->req.status = 0;
 892                                 maybe_set_status (urb, 0);
 893                         } else if (to_host) {
 894                                 req->req.status = 0;
 895                                 if (dev_len > host_len)
 896                                         maybe_set_status (urb, -EOVERFLOW);
 897                                 else
 898                                         maybe_set_status (urb,
 899                                                 (urb->transfer_flags
 900                                                         & URB_SHORT_NOT_OK)
 901                                                 ? -EREMOTEIO : 0);
 902                         } else if (!to_host) {
 903                                 maybe_set_status (urb, 0);
 904                                 if (host_len > dev_len)
 905                                         req->req.status = -EOVERFLOW;
 906                                 else
 907                                         req->req.status = 0;
 908                         }
 909
 910                 /* many requests terminate without a short packet */
 911                 } else {
 912                         if (req->req.length == req->req.actual
 913                                         && !req->req.zero)
 914                                 req->req.status = 0;
 915                         if (urb->transfer_buffer_length == urb->actual_length
 916                                         && !(urb->transfer_flags
 917                                                 & URB_ZERO_PACKET)) {
 918                                 maybe_set_status (urb, 0);
 919                         }
 920                 }
 921
 922                 /* device side completion --> continuable */
 923                 if (req->req.status != -EINPROGRESS) {
 924                         list_del_init (&req->queue);
 925
 926                         spin_unlock (&dum->lock);
 927                         req->req.complete (&ep->ep, &req->req);
 928                         spin_lock (&dum->lock);
 929
 930                         /* requests might have been unlinked... */
 931                         rescan = 1;
 932                 }
 933
 934                 /* host side completion --> terminate */
 935                 if (urb->status != -EINPROGRESS)
 936                         break;
 937
 938                 /* rescan to continue with any other queued i/o */
 939                 if (rescan)
 940                         goto top;
 941         }
 942         return limit;
 943 }
 944
 945 static int periodic_bytes (struct dummy *dum, struct dummy_ep *ep)
 946 {
 947         int     limit = ep->ep.maxpacket;
 948
 949         if (dum->gadget.speed == USB_SPEED_HIGH) {
 950                 int     tmp;
 951
 952                 /* high bandwidth mode */
 953                 tmp = ep->desc->wMaxPacketSize;
 954                 tmp = le16_to_cpu (tmp);
 955                 tmp = (tmp >> 11) & 0x03;
 956                 tmp *= 8 /* applies to entire frame */;
 957                 limit += limit * tmp;
 958         }
 959         return limit;
 960 }
 961
 962 static struct dummy_ep *find_endpoint (struct dummy *dum, u8 address)
 963 {
 964         int             i;
 965
 966         if ((address & ~USB_DIR_IN) == 0)
 967                 return &dum->ep [0];
 968         for (i = 1; i < DUMMY_ENDPOINTS; i++) {
 969                 struct dummy_ep *ep = &dum->ep [i];
 970
 971                 if (!ep->desc)
 972                         continue;
 973                 if (ep->desc->bEndpointAddress == address)
 974                         return ep;
 975         }
 976         return NULL;
 977 }
 978
 979 #define Dev_Request     (USB_TYPE_STANDARD | USB_RECIP_DEVICE)
 980 #define Dev_InRequest   (Dev_Request | USB_DIR_IN)
 981 #define Intf_Request    (USB_TYPE_STANDARD | USB_RECIP_INTERFACE)
 982 #define Intf_InRequest  (Intf_Request | USB_DIR_IN)
 983 #define Ep_Request      (USB_TYPE_STANDARD | USB_RECIP_ENDPOINT)
 984 #define Ep_InRequest    (Ep_Request | USB_DIR_IN)
 985
 986 /* drive both sides of the transfers; looks like irq handlers to
 987  * both drivers except the callbacks aren't in_irq().
 988  */
 989 static void dummy_timer (unsigned long _dum)
 990 {
 991         struct dummy            *dum = (struct dummy *) _dum;
 992         struct hcd_dev          *hdev = dum->hdev;
 993         struct list_head        *entry, *tmp;
 994         unsigned long           flags;
 995         int                     limit, total;
 996         int                     i;
 997
 998         if (!hdev) {
 999                 dev_err (hardware, "timer fired with device gone?\n");
1000                 return;
1001         }
1002
1003         /* simplistic model for one frame's bandwidth */
1004         switch (dum->gadget.speed) {
1005         case USB_SPEED_LOW:
1006                 total = 8/*bytes*/ * 12/*packets*/;
1007                 break;
1008         case USB_SPEED_FULL:
1009                 total = 64/*bytes*/ * 19/*packets*/;
1010                 break;
1011         case USB_SPEED_HIGH:
1012                 total = 512/*bytes*/ * 13/*packets*/ * 8/*uframes*/;
1013                 break;
1014         default:
1015                 dev_err (hardware, "bogus device speed\n");
1016                 return;
1017         }
1018
1019         /* FIXME if HZ != 1000 this will probably misbehave ... */
1020
1021         /* look at each urb queued by the host side driver */
1022         spin_lock_irqsave (&dum->lock, flags);
1023         for (i = 0; i < DUMMY_ENDPOINTS; i++) {
1024                 if (!ep_name [i])
1025                         break;
1026                 dum->ep [i].already_seen = 0;
1027         }
1028
1029 restart:
1030         list_for_each_safe (entry, tmp, &hdev->urb_list) {
1031                 struct urb              *urb;
1032                 struct dummy_request    *req;
1033                 u8                      address;
1034                 struct dummy_ep         *ep = 0;
1035                 int                     type;
1036
1037                 urb = list_entry (entry, struct urb, urb_list);
1038                 if (urb->status != -EINPROGRESS) {
1039                         /* likely it was just unlinked */
1040                         goto return_urb;
1041                 }
1042                 type = usb_pipetype (urb->pipe);
1043
1044                 /* used up this frame's non-periodic bandwidth?
1045                  * FIXME there's infinite bandwidth for control and
1046                  * periodic transfers ... unrealistic.
1047                  */
1048                 if (total <= 0 && type == PIPE_BULK)
1049                         continue;
1050
1051                 /* find the gadget's ep for this request (if configured) */
1052                 address = usb_pipeendpoint (urb->pipe);
1053                 if (usb_pipein (urb->pipe))
1054                         address |= USB_DIR_IN;
1055                 ep = find_endpoint(dum, address);
1056                 if (!ep) {
1057                         /* set_configuration() disagreement */
1058                         dev_err (hardware,
1059                                 "no ep configured for urb %p\n",
1060                                 urb);
1061                         maybe_set_status (urb, -ETIMEDOUT);
1062                         goto return_urb;
1063                 }
1064
1065                 if (ep->already_seen)
1066                         continue;
1067                 ep->already_seen = 1;
1068                 if (ep == &dum->ep [0] && urb->error_count) {
1069                         ep->setup_stage = 1;    /* a new urb */
1070                         urb->error_count = 0;
1071                 }
1072                 if (ep->halted && !ep->setup_stage) {
1073                         /* NOTE: must not be iso! */
1074                         dev_dbg (hardware, "ep %s halted, urb %p\n",
1075                                         ep->ep.name, urb);
1076                         maybe_set_status (urb, -EPIPE);
1077                         goto return_urb;
1078                 }
1079                 /* FIXME make sure both ends agree on maxpacket */
1080
1081                 /* handle control requests */
1082                 if (ep == &dum->ep [0] && ep->setup_stage) {
1083                         struct usb_ctrlrequest          setup;
1084                         int                             value = 1;
1085                         struct dummy_ep                 *ep2;
1086
1087                         setup = *(struct usb_ctrlrequest*) urb->setup_packet;
1088                         le16_to_cpus (&setup.wIndex);
1089                         le16_to_cpus (&setup.wValue);
1090                         le16_to_cpus (&setup.wLength);
1091                         if (setup.wLength != urb->transfer_buffer_length) {
1092                                 maybe_set_status (urb, -EOVERFLOW);
1093                                 goto return_urb;
1094                         }
1095
1096                         /* paranoia, in case of stale queued data */
1097                         list_for_each_entry (req, &ep->queue, queue) {
1098                                 list_del_init (&req->queue);
1099                                 req->req.status = -EOVERFLOW;
1100                                 dev_dbg (hardware, "stale req = %p\n", req);
1101
1102                                 spin_unlock (&dum->lock);
1103                                 req->req.complete (&ep->ep, &req->req);
1104                                 spin_lock (&dum->lock);
1105                                 ep->already_seen = 0;
1106                                 goto restart;
1107                         }
1108
1109                         /* gadget driver never sees set_address or operations
1110                          * on standard feature flags.  some hardware doesn't
1111                          * even expose them.
1112                          */
1113                         ep->last_io = jiffies;
1114                         ep->setup_stage = 0;
1115                         ep->halted = 0;
1116                         switch (setup.bRequest) {
1117                         case USB_REQ_SET_ADDRESS:
1118                                 if (setup.bRequestType != Dev_Request)
1119                                         break;
1120                                 if (dum->address != 0) {
1121                                         maybe_set_status (urb, -ETIMEDOUT);
1122                                         urb->actual_length = 0;
1123                                         goto return_urb;
1124                                 }
1125                                 dum->address = setup.wValue;
1126                                 maybe_set_status (urb, 0);
1127                                 dev_dbg (hardware, "set_address = %d\n",
1128                                                 setup.wValue);
1129                                 value = 0;
1130                                 break;
1131                         case USB_REQ_SET_FEATURE:
1132                                 if (setup.bRequestType == Dev_Request) {
1133                                         // remote wakeup, and (hs) test mode
1134                                         value = -EOPNOTSUPP;
1135                                 } else if (setup.bRequestType == Ep_Request) {
1136                                         // endpoint halt
1137                                         ep2 = find_endpoint (dum,
1138                                                         setup.wIndex);
1139                                         if (!ep2) {
1140                                                 value = -EOPNOTSUPP;
1141                                                 break;
1142                                         }
1143                                         ep2->halted = 1;
1144                                         value = 0;
1145                                         maybe_set_status (urb, 0);
1146                                 }
1147                                 break;
1148                         case USB_REQ_CLEAR_FEATURE:
1149                                 if (setup.bRequestType == Dev_Request) {
1150                                         // remote wakeup
1151                                         value = 0;
1152                                         maybe_set_status (urb, 0);
1153                                 } else if (setup.bRequestType == Ep_Request) {
1154                                         // endpoint halt
1155                                         ep2 = find_endpoint (dum,
1156                                                         setup.wIndex);
1157                                         if (!ep2) {
1158                                                 value = -EOPNOTSUPP;
1159                                                 break;
1160                                         }
1161                                         ep2->halted = 0;
1162                                         value = 0;
1163                                         maybe_set_status (urb, 0);
1164                                 }
1165                                 break;
1166                         case USB_REQ_GET_STATUS:
1167                                 if (setup.bRequestType == Dev_InRequest
1168                                                 || setup.bRequestType
1169                                                         == Intf_InRequest
1170                                                 || setup.bRequestType
1171                                                         == Ep_InRequest
1172                                                 ) {
1173                                         char *buf;
1174
1175                                         // device: remote wakeup, selfpowered
1176                                         // interface: nothing
1177                                         // endpoint: halt
1178                                         buf = (char *)urb->transfer_buffer;
1179                                         if (urb->transfer_buffer_length > 0) {
1180                                                 if (setup.bRequestType ==
1181                                                                 Ep_InRequest) {
1182         ep2 = find_endpoint (dum, setup.wIndex);
1183         if (!ep2) {
1184                 value = -EOPNOTSUPP;
1185                 break;
1186         }
1187         buf [0] = ep2->halted;
1188                                                 } else
1189                                                         buf [0] = 0;
1190                                         }
1191                                         if (urb->transfer_buffer_length > 1)
1192                                                 buf [1] = 0;
1193                                         urb->actual_length = min (2,
1194                                                 urb->transfer_buffer_length);
1195                                         value = 0;
1196                                         maybe_set_status (urb, 0);
1197                                 }
1198                                 break;
1199                         }
1200
1201                         /* gadget driver handles all other requests.  block
1202                          * until setup() returns; no reentrancy issues etc.
1203                          */
1204                         if (value > 0) {
1205                                 spin_unlock (&dum->lock);
1206                                 value = dum->driver->setup (&dum->gadget,
1207                                                 &setup);
1208                                 spin_lock (&dum->lock);
1209
1210                                 if (value >= 0) {
1211                                         /* no delays (max 64KB data stage) */
1212                                         limit = 64*1024;
1213                                         goto treat_control_like_bulk;
1214                                 }
1215                                 /* error, see below */
1216                         }
1217
1218                         if (value < 0) {
1219                                 if (value != -EOPNOTSUPP)
1220                                         dev_dbg (hardware,
1221                                                 "setup --> %d\n",
1222                                                 value);
1223                                 maybe_set_status (urb, -EPIPE);
1224                                 urb->actual_length = 0;
1225                         }
1226
1227                         goto return_urb;
1228                 }
1229
1230                 /* non-control requests */
1231                 limit = total;
1232                 switch (usb_pipetype (urb->pipe)) {
1233                 case PIPE_ISOCHRONOUS:
1234                         /* FIXME is it urb->interval since the last xfer?
1235                          * use urb->iso_frame_desc[i].
1236                          * complete whether or not ep has requests queued.
1237                          * report random errors, to debug drivers.
1238                          */
1239                         limit = max (limit, periodic_bytes (dum, ep));
1240                         maybe_set_status (urb, -ENOSYS);
1241                         break;
1242
1243                 case PIPE_INTERRUPT:
1244                         /* FIXME is it urb->interval since the last xfer?
1245                          * this almost certainly polls too fast.
1246                          */
1247                         limit = max (limit, periodic_bytes (dum, ep));
1248                         /* FALLTHROUGH */
1249
1250                 // case PIPE_BULK:  case PIPE_CONTROL:
1251                 default:
1252                 treat_control_like_bulk:
1253                         ep->last_io = jiffies;
1254                         total = transfer (dum, urb, ep, limit);
1255                         break;
1256                 }
1257
1258                 /* incomplete transfer? */
1259                 if (urb->status == -EINPROGRESS)
1260                         continue;
1261
1262 return_urb:
1263                 urb->hcpriv = 0;
1264                 if (ep)
1265                         ep->already_seen = ep->setup_stage = 0;
1266
1267                 spin_unlock (&dum->lock);
1268                 usb_hcd_giveback_urb (&dum->hcd, urb, 0);
1269                 spin_lock (&dum->lock);
1270
1271                 goto restart;
1272         }
1273
1274         /* want a 1 msec delay here */
1275         if (!list_empty (&hdev->urb_list))
1276                 mod_timer (&dum->timer, jiffies + 1);
1277
1278         spin_unlock_irqrestore (&dum->lock, flags);
1279 }
1280
1281 /*-------------------------------------------------------------------------*/
1282
1283 #define PORT_C_MASK \
1284          ((1 << USB_PORT_FEAT_C_CONNECTION) \
1285         | (1 << USB_PORT_FEAT_C_ENABLE) \
1286         | (1 << USB_PORT_FEAT_C_SUSPEND) \
1287         | (1 << USB_PORT_FEAT_C_OVER_CURRENT) \
1288         | (1 << USB_PORT_FEAT_C_RESET))
1289
1290 static int dummy_hub_status (struct usb_hcd *hcd, char *buf)
1291 {
1292         struct dummy            *dum;
1293         unsigned long           flags;
1294         int                     retval;
1295
1296         dum = container_of (hcd, struct dummy, hcd);
1297
1298         spin_lock_irqsave (&dum->lock, flags);
1299         if (!(dum->port_status & PORT_C_MASK))
1300                 retval = 0;
1301         else {
1302                 *buf = (1 << 1);
1303                 dev_dbg (hardware, "port status 0x%08x has changes\n",
1304                         dum->port_status);
1305                 retval = 1;
1306         }
1307         spin_unlock_irqrestore (&dum->lock, flags);
1308         return retval;
1309 }
1310
1311 static inline void
1312 hub_descriptor (struct usb_hub_descriptor *desc)
1313 {
1314         memset (desc, 0, sizeof *desc);
1315         desc->bDescriptorType = 0x29;
1316         desc->bDescLength = 9;
1317         desc->wHubCharacteristics = __constant_cpu_to_le16 (0x0001);
1318         desc->bNbrPorts = 1;
1319         desc->bitmap [0] = 0xff;
1320         desc->bitmap [1] = 0xff;
1321 }
1322
1323 static int dummy_hub_control (
1324         struct usb_hcd  *hcd,
1325         u16             typeReq,
1326         u16             wValue,
1327         u16             wIndex,
1328         char            *buf,
1329         u16             wLength
1330 ) {
1331         struct dummy    *dum;
1332         int             retval = 0;
1333         unsigned long   flags;
1334
1335         dum = container_of (hcd, struct dummy, hcd);
1336         spin_lock_irqsave (&dum->lock, flags);
1337         switch (typeReq) {
1338         case ClearHubFeature:
1339                 break;
1340         case ClearPortFeature:
1341                 // FIXME won't some of these need special handling?
1342                 dum->port_status &= ~(1 << wValue);
1343                 break;
1344         case GetHubDescriptor:
1345                 hub_descriptor ((struct usb_hub_descriptor *) buf);
1346                 break;
1347         case GetHubStatus:
1348                 *(u32 *) buf = __constant_cpu_to_le32 (0);
1349                 break;
1350         case GetPortStatus:
1351                 if (wIndex != 1)
1352                         retval = -EPIPE;
1353                 ((u16 *) buf)[0] = cpu_to_le16 (dum->port_status);
1354                 ((u16 *) buf)[1] = cpu_to_le16 (dum->port_status >> 16);
1355                 break;
1356         case SetHubFeature:
1357                 retval = -EPIPE;
1358                 break;
1359         case SetPortFeature:
1360                 if (wValue == USB_PORT_FEAT_RESET) {
1361                         /* if it's already running, disconnect first */
1362                         if (dum->port_status & USB_PORT_STAT_ENABLE) {
1363                                 dum->port_status &= ~(USB_PORT_STAT_ENABLE
1364                                                 | USB_PORT_STAT_LOW_SPEED
1365                                                 | USB_PORT_STAT_HIGH_SPEED);
1366                                 if (dum->driver) {
1367                                         dev_dbg (hardware, "disconnect\n");
1368                                         stop_activity (dum, dum->driver);
1369                                 }
1370
1371                                 /* FIXME test that code path! */
1372                         } else
1373                                 dum->port_status |=
1374                                         (1 << USB_PORT_FEAT_C_ENABLE);
1375
1376                         dum->port_status |= USB_PORT_STAT_ENABLE |
1377                                   (1 << USB_PORT_FEAT_C_RESET);
1378                         if (dum->driver) {
1379
1380                                 /* give it the best speed we agree on */
1381                                 dum->gadget.speed = dum->driver->speed;
1382                                 dum->gadget.ep0->maxpacket = 64;
1383                                 switch (dum->gadget.speed) {
1384                                 case USB_SPEED_HIGH:
1385                                         dum->port_status |=
1386                                                 USB_PORT_STAT_HIGH_SPEED;
1387                                         break;
1388                                 case USB_SPEED_LOW:
1389                                         dum->gadget.ep0->maxpacket = 8;
1390                                         dum->port_status |=
1391                                                 USB_PORT_STAT_LOW_SPEED;
1392                                         break;
1393                                 default:
1394                                         dum->gadget.speed = USB_SPEED_FULL;
1395                                         break;
1396                                 }
1397                         }
1398                 } else
1399                         dum->port_status |= (1 << wValue);
1400                 break;
1401
1402         default:
1403                 dev_dbg (hardware,
1404                         "hub control req%04x v%04x i%04x l%d\n",
1405                         typeReq, wValue, wIndex, wLength);
1406
1407                 /* "protocol stall" on error */
1408                 retval = -EPIPE;
1409         }
1410         spin_unlock_irqrestore (&dum->lock, flags);
1411         return retval;
1412 }
1413
1414
1415 /*-------------------------------------------------------------------------*/
1416
1417 static struct usb_hcd *dummy_alloc (void)
1418 {
1419         struct dummy            *dum;
1420
1421         dum = kmalloc (sizeof *dum, SLAB_KERNEL);
1422         if (dum == NULL)
1423                 return 0;
1424         memset (dum, 0, sizeof *dum);
1425         return &dum->hcd;
1426 }
1427
1428 static void dummy_free (struct usb_hcd *hcd)
1429 {
1430         struct dummy            *dum;
1431
1432         dum = container_of (hcd, struct dummy, hcd);
1433         WARN_ON (dum->driver != 0);
1434         kfree (dum);
1435 }
1436
1437 /*-------------------------------------------------------------------------*/
1438
1439 static inline ssize_t
1440 show_urb (char *buf, size_t size, struct urb *urb)
1441 {
1442         int ep = usb_pipeendpoint (urb->pipe);
1443
1444         return snprintf (buf, size,
1445                 "urb/%p %s ep%d%s%s len %d/%d\n",
1446                 urb,
1447                 ({ char *s;
1448                  switch (urb->dev->speed) {
1449                  case USB_SPEED_LOW:    s = "ls"; break;
1450                  case USB_SPEED_FULL:   s = "fs"; break;
1451                  case USB_SPEED_HIGH:   s = "hs"; break;
1452                  default:               s = "?"; break;
1453                  }; s; }),
1454                 ep, ep ? (usb_pipein (urb->pipe) ? "in" : "out") : "",
1455                 ({ char *s; \
1456                  switch (usb_pipetype (urb->pipe)) { \
1457                  case PIPE_CONTROL:     s = ""; break; \
1458                  case PIPE_BULK:        s = "-bulk"; break; \
1459                  case PIPE_INTERRUPT:   s = "-int"; break; \
1460                  default:               s = "-iso"; break; \
1461                 }; s;}),
1462                 urb->actual_length, urb->transfer_buffer_length);
1463 }
1464
1465 static ssize_t
1466 show_urbs (struct device *dev, char *buf)
1467 {
1468         struct dummy            *dum = dev_get_drvdata(dev);
1469         struct urb              *urb;
1470         size_t                  size = 0;
1471         unsigned long           flags;
1472
1473         spin_lock_irqsave (&dum->lock, flags);
1474         if (dum->hdev) {
1475                 list_for_each_entry (urb, &dum->hdev->urb_list, urb_list) {
1476                         size_t          temp;
1477
1478                         temp = show_urb (buf, PAGE_SIZE - size, urb);
1479                         buf += temp;
1480                         size += temp;
1481                 }
1482         }
1483         spin_unlock_irqrestore (&dum->lock, flags);
1484
1485         return size;
1486 }
1487 static DEVICE_ATTR (urbs, S_IRUGO, show_urbs, NULL);
1488
1489
1490 static const struct hc_driver dummy_hcd;
1491
1492 static int dummy_start (struct usb_hcd *hcd)
1493 {
1494         struct dummy            *dum;
1495         struct usb_bus          *bus;
1496         struct usb_device       *root;
1497         int                     retval;
1498
1499         dum = container_of (hcd, struct dummy, hcd);
1500
1501         /*
1502          * MASTER side init ... we emulate a root hub that'll only ever
1503          * talk to one device (the slave side).  Also appears in sysfs,
1504          * just like more familiar pci-based HCDs.
1505          */
1506         spin_lock_init (&dum->lock);
1507
1508         retval = driver_register (&dummy_driver);
1509         if (retval < 0)
1510                 return retval;
1511
1512         dum->pdev.name = "hc";
1513         dum->pdev.dev.driver = &dummy_driver;
1514         dev_set_drvdata(&dum->pdev.dev, dum);
1515         dum->pdev.dev.release = dummy_hc_release;
1516         retval = platform_device_register (&dum->pdev);
1517         if (retval < 0) {
1518                 driver_unregister (&dummy_driver);
1519                 return retval;
1520         }
1521         dev_info (&dum->pdev.dev, "%s, driver " DRIVER_VERSION "\n",
1522                         driver_desc);
1523
1524         hcd->self.controller = &dum->pdev.dev;
1525
1526         /* FIXME 'urbs' should be a per-device thing, maybe in usbcore */
1527         device_create_file (hcd->self.controller, &dev_attr_urbs);
1528
1529         init_timer (&dum->timer);
1530         dum->timer.function = dummy_timer;
1531         dum->timer.data = (unsigned long) dum;
1532
1533         /* root hub will appear as another device */
1534         dum->hcd.driver = (struct hc_driver *) &dummy_hcd;
1535         dum->hcd.description = dummy_hcd.description;
1536         dum->hcd.product_desc = "Dummy host controller";
1537
1538         bus = hcd_to_bus (&dum->hcd);
1539         bus->bus_name = dum->pdev.dev.bus_id;
1540         usb_bus_init (bus);
1541         bus->op = &usb_hcd_operations;
1542         bus->hcpriv = &dum->hcd;
1543
1544         /* FIXME don't require the pci-based buffer/alloc impls;
1545          * the "generic dma" implementation still requires them,
1546          * it's not very generic yet.
1547          */
1548         if ((retval = hcd_buffer_create (&dum->hcd)) != 0) {
1549 clean0:
1550                 init_completion (&dum->released);
1551                 platform_device_unregister (&dum->pdev);
1552                 wait_for_completion (&dum->released);
1553                 driver_unregister (&dummy_driver);
1554                 return retval;
1555         }
1556
1557         INIT_LIST_HEAD (&hcd->dev_list);
1558         usb_register_bus (bus);
1559
1560         bus->root_hub = root = usb_alloc_dev (0, bus, 0);
1561         if (!root) {
1562                 retval = -ENOMEM;
1563 clean1:
1564                 hcd_buffer_destroy (&dum->hcd);
1565                 usb_deregister_bus (bus);
1566                 goto clean0;
1567         }
1568
1569         /* root hub enters addressed state... */
1570         dum->hcd.state = USB_STATE_RUNNING;
1571         root->speed = USB_SPEED_HIGH;
1572
1573         /* ...then configured, so khubd sees us. */
1574         if ((retval = hcd_register_root (&dum->hcd)) != 0) {
1575                 bus->root_hub = 0;
1576                 usb_put_dev (root);
1577 clean2:
1578                 dum->hcd.state = USB_STATE_QUIESCING;
1579                 goto clean1;
1580         }
1581
1582         dum->started = 1;
1583
1584         if ((retval = dummy_register_udc (dum)) != 0) {
1585                 dum->started = 0;
1586                 usb_disconnect (&bus->root_hub);
1587                 goto clean2;
1588         }
1589         return 0;
1590 }
1591
1592 static void dummy_stop (struct usb_hcd *hcd)
1593 {
1594         struct dummy            *dum;
1595         struct usb_bus          *bus;
1596
1597         dum = container_of (hcd, struct dummy, hcd);
1598         if (!dum->started)
1599                 return;
1600         dum->started = 0;
1601
1602         usb_gadget_unregister_driver (dum->driver);
1603         dummy_unregister_udc (dum);
1604
1605         bus = hcd_to_bus (&dum->hcd);
1606         hcd->state = USB_STATE_QUIESCING;
1607         dev_dbg (hardware, "remove root hub\n");
1608         usb_disconnect (&bus->root_hub);
1609
1610         hcd_buffer_destroy (&dum->hcd);
1611         usb_deregister_bus (bus);
1612
1613         dev_info (hardware, "stopped\n");
1614
1615         device_remove_file (hcd->self.controller, &dev_attr_urbs);
1616         init_completion (&dum->released);
1617         platform_device_unregister (&dum->pdev);
1618         wait_for_completion (&dum->released);
1619
1620         driver_unregister (&dummy_driver);
1621 }
1622
1623 /*-------------------------------------------------------------------------*/
1624
1625 static int dummy_h_get_frame (struct usb_hcd *hcd)
1626 {
1627         return dummy_g_get_frame (0);
1628 }
1629
1630 static const struct hc_driver dummy_hcd = {
1631         .description =          (char *) driver_name,
1632         .flags =                HCD_USB2,
1633
1634         .start =                dummy_start,
1635         .stop =                 dummy_stop,
1636
1637         .hcd_alloc =            dummy_alloc,
1638         .hcd_free =             dummy_free,
1639
1640         .urb_enqueue =          dummy_urb_enqueue,
1641         .urb_dequeue =          dummy_urb_dequeue,
1642
1643         .get_frame_number =     dummy_h_get_frame,
1644
1645         .hub_status_data =      dummy_hub_status,
1646         .hub_control =          dummy_hub_control,
1647 };
1648
1649 /*-------------------------------------------------------------------------*/
1650
1651 static int __init init (void)
1652 {
1653         struct usb_hcd          *hcd;
1654         int                     value;
1655
1656         if (usb_disabled ())
1657                 return -ENODEV;
1658         if ((hcd = dummy_alloc ()) == 0)
1659                 return -ENOMEM;
1660
1661         the_controller = container_of (hcd, struct dummy, hcd);
1662         value = dummy_start (hcd);
1663
1664         if (value != 0) {
1665                 dummy_free (hcd);
1666                 the_controller = 0;
1667         }
1668         return value;
1669 }
1670 module_init (init);
1671
1672 static void __exit cleanup (void)
1673 {
1674         dummy_stop (&the_controller->hcd);
1675         dummy_free (&the_controller->hcd);
1676         the_controller = 0;
1677 }
1678 module_exit (cleanup);
1679