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