root/drivers/usb/mtu3/mtu3_gadget.c

DEFINITIONS

1. mtu3_req_complete
2. nuke
3. mtu3_ep_enable
4. mtu3_ep_disable
5. mtu3_gadget_ep_enable
6. mtu3_gadget_ep_disable
7. mtu3_alloc_request
8. mtu3_free_request
9. mtu3_gadget_queue
10. mtu3_gadget_dequeue
11. mtu3_gadget_ep_set_halt
12. mtu3_gadget_ep_set_wedge
13. mtu3_gadget_get_frame
14. mtu3_gadget_wakeup
15. mtu3_gadget_set_self_powered
16. mtu3_gadget_pullup
17. mtu3_gadget_start
18. stop_activity
19. mtu3_gadget_stop
20. mtu3_state_reset
21. init_hw_ep
22. mtu3_gadget_init_eps
23. mtu3_gadget_setup
24. mtu3_gadget_cleanup
25. mtu3_gadget_resume
26. mtu3_gadget_suspend
27. mtu3_gadget_disconnect
28. mtu3_gadget_reset

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