drivers/usb/mtu3/mtu3_gadget.c

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