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