drivers/usb/gadget/udc/dummy_hcd.c

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