usb/mtu3/mtu3_gadget.c

   1 // SPDX-License-Identifier: GPL-2.0
   2 /*
   3  * mtu3_gadget.c - MediaTek usb3 DRD peripheral support
   4  *
   5  * Copyright (C) 2016 MediaTek Inc.
   6  *
   7  * Author: Chunfeng Yun <chunfeng.yun@mediatek.com>
   8  */
   9
  10 #include "mtu3.h"
  11
  12 void mtu3_req_complete(struct mtu3_ep *mep,
  13                      struct usb_request *req, int status)
  14 __releases(mep->mtu->lock)
  15 __acquires(mep->mtu->lock)
  16 {
  17         struct mtu3_request *mreq;
  18         struct mtu3 *mtu;
  19         int busy = mep->busy;
  20
  21         mreq = to_mtu3_request(req);
  22         list_del(&mreq->list);
  23         if (mreq->request.status == -EINPROGRESS)
  24                 mreq->request.status = status;
  25
  26         mtu = mreq->mtu;
  27         mep->busy = 1;
  28         spin_unlock(&mtu->lock);
  29
  30         /* ep0 makes use of PIO, needn't unmap it */
  31         if (mep->epnum)
  32                 usb_gadget_unmap_request(&mtu->g, req, mep->is_in);
  33
  34         dev_dbg(mtu->dev, "%s complete req: %p, sts %d, %d/%d\n", mep->name,
  35                 req, req->status, mreq->request.actual, mreq->request.length);
  36
  37         usb_gadget_giveback_request(&mep->ep, &mreq->request);
  38
  39         spin_lock(&mtu->lock);
  40         mep->busy = busy;
  41 }
  42
  43 static void nuke(struct mtu3_ep *mep, const int status)
  44 {
  45         struct mtu3_request *mreq = NULL;
  46
  47         mep->busy = 1;
  48         if (list_empty(&mep->req_list))
  49                 return;
  50
  51         dev_dbg(mep->mtu->dev, "abort %s's req: sts %d\n", mep->name, status);
  52
  53         /* exclude EP0 */
  54         if (mep->epnum)
  55                 mtu3_qmu_flush(mep);
  56
  57         while (!list_empty(&mep->req_list)) {
  58                 mreq = list_first_entry(&mep->req_list,
  59                                         struct mtu3_request, list);
  60                 mtu3_req_complete(mep, &mreq->request, status);
  61         }
  62 }
  63
  64 static int mtu3_ep_enable(struct mtu3_ep *mep)
  65 {
  66         const struct usb_endpoint_descriptor *desc;
  67         const struct usb_ss_ep_comp_descriptor *comp_desc;
  68         struct mtu3 *mtu = mep->mtu;
  69         u32 interval = 0;
  70         u32 mult = 0;
  71         u32 burst = 0;
  72         int ret;
  73
  74         desc = mep->desc;
  75         comp_desc = mep->comp_desc;
  76         mep->type = usb_endpoint_type(desc);
  77         mep->maxp = usb_endpoint_maxp(desc);
  78
  79         switch (mtu->g.speed) {
  80         case USB_SPEED_SUPER:
  81         case USB_SPEED_SUPER_PLUS:
  82                 if (usb_endpoint_xfer_int(desc) ||
  83                                 usb_endpoint_xfer_isoc(desc)) {
  84                         interval = desc->bInterval;
  85                         interval = clamp_val(interval, 1, 16) - 1;
  86                         if (usb_endpoint_xfer_isoc(desc) && comp_desc)
  87                                 mult = comp_desc->bmAttributes;
  88                 }
  89                 if (comp_desc)
  90                         burst = comp_desc->bMaxBurst;
  91
  92                 break;
  93         case USB_SPEED_HIGH:
  94                 if (usb_endpoint_xfer_isoc(desc) ||
  95                                 usb_endpoint_xfer_int(desc)) {
  96                         interval = desc->bInterval;
  97                         interval = clamp_val(interval, 1, 16) - 1;
  98                         mult = usb_endpoint_maxp_mult(desc) - 1;
  99                 }
 100                 break;
 101         default:
 102                 break; /*others are ignored */
 103         }
 104
 105         dev_dbg(mtu->dev, "%s maxp:%d, interval:%d, burst:%d, mult:%d\n",
 106                 __func__, mep->maxp, interval, burst, mult);
 107
 108         mep->ep.maxpacket = mep->maxp;
 109         mep->ep.desc = desc;
 110         mep->ep.comp_desc = comp_desc;
 111
 112         /* slot mainly affects bulk/isoc transfer, so ignore int */
 113         mep->slot = usb_endpoint_xfer_int(desc) ? 0 : mtu->slot;
 114
 115         ret = mtu3_config_ep(mtu, mep, interval, burst, mult);
 116         if (ret < 0)
 117                 return ret;
 118
 119         ret = mtu3_gpd_ring_alloc(mep);
 120         if (ret < 0) {
 121                 mtu3_deconfig_ep(mtu, mep);
 122                 return ret;
 123         }
 124
 125         mtu3_qmu_start(mep);
 126
 127         return 0;
 128 }
 129
 130 static int mtu3_ep_disable(struct mtu3_ep *mep)
 131 {
 132         struct mtu3 *mtu = mep->mtu;
 133
 134         mtu3_qmu_stop(mep);
 135
 136         /* abort all pending requests */
 137         nuke(mep, -ESHUTDOWN);
 138         mtu3_deconfig_ep(mtu, mep);
 139         mtu3_gpd_ring_free(mep);
 140
 141         mep->desc = NULL;
 142         mep->ep.desc = NULL;
 143         mep->comp_desc = NULL;
 144         mep->type = 0;
 145         mep->flags = 0;
 146
 147         return 0;
 148 }
 149
 150 static int mtu3_gadget_ep_enable(struct usb_ep *ep,
 151                 const struct usb_endpoint_descriptor *desc)
 152 {
 153         struct mtu3_ep *mep;
 154         struct mtu3 *mtu;
 155         unsigned long flags;
 156         int ret = -EINVAL;
 157
 158         if (!ep || !desc || desc->bDescriptorType != USB_DT_ENDPOINT) {
 159                 pr_debug("%s invalid parameters\n", __func__);
 160                 return -EINVAL;
 161         }
 162
 163         if (!desc->wMaxPacketSize) {
 164                 pr_debug("%s missing wMaxPacketSize\n", __func__);
 165                 return -EINVAL;
 166         }
 167         mep = to_mtu3_ep(ep);
 168         mtu = mep->mtu;
 169
 170         /* check ep number and direction against endpoint */
 171         if (usb_endpoint_num(desc) != mep->epnum)
 172                 return -EINVAL;
 173
 174         if (!!usb_endpoint_dir_in(desc) ^ !!mep->is_in)
 175                 return -EINVAL;
 176
 177         dev_dbg(mtu->dev, "%s %s\n", __func__, ep->name);
 178
 179         if (mep->flags & MTU3_EP_ENABLED) {
 180                 dev_WARN_ONCE(mtu->dev, true, "%s is already enabled\n",
 181                                 mep->name);
 182                 return 0;
 183         }
 184
 185         spin_lock_irqsave(&mtu->lock, flags);
 186         mep->desc = desc;
 187         mep->comp_desc = ep->comp_desc;
 188
 189         ret = mtu3_ep_enable(mep);
 190         if (ret)
 191                 goto error;
 192
 193         mep->busy = 0;
 194         mep->wedged = 0;
 195         mep->flags |= MTU3_EP_ENABLED;
 196         mtu->active_ep++;
 197
 198 error:
 199         spin_unlock_irqrestore(&mtu->lock, flags);
 200
 201         dev_dbg(mtu->dev, "%s active_ep=%d\n", __func__, mtu->active_ep);
 202
 203         return ret;
 204 }
 205
 206 static int mtu3_gadget_ep_disable(struct usb_ep *ep)
 207 {
 208         struct mtu3_ep *mep = to_mtu3_ep(ep);
 209         struct mtu3 *mtu = mep->mtu;
 210         unsigned long flags;
 211
 212         dev_dbg(mtu->dev, "%s %s\n", __func__, mep->name);
 213
 214         if (!(mep->flags & MTU3_EP_ENABLED)) {
 215                 dev_warn(mtu->dev, "%s is already disabled\n", mep->name);
 216                 return 0;
 217         }
 218
 219         spin_lock_irqsave(&mtu->lock, flags);
 220         mtu3_ep_disable(mep);
 221         mep->flags &= ~MTU3_EP_ENABLED;
 222         mtu->active_ep--;
 223         spin_unlock_irqrestore(&(mtu->lock), flags);
 224
 225         dev_dbg(mtu->dev, "%s active_ep=%d, mtu3 is_active=%d\n",
 226                 __func__, mtu->active_ep, mtu->is_active);
 227
 228         return 0;
 229 }
 230
 231 struct usb_request *mtu3_alloc_request(struct usb_ep *ep, gfp_t gfp_flags)
 232 {
 233         struct mtu3_ep *mep = to_mtu3_ep(ep);
 234         struct mtu3_request *mreq;
 235
 236         mreq = kzalloc(sizeof(*mreq), gfp_flags);
 237         if (!mreq)
 238                 return NULL;
 239
 240         mreq->request.dma = DMA_ADDR_INVALID;
 241         mreq->epnum = mep->epnum;
 242         mreq->mep = mep;
 243
 244         return &mreq->request;
 245 }
 246
 247 void mtu3_free_request(struct usb_ep *ep, struct usb_request *req)
 248 {
 249         kfree(to_mtu3_request(req));
 250 }
 251
 252 static int mtu3_gadget_queue(struct usb_ep *ep,
 253                 struct usb_request *req, gfp_t gfp_flags)
 254 {
 255         struct mtu3_ep *mep;
 256         struct mtu3_request *mreq;
 257         struct mtu3 *mtu;
 258         unsigned long flags;
 259         int ret = 0;
 260
 261         if (!ep || !req)
 262                 return -EINVAL;
 263
 264         if (!req->buf)
 265                 return -ENODATA;
 266
 267         mep = to_mtu3_ep(ep);
 268         mtu = mep->mtu;
 269         mreq = to_mtu3_request(req);
 270         mreq->mtu = mtu;
 271
 272         if (mreq->mep != mep)
 273                 return -EINVAL;
 274
 275         dev_dbg(mtu->dev, "%s %s EP%d(%s), req=%p, maxp=%d, len#%d\n",
 276                 __func__, mep->is_in ? "TX" : "RX", mreq->epnum, ep->name,
 277                 mreq, ep->maxpacket, mreq->request.length);
 278
 279         if (req->length > GPD_BUF_SIZE) {
 280                 dev_warn(mtu->dev,
 281                         "req length > supported MAX:%d requested:%d\n",
 282                         GPD_BUF_SIZE, req->length);
 283                 return -EOPNOTSUPP;
 284         }
 285
 286         /* don't queue if the ep is down */
 287         if (!mep->desc) {
 288                 dev_dbg(mtu->dev, "req=%p queued to %s while it's disabled\n",
 289                         req, ep->name);
 290                 return -ESHUTDOWN;
 291         }
 292
 293         mreq->request.actual = 0;
 294         mreq->request.status = -EINPROGRESS;
 295
 296         ret = usb_gadget_map_request(&mtu->g, req, mep->is_in);
 297         if (ret) {
 298                 dev_err(mtu->dev, "dma mapping failed\n");
 299                 return ret;
 300         }
 301
 302         spin_lock_irqsave(&mtu->lock, flags);
 303
 304         if (mtu3_prepare_transfer(mep)) {
 305                 ret = -EAGAIN;
 306                 goto error;
 307         }
 308
 309         list_add_tail(&mreq->list, &mep->req_list);
 310         mtu3_insert_gpd(mep, mreq);
 311         mtu3_qmu_resume(mep);
 312
 313 error:
 314         spin_unlock_irqrestore(&mtu->lock, flags);
 315
 316         return ret;
 317 }
 318
 319 static int mtu3_gadget_dequeue(struct usb_ep *ep, struct usb_request *req)
 320 {
 321         struct mtu3_ep *mep = to_mtu3_ep(ep);
 322         struct mtu3_request *mreq = to_mtu3_request(req);
 323         struct mtu3_request *r;
 324         unsigned long flags;
 325         int ret = 0;
 326         struct mtu3 *mtu = mep->mtu;
 327
 328         if (!ep || !req || mreq->mep != mep)
 329                 return -EINVAL;
 330
 331         dev_dbg(mtu->dev, "%s : req=%p\n", __func__, req);
 332
 333         spin_lock_irqsave(&mtu->lock, flags);
 334
 335         list_for_each_entry(r, &mep->req_list, list) {
 336                 if (r == mreq)
 337                         break;
 338         }
 339         if (r != mreq) {
 340                 dev_dbg(mtu->dev, "req=%p not queued to %s\n", req, ep->name);
 341                 ret = -EINVAL;
 342                 goto done;
 343         }
 344
 345         mtu3_qmu_flush(mep);  /* REVISIT: set BPS ?? */
 346         mtu3_req_complete(mep, req, -ECONNRESET);
 347         mtu3_qmu_start(mep);
 348
 349 done:
 350         spin_unlock_irqrestore(&mtu->lock, flags);
 351
 352         return ret;
 353 }
 354
 355 /*
 356  * Set or clear the halt bit of an EP.
 357  * A halted EP won't TX/RX any data but will queue requests.
 358  */
 359 static int mtu3_gadget_ep_set_halt(struct usb_ep *ep, int value)
 360 {
 361         struct mtu3_ep *mep = to_mtu3_ep(ep);
 362         struct mtu3 *mtu = mep->mtu;
 363         struct mtu3_request *mreq;
 364         unsigned long flags;
 365         int ret = 0;
 366
 367         if (!ep)
 368                 return -EINVAL;
 369
 370         dev_dbg(mtu->dev, "%s : %s...", __func__, ep->name);
 371
 372         spin_lock_irqsave(&mtu->lock, flags);
 373
 374         if (mep->type == USB_ENDPOINT_XFER_ISOC) {
 375                 ret = -EINVAL;
 376                 goto done;
 377         }
 378
 379         mreq = next_request(mep);
 380         if (value) {
 381                 /*
 382                  * If there is not request for TX-EP, QMU will not transfer
 383                  * data to TX-FIFO, so no need check whether TX-FIFO
 384                  * holds bytes or not here
 385                  */
 386                 if (mreq) {
 387                         dev_dbg(mtu->dev, "req in progress, cannot halt %s\n",
 388                                 ep->name);
 389                         ret = -EAGAIN;
 390                         goto done;
 391                 }
 392         } else {
 393                 mep->wedged = 0;
 394         }
 395
 396         dev_dbg(mtu->dev, "%s %s stall\n", ep->name, value ? "set" : "clear");
 397
 398         mtu3_ep_stall_set(mep, value);
 399
 400 done:
 401         spin_unlock_irqrestore(&mtu->lock, flags);
 402
 403         return ret;
 404 }
 405
 406 /* Sets the halt feature with the clear requests ignored */
 407 static int mtu3_gadget_ep_set_wedge(struct usb_ep *ep)
 408 {
 409         struct mtu3_ep *mep = to_mtu3_ep(ep);
 410
 411         if (!ep)
 412                 return -EINVAL;
 413
 414         mep->wedged = 1;
 415
 416         return usb_ep_set_halt(ep);
 417 }
 418
 419 static const struct usb_ep_ops mtu3_ep_ops = {
 420         .enable = mtu3_gadget_ep_enable,
 421         .disable = mtu3_gadget_ep_disable,
 422         .alloc_request = mtu3_alloc_request,
 423         .free_request = mtu3_free_request,
 424         .queue = mtu3_gadget_queue,
 425         .dequeue = mtu3_gadget_dequeue,
 426         .set_halt = mtu3_gadget_ep_set_halt,
 427         .set_wedge = mtu3_gadget_ep_set_wedge,
 428 };
 429
 430 static int mtu3_gadget_get_frame(struct usb_gadget *gadget)
 431 {
 432         struct mtu3 *mtu = gadget_to_mtu3(gadget);
 433
 434         return (int)mtu3_readl(mtu->mac_base, U3D_USB20_FRAME_NUM);
 435 }
 436
 437 static int mtu3_gadget_wakeup(struct usb_gadget *gadget)
 438 {
 439         struct mtu3 *mtu = gadget_to_mtu3(gadget);
 440         unsigned long flags;
 441
 442         dev_dbg(mtu->dev, "%s\n", __func__);
 443
 444         /* remote wakeup feature is not enabled by host */
 445         if (!mtu->may_wakeup)
 446                 return  -EOPNOTSUPP;
 447
 448         spin_lock_irqsave(&mtu->lock, flags);
 449         if (mtu->g.speed >= USB_SPEED_SUPER) {
 450                 mtu3_setbits(mtu->mac_base, U3D_LINK_POWER_CONTROL, UX_EXIT);
 451         } else {
 452                 mtu3_setbits(mtu->mac_base, U3D_POWER_MANAGEMENT, RESUME);
 453                 spin_unlock_irqrestore(&mtu->lock, flags);
 454                 usleep_range(10000, 11000);
 455                 spin_lock_irqsave(&mtu->lock, flags);
 456                 mtu3_clrbits(mtu->mac_base, U3D_POWER_MANAGEMENT, RESUME);
 457         }
 458         spin_unlock_irqrestore(&mtu->lock, flags);
 459         return 0;
 460 }
 461
 462 static int mtu3_gadget_set_self_powered(struct usb_gadget *gadget,
 463                 int is_selfpowered)
 464 {
 465         struct mtu3 *mtu = gadget_to_mtu3(gadget);
 466
 467         mtu->is_self_powered = !!is_selfpowered;
 468         return 0;
 469 }
 470
 471 static int mtu3_gadget_pullup(struct usb_gadget *gadget, int is_on)
 472 {
 473         struct mtu3 *mtu = gadget_to_mtu3(gadget);
 474         unsigned long flags;
 475
 476         dev_dbg(mtu->dev, "%s (%s) for %sactive device\n", __func__,
 477                 is_on ? "on" : "off", mtu->is_active ? "" : "in");
 478
 479         /* we'd rather not pullup unless the device is active. */
 480         spin_lock_irqsave(&mtu->lock, flags);
 481
 482         is_on = !!is_on;
 483         if (!mtu->is_active) {
 484                 /* save it for mtu3_start() to process the request */
 485                 mtu->softconnect = is_on;
 486         } else if (is_on != mtu->softconnect) {
 487                 mtu->softconnect = is_on;
 488                 mtu3_dev_on_off(mtu, is_on);
 489         }
 490
 491         spin_unlock_irqrestore(&mtu->lock, flags);
 492
 493         return 0;
 494 }
 495
 496 static int mtu3_gadget_start(struct usb_gadget *gadget,
 497                 struct usb_gadget_driver *driver)
 498 {
 499         struct mtu3 *mtu = gadget_to_mtu3(gadget);
 500         unsigned long flags;
 501
 502         if (mtu->gadget_driver) {
 503                 dev_err(mtu->dev, "%s is already bound to %s\n",
 504                         mtu->g.name, mtu->gadget_driver->driver.name);
 505                 return -EBUSY;
 506         }
 507
 508         dev_dbg(mtu->dev, "bind driver %s\n", driver->function);
 509
 510         spin_lock_irqsave(&mtu->lock, flags);
 511
 512         mtu->softconnect = 0;
 513         mtu->gadget_driver = driver;
 514
 515         if (mtu->ssusb->dr_mode == USB_DR_MODE_PERIPHERAL)
 516                 mtu3_start(mtu);
 517
 518         spin_unlock_irqrestore(&mtu->lock, flags);
 519
 520         return 0;
 521 }
 522
 523 static void stop_activity(struct mtu3 *mtu)
 524 {
 525         struct usb_gadget_driver *driver = mtu->gadget_driver;
 526         int i;
 527
 528         /* don't disconnect if it's not connected */
 529         if (mtu->g.speed == USB_SPEED_UNKNOWN)
 530                 driver = NULL;
 531         else
 532                 mtu->g.speed = USB_SPEED_UNKNOWN;
 533
 534         /* deactivate the hardware */
 535         if (mtu->softconnect) {
 536                 mtu->softconnect = 0;
 537                 mtu3_dev_on_off(mtu, 0);
 538         }
 539
 540         /*
 541          * killing any outstanding requests will quiesce the driver;
 542          * then report disconnect
 543          */
 544         nuke(mtu->ep0, -ESHUTDOWN);
 545         for (i = 1; i < mtu->num_eps; i++) {
 546                 nuke(mtu->in_eps + i, -ESHUTDOWN);
 547                 nuke(mtu->out_eps + i, -ESHUTDOWN);
 548         }
 549
 550         if (driver) {
 551                 spin_unlock(&mtu->lock);
 552                 driver->disconnect(&mtu->g);
 553                 spin_lock(&mtu->lock);
 554         }
 555 }
 556
 557 static int mtu3_gadget_stop(struct usb_gadget *g)
 558 {
 559         struct mtu3 *mtu = gadget_to_mtu3(g);
 560         unsigned long flags;
 561
 562         dev_dbg(mtu->dev, "%s\n", __func__);
 563
 564         spin_lock_irqsave(&mtu->lock, flags);
 565
 566         stop_activity(mtu);
 567         mtu->gadget_driver = NULL;
 568
 569         if (mtu->ssusb->dr_mode == USB_DR_MODE_PERIPHERAL)
 570                 mtu3_stop(mtu);
 571
 572         spin_unlock_irqrestore(&mtu->lock, flags);
 573
 574         synchronize_irq(mtu->irq);
 575         return 0;
 576 }
 577
 578 static const struct usb_gadget_ops mtu3_gadget_ops = {
 579         .get_frame = mtu3_gadget_get_frame,
 580         .wakeup = mtu3_gadget_wakeup,
 581         .set_selfpowered = mtu3_gadget_set_self_powered,
 582         .pullup = mtu3_gadget_pullup,
 583         .udc_start = mtu3_gadget_start,
 584         .udc_stop = mtu3_gadget_stop,
 585 };
 586
 587 static void mtu3_state_reset(struct mtu3 *mtu)
 588 {
 589         mtu->address = 0;
 590         mtu->ep0_state = MU3D_EP0_STATE_SETUP;
 591         mtu->may_wakeup = 0;
 592         mtu->u1_enable = 0;
 593         mtu->u2_enable = 0;
 594         mtu->delayed_status = false;
 595         mtu->test_mode = false;
 596 }
 597
 598 static void init_hw_ep(struct mtu3 *mtu, struct mtu3_ep *mep,
 599                 u32 epnum, u32 is_in)
 600 {
 601         mep->epnum = epnum;
 602         mep->mtu = mtu;
 603         mep->is_in = is_in;
 604
 605         INIT_LIST_HEAD(&mep->req_list);
 606
 607         sprintf(mep->name, "ep%d%s", epnum,
 608                 !epnum ? "" : (is_in ? "in" : "out"));
 609
 610         mep->ep.name = mep->name;
 611         INIT_LIST_HEAD(&mep->ep.ep_list);
 612
 613         /* initialize maxpacket as SS */
 614         if (!epnum) {
 615                 usb_ep_set_maxpacket_limit(&mep->ep, 512);
 616                 mep->ep.caps.type_control = true;
 617                 mep->ep.ops = &mtu3_ep0_ops;
 618                 mtu->g.ep0 = &mep->ep;
 619         } else {
 620                 usb_ep_set_maxpacket_limit(&mep->ep, 1024);
 621                 mep->ep.caps.type_iso = true;
 622                 mep->ep.caps.type_bulk = true;
 623                 mep->ep.caps.type_int = true;
 624                 mep->ep.ops = &mtu3_ep_ops;
 625                 list_add_tail(&mep->ep.ep_list, &mtu->g.ep_list);
 626         }
 627
 628         dev_dbg(mtu->dev, "%s, name=%s, maxp=%d\n", __func__, mep->ep.name,
 629                  mep->ep.maxpacket);
 630
 631         if (!epnum) {
 632                 mep->ep.caps.dir_in = true;
 633                 mep->ep.caps.dir_out = true;
 634         } else if (is_in) {
 635                 mep->ep.caps.dir_in = true;
 636         } else {
 637                 mep->ep.caps.dir_out = true;
 638         }
 639 }
 640
 641 static void mtu3_gadget_init_eps(struct mtu3 *mtu)
 642 {
 643         u8 epnum;
 644
 645         /* initialize endpoint list just once */
 646         INIT_LIST_HEAD(&(mtu->g.ep_list));
 647
 648         dev_dbg(mtu->dev, "%s num_eps(1 for a pair of tx&rx ep)=%d\n",
 649                 __func__, mtu->num_eps);
 650
 651         init_hw_ep(mtu, mtu->ep0, 0, 0);
 652         for (epnum = 1; epnum < mtu->num_eps; epnum++) {
 653                 init_hw_ep(mtu, mtu->in_eps + epnum, epnum, 1);
 654                 init_hw_ep(mtu, mtu->out_eps + epnum, epnum, 0);
 655         }
 656 }
 657
 658 int mtu3_gadget_setup(struct mtu3 *mtu)
 659 {
 660         int ret;
 661
 662         mtu->g.ops = &mtu3_gadget_ops;
 663         mtu->g.max_speed = mtu->max_speed;
 664         mtu->g.speed = USB_SPEED_UNKNOWN;
 665         mtu->g.sg_supported = 0;
 666         mtu->g.name = MTU3_DRIVER_NAME;
 667         mtu->is_active = 0;
 668         mtu->delayed_status = false;
 669
 670         mtu3_gadget_init_eps(mtu);
 671
 672         ret = usb_add_gadget_udc(mtu->dev, &mtu->g);
 673         if (ret)
 674                 dev_err(mtu->dev, "failed to register udc\n");
 675
 676         return ret;
 677 }
 678
 679 void mtu3_gadget_cleanup(struct mtu3 *mtu)
 680 {
 681         usb_del_gadget_udc(&mtu->g);
 682 }
 683
 684 void mtu3_gadget_resume(struct mtu3 *mtu)
 685 {
 686         dev_dbg(mtu->dev, "gadget RESUME\n");
 687         if (mtu->gadget_driver && mtu->gadget_driver->resume) {
 688                 spin_unlock(&mtu->lock);
 689                 mtu->gadget_driver->resume(&mtu->g);
 690                 spin_lock(&mtu->lock);
 691         }
 692 }
 693
 694 /* called when SOF packets stop for 3+ msec or enters U3 */
 695 void mtu3_gadget_suspend(struct mtu3 *mtu)
 696 {
 697         dev_dbg(mtu->dev, "gadget SUSPEND\n");
 698         if (mtu->gadget_driver && mtu->gadget_driver->suspend) {
 699                 spin_unlock(&mtu->lock);
 700                 mtu->gadget_driver->suspend(&mtu->g);
 701                 spin_lock(&mtu->lock);
 702         }
 703 }
 704
 705 /* called when VBUS drops below session threshold, and in other cases */
 706 void mtu3_gadget_disconnect(struct mtu3 *mtu)
 707 {
 708         dev_dbg(mtu->dev, "gadget DISCONNECT\n");
 709         if (mtu->gadget_driver && mtu->gadget_driver->disconnect) {
 710                 spin_unlock(&mtu->lock);
 711                 mtu->gadget_driver->disconnect(&mtu->g);
 712                 spin_lock(&mtu->lock);
 713         }
 714
 715         mtu3_state_reset(mtu);
 716         usb_gadget_set_state(&mtu->g, USB_STATE_NOTATTACHED);
 717 }
 718
 719 void mtu3_gadget_reset(struct mtu3 *mtu)
 720 {
 721         dev_dbg(mtu->dev, "gadget RESET\n");
 722
 723         /* report disconnect, if we didn't flush EP state */
 724         if (mtu->g.speed != USB_SPEED_UNKNOWN)
 725                 mtu3_gadget_disconnect(mtu);
 726         else
 727                 mtu3_state_reset(mtu);
 728 }