Back to home page

OSCL-LXR
 
 

     

0001 // SPDX-License-Identifier: GPL-2.0
0002 /*
0003  * mtu3_gadget.c - MediaTek usb3 DRD peripheral support
0004  *
0005  * Copyright (C) 2016 MediaTek Inc.
0006  *
0007  * Author: Chunfeng Yun <chunfeng.yun@mediatek.com>
0008  */
0009 
0010 #include "mtu3.h"
0011 #include "mtu3_trace.h"
0012 
0013 void mtu3_req_complete(struct mtu3_ep *mep,
0014              struct usb_request *req, int status)
0015 __releases(mep->mtu->lock)
0016 __acquires(mep->mtu->lock)
0017 {
0018     struct mtu3_request *mreq = to_mtu3_request(req);
0019     struct mtu3 *mtu = mreq->mtu;
0020 
0021     list_del(&mreq->list);
0022     if (req->status == -EINPROGRESS)
0023         req->status = status;
0024 
0025     trace_mtu3_req_complete(mreq);
0026     spin_unlock(&mtu->lock);
0027 
0028     /* ep0 makes use of PIO, needn't unmap it */
0029     if (mep->epnum)
0030         usb_gadget_unmap_request(&mtu->g, req, mep->is_in);
0031 
0032     dev_dbg(mtu->dev, "%s complete req: %p, sts %d, %d/%d\n",
0033         mep->name, req, req->status, req->actual, req->length);
0034 
0035     usb_gadget_giveback_request(&mep->ep, req);
0036     spin_lock(&mtu->lock);
0037 }
0038 
0039 static void nuke(struct mtu3_ep *mep, const int status)
0040 {
0041     struct mtu3_request *mreq = NULL;
0042 
0043     if (list_empty(&mep->req_list))
0044         return;
0045 
0046     dev_dbg(mep->mtu->dev, "abort %s's req: sts %d\n", mep->name, status);
0047 
0048     /* exclude EP0 */
0049     if (mep->epnum)
0050         mtu3_qmu_flush(mep);
0051 
0052     while (!list_empty(&mep->req_list)) {
0053         mreq = list_first_entry(&mep->req_list,
0054                     struct mtu3_request, list);
0055         mtu3_req_complete(mep, &mreq->request, status);
0056     }
0057 }
0058 
0059 static int mtu3_ep_enable(struct mtu3_ep *mep)
0060 {
0061     const struct usb_endpoint_descriptor *desc;
0062     const struct usb_ss_ep_comp_descriptor *comp_desc;
0063     struct mtu3 *mtu = mep->mtu;
0064     u32 interval = 0;
0065     u32 mult = 0;
0066     u32 burst = 0;
0067     int ret;
0068 
0069     desc = mep->desc;
0070     comp_desc = mep->comp_desc;
0071     mep->type = usb_endpoint_type(desc);
0072     mep->maxp = usb_endpoint_maxp(desc);
0073 
0074     switch (mtu->g.speed) {
0075     case USB_SPEED_SUPER:
0076     case USB_SPEED_SUPER_PLUS:
0077         if (usb_endpoint_xfer_int(desc) ||
0078                 usb_endpoint_xfer_isoc(desc)) {
0079             interval = desc->bInterval;
0080             interval = clamp_val(interval, 1, 16);
0081             if (usb_endpoint_xfer_isoc(desc) && comp_desc)
0082                 mult = comp_desc->bmAttributes;
0083         }
0084         if (comp_desc)
0085             burst = comp_desc->bMaxBurst;
0086 
0087         break;
0088     case USB_SPEED_HIGH:
0089         if (usb_endpoint_xfer_isoc(desc) ||
0090                 usb_endpoint_xfer_int(desc)) {
0091             interval = desc->bInterval;
0092             interval = clamp_val(interval, 1, 16);
0093             mult = usb_endpoint_maxp_mult(desc) - 1;
0094         }
0095         break;
0096     case USB_SPEED_FULL:
0097         if (usb_endpoint_xfer_isoc(desc))
0098             interval = clamp_val(desc->bInterval, 1, 16);
0099         else if (usb_endpoint_xfer_int(desc))
0100             interval = clamp_val(desc->bInterval, 1, 255);
0101 
0102         break;
0103     default:
0104         break; /*others are ignored */
0105     }
0106 
0107     dev_dbg(mtu->dev, "%s maxp:%d, interval:%d, burst:%d, mult:%d\n",
0108         __func__, mep->maxp, interval, burst, mult);
0109 
0110     mep->ep.maxpacket = mep->maxp;
0111     mep->ep.desc = desc;
0112     mep->ep.comp_desc = comp_desc;
0113 
0114     /* slot mainly affects bulk/isoc transfer, so ignore int */
0115     mep->slot = usb_endpoint_xfer_int(desc) ? 0 : mtu->slot;
0116 
0117     ret = mtu3_config_ep(mtu, mep, interval, burst, mult);
0118     if (ret < 0)
0119         return ret;
0120 
0121     ret = mtu3_gpd_ring_alloc(mep);
0122     if (ret < 0) {
0123         mtu3_deconfig_ep(mtu, mep);
0124         return ret;
0125     }
0126 
0127     mtu3_qmu_start(mep);
0128 
0129     return 0;
0130 }
0131 
0132 static int mtu3_ep_disable(struct mtu3_ep *mep)
0133 {
0134     struct mtu3 *mtu = mep->mtu;
0135 
0136     mtu3_qmu_stop(mep);
0137 
0138     /* abort all pending requests */
0139     nuke(mep, -ESHUTDOWN);
0140     mtu3_deconfig_ep(mtu, mep);
0141     mtu3_gpd_ring_free(mep);
0142 
0143     mep->desc = NULL;
0144     mep->ep.desc = NULL;
0145     mep->comp_desc = NULL;
0146     mep->type = 0;
0147     mep->flags = 0;
0148 
0149     return 0;
0150 }
0151 
0152 static int mtu3_gadget_ep_enable(struct usb_ep *ep,
0153         const struct usb_endpoint_descriptor *desc)
0154 {
0155     struct mtu3_ep *mep;
0156     struct mtu3 *mtu;
0157     unsigned long flags;
0158     int ret = -EINVAL;
0159 
0160     if (!ep || !desc || desc->bDescriptorType != USB_DT_ENDPOINT) {
0161         pr_debug("%s invalid parameters\n", __func__);
0162         return -EINVAL;
0163     }
0164 
0165     if (!desc->wMaxPacketSize) {
0166         pr_debug("%s missing wMaxPacketSize\n", __func__);
0167         return -EINVAL;
0168     }
0169     mep = to_mtu3_ep(ep);
0170     mtu = mep->mtu;
0171 
0172     /* check ep number and direction against endpoint */
0173     if (usb_endpoint_num(desc) != mep->epnum)
0174         return -EINVAL;
0175 
0176     if (!!usb_endpoint_dir_in(desc) ^ !!mep->is_in)
0177         return -EINVAL;
0178 
0179     dev_dbg(mtu->dev, "%s %s\n", __func__, ep->name);
0180 
0181     if (mep->flags & MTU3_EP_ENABLED) {
0182         dev_WARN_ONCE(mtu->dev, true, "%s is already enabled\n",
0183                 mep->name);
0184         return 0;
0185     }
0186 
0187     spin_lock_irqsave(&mtu->lock, flags);
0188     mep->desc = desc;
0189     mep->comp_desc = ep->comp_desc;
0190 
0191     ret = mtu3_ep_enable(mep);
0192     if (ret)
0193         goto error;
0194 
0195     mep->flags = MTU3_EP_ENABLED;
0196     mtu->active_ep++;
0197 
0198 error:
0199     spin_unlock_irqrestore(&mtu->lock, flags);
0200 
0201     dev_dbg(mtu->dev, "%s active_ep=%d\n", __func__, mtu->active_ep);
0202     trace_mtu3_gadget_ep_enable(mep);
0203 
0204     return ret;
0205 }
0206 
0207 static int mtu3_gadget_ep_disable(struct usb_ep *ep)
0208 {
0209     struct mtu3_ep *mep = to_mtu3_ep(ep);
0210     struct mtu3 *mtu = mep->mtu;
0211     unsigned long flags;
0212 
0213     dev_dbg(mtu->dev, "%s %s\n", __func__, mep->name);
0214     trace_mtu3_gadget_ep_disable(mep);
0215 
0216     if (!(mep->flags & MTU3_EP_ENABLED)) {
0217         dev_warn(mtu->dev, "%s is already disabled\n", mep->name);
0218         return 0;
0219     }
0220 
0221     spin_lock_irqsave(&mtu->lock, flags);
0222     mtu3_ep_disable(mep);
0223     mep->flags = 0;
0224     mtu->active_ep--;
0225     spin_unlock_irqrestore(&(mtu->lock), flags);
0226 
0227     dev_dbg(mtu->dev, "%s active_ep=%d, mtu3 is_active=%d\n",
0228         __func__, mtu->active_ep, mtu->is_active);
0229 
0230     return 0;
0231 }
0232 
0233 struct usb_request *mtu3_alloc_request(struct usb_ep *ep, gfp_t gfp_flags)
0234 {
0235     struct mtu3_ep *mep = to_mtu3_ep(ep);
0236     struct mtu3_request *mreq;
0237 
0238     mreq = kzalloc(sizeof(*mreq), gfp_flags);
0239     if (!mreq)
0240         return NULL;
0241 
0242     mreq->request.dma = DMA_ADDR_INVALID;
0243     mreq->epnum = mep->epnum;
0244     mreq->mep = mep;
0245     INIT_LIST_HEAD(&mreq->list);
0246     trace_mtu3_alloc_request(mreq);
0247 
0248     return &mreq->request;
0249 }
0250 
0251 void mtu3_free_request(struct usb_ep *ep, struct usb_request *req)
0252 {
0253     struct mtu3_request *mreq = to_mtu3_request(req);
0254 
0255     trace_mtu3_free_request(mreq);
0256     kfree(mreq);
0257 }
0258 
0259 static int mtu3_gadget_queue(struct usb_ep *ep,
0260         struct usb_request *req, gfp_t gfp_flags)
0261 {
0262     struct mtu3_ep *mep = to_mtu3_ep(ep);
0263     struct mtu3_request *mreq = to_mtu3_request(req);
0264     struct mtu3 *mtu = mep->mtu;
0265     unsigned long flags;
0266     int ret = 0;
0267 
0268     if (!req->buf)
0269         return -ENODATA;
0270 
0271     if (mreq->mep != mep)
0272         return -EINVAL;
0273 
0274     dev_dbg(mtu->dev, "%s %s EP%d(%s), req=%p, maxp=%d, len#%d\n",
0275         __func__, mep->is_in ? "TX" : "RX", mreq->epnum, ep->name,
0276         mreq, ep->maxpacket, mreq->request.length);
0277 
0278     if (req->length > GPD_BUF_SIZE ||
0279         (mtu->gen2cp && req->length > GPD_BUF_SIZE_EL)) {
0280         dev_warn(mtu->dev,
0281             "req length > supported MAX:%d requested:%d\n",
0282             mtu->gen2cp ? GPD_BUF_SIZE_EL : GPD_BUF_SIZE,
0283             req->length);
0284         return -EOPNOTSUPP;
0285     }
0286 
0287     /* don't queue if the ep is down */
0288     if (!mep->desc) {
0289         dev_dbg(mtu->dev, "req=%p queued to %s while it's disabled\n",
0290             req, ep->name);
0291         return -ESHUTDOWN;
0292     }
0293 
0294     mreq->mtu = mtu;
0295     mreq->request.actual = 0;
0296     mreq->request.status = -EINPROGRESS;
0297 
0298     ret = usb_gadget_map_request(&mtu->g, req, mep->is_in);
0299     if (ret) {
0300         dev_err(mtu->dev, "dma mapping failed\n");
0301         return ret;
0302     }
0303 
0304     spin_lock_irqsave(&mtu->lock, flags);
0305 
0306     if (mtu3_prepare_transfer(mep)) {
0307         ret = -EAGAIN;
0308         goto error;
0309     }
0310 
0311     list_add_tail(&mreq->list, &mep->req_list);
0312     mtu3_insert_gpd(mep, mreq);
0313     mtu3_qmu_resume(mep);
0314 
0315 error:
0316     spin_unlock_irqrestore(&mtu->lock, flags);
0317     trace_mtu3_gadget_queue(mreq);
0318 
0319     return ret;
0320 }
0321 
0322 static int mtu3_gadget_dequeue(struct usb_ep *ep, struct usb_request *req)
0323 {
0324     struct mtu3_ep *mep = to_mtu3_ep(ep);
0325     struct mtu3_request *mreq = to_mtu3_request(req);
0326     struct mtu3_request *r;
0327     struct mtu3 *mtu = mep->mtu;
0328     unsigned long flags;
0329     int ret = 0;
0330 
0331     if (mreq->mep != mep)
0332         return -EINVAL;
0333 
0334     dev_dbg(mtu->dev, "%s : req=%p\n", __func__, req);
0335     trace_mtu3_gadget_dequeue(mreq);
0336 
0337     spin_lock_irqsave(&mtu->lock, flags);
0338 
0339     list_for_each_entry(r, &mep->req_list, list) {
0340         if (r == mreq)
0341             break;
0342     }
0343     if (r != mreq) {
0344         dev_dbg(mtu->dev, "req=%p not queued to %s\n", req, ep->name);
0345         ret = -EINVAL;
0346         goto done;
0347     }
0348 
0349     mtu3_qmu_flush(mep);  /* REVISIT: set BPS ?? */
0350     mtu3_req_complete(mep, req, -ECONNRESET);
0351     mtu3_qmu_start(mep);
0352 
0353 done:
0354     spin_unlock_irqrestore(&mtu->lock, flags);
0355 
0356     return ret;
0357 }
0358 
0359 /*
0360  * Set or clear the halt bit of an EP.
0361  * A halted EP won't TX/RX any data but will queue requests.
0362  */
0363 static int mtu3_gadget_ep_set_halt(struct usb_ep *ep, int value)
0364 {
0365     struct mtu3_ep *mep = to_mtu3_ep(ep);
0366     struct mtu3 *mtu = mep->mtu;
0367     struct mtu3_request *mreq;
0368     unsigned long flags;
0369     int ret = 0;
0370 
0371     dev_dbg(mtu->dev, "%s : %s...", __func__, ep->name);
0372 
0373     spin_lock_irqsave(&mtu->lock, flags);
0374 
0375     if (mep->type == USB_ENDPOINT_XFER_ISOC) {
0376         ret = -EINVAL;
0377         goto done;
0378     }
0379 
0380     mreq = next_request(mep);
0381     if (value) {
0382         /*
0383          * If there is not request for TX-EP, QMU will not transfer
0384          * data to TX-FIFO, so no need check whether TX-FIFO
0385          * holds bytes or not here
0386          */
0387         if (mreq) {
0388             dev_dbg(mtu->dev, "req in progress, cannot halt %s\n",
0389                 ep->name);
0390             ret = -EAGAIN;
0391             goto done;
0392         }
0393     } else {
0394         mep->flags &= ~MTU3_EP_WEDGE;
0395     }
0396 
0397     dev_dbg(mtu->dev, "%s %s stall\n", ep->name, value ? "set" : "clear");
0398 
0399     mtu3_ep_stall_set(mep, value);
0400 
0401 done:
0402     spin_unlock_irqrestore(&mtu->lock, flags);
0403     trace_mtu3_gadget_ep_set_halt(mep);
0404 
0405     return ret;
0406 }
0407 
0408 /* Sets the halt feature with the clear requests ignored */
0409 static int mtu3_gadget_ep_set_wedge(struct usb_ep *ep)
0410 {
0411     struct mtu3_ep *mep = to_mtu3_ep(ep);
0412 
0413     mep->flags |= MTU3_EP_WEDGE;
0414 
0415     return usb_ep_set_halt(ep);
0416 }
0417 
0418 static const struct usb_ep_ops mtu3_ep_ops = {
0419     .enable = mtu3_gadget_ep_enable,
0420     .disable = mtu3_gadget_ep_disable,
0421     .alloc_request = mtu3_alloc_request,
0422     .free_request = mtu3_free_request,
0423     .queue = mtu3_gadget_queue,
0424     .dequeue = mtu3_gadget_dequeue,
0425     .set_halt = mtu3_gadget_ep_set_halt,
0426     .set_wedge = mtu3_gadget_ep_set_wedge,
0427 };
0428 
0429 static int mtu3_gadget_get_frame(struct usb_gadget *gadget)
0430 {
0431     struct mtu3 *mtu = gadget_to_mtu3(gadget);
0432 
0433     return (int)mtu3_readl(mtu->mac_base, U3D_USB20_FRAME_NUM);
0434 }
0435 
0436 static void function_wake_notif(struct mtu3 *mtu, u8 intf)
0437 {
0438     mtu3_writel(mtu->mac_base, U3D_DEV_NOTIF_0,
0439             TYPE_FUNCTION_WAKE | DEV_NOTIF_VAL_FW(intf));
0440     mtu3_setbits(mtu->mac_base, U3D_DEV_NOTIF_0, SEND_DEV_NOTIF);
0441 }
0442 
0443 static int mtu3_gadget_wakeup(struct usb_gadget *gadget)
0444 {
0445     struct mtu3 *mtu = gadget_to_mtu3(gadget);
0446     unsigned long flags;
0447 
0448     dev_dbg(mtu->dev, "%s\n", __func__);
0449 
0450     /* remote wakeup feature is not enabled by host */
0451     if (!mtu->may_wakeup)
0452         return  -EOPNOTSUPP;
0453 
0454     spin_lock_irqsave(&mtu->lock, flags);
0455     if (mtu->g.speed >= USB_SPEED_SUPER) {
0456         /*
0457          * class driver may do function wakeup even UFP is in U0,
0458          * and UX_EXIT only takes effect in U1/U2/U3;
0459          */
0460         mtu3_setbits(mtu->mac_base, U3D_LINK_POWER_CONTROL, UX_EXIT);
0461         /*
0462          * Assume there's only one function on the composite device
0463          * and enable remote wake for the first interface.
0464          * FIXME if the IAD (interface association descriptor) shows
0465          * there is more than one function.
0466          */
0467         function_wake_notif(mtu, 0);
0468     } else {
0469         mtu3_setbits(mtu->mac_base, U3D_POWER_MANAGEMENT, RESUME);
0470         spin_unlock_irqrestore(&mtu->lock, flags);
0471         usleep_range(10000, 11000);
0472         spin_lock_irqsave(&mtu->lock, flags);
0473         mtu3_clrbits(mtu->mac_base, U3D_POWER_MANAGEMENT, RESUME);
0474     }
0475     spin_unlock_irqrestore(&mtu->lock, flags);
0476     return 0;
0477 }
0478 
0479 static int mtu3_gadget_set_self_powered(struct usb_gadget *gadget,
0480         int is_selfpowered)
0481 {
0482     struct mtu3 *mtu = gadget_to_mtu3(gadget);
0483 
0484     mtu->is_self_powered = !!is_selfpowered;
0485     return 0;
0486 }
0487 
0488 static int mtu3_gadget_pullup(struct usb_gadget *gadget, int is_on)
0489 {
0490     struct mtu3 *mtu = gadget_to_mtu3(gadget);
0491     unsigned long flags;
0492 
0493     dev_dbg(mtu->dev, "%s (%s) for %sactive device\n", __func__,
0494         is_on ? "on" : "off", mtu->is_active ? "" : "in");
0495 
0496     pm_runtime_get_sync(mtu->dev);
0497 
0498     /* we'd rather not pullup unless the device is active. */
0499     spin_lock_irqsave(&mtu->lock, flags);
0500 
0501     is_on = !!is_on;
0502     if (!mtu->is_active) {
0503         /* save it for mtu3_start() to process the request */
0504         mtu->softconnect = is_on;
0505     } else if (is_on != mtu->softconnect) {
0506         mtu->softconnect = is_on;
0507         mtu3_dev_on_off(mtu, is_on);
0508     }
0509 
0510     spin_unlock_irqrestore(&mtu->lock, flags);
0511     pm_runtime_put(mtu->dev);
0512 
0513     return 0;
0514 }
0515 
0516 static int mtu3_gadget_start(struct usb_gadget *gadget,
0517         struct usb_gadget_driver *driver)
0518 {
0519     struct mtu3 *mtu = gadget_to_mtu3(gadget);
0520     unsigned long flags;
0521 
0522     if (mtu->gadget_driver) {
0523         dev_err(mtu->dev, "%s is already bound to %s\n",
0524             mtu->g.name, mtu->gadget_driver->driver.name);
0525         return -EBUSY;
0526     }
0527 
0528     dev_dbg(mtu->dev, "bind driver %s\n", driver->function);
0529     pm_runtime_get_sync(mtu->dev);
0530 
0531     spin_lock_irqsave(&mtu->lock, flags);
0532 
0533     mtu->softconnect = 0;
0534     mtu->gadget_driver = driver;
0535 
0536     if (mtu->ssusb->dr_mode == USB_DR_MODE_PERIPHERAL)
0537         mtu3_start(mtu);
0538 
0539     spin_unlock_irqrestore(&mtu->lock, flags);
0540     pm_runtime_put(mtu->dev);
0541 
0542     return 0;
0543 }
0544 
0545 static void stop_activity(struct mtu3 *mtu)
0546 {
0547     struct usb_gadget_driver *driver = mtu->gadget_driver;
0548     int i;
0549 
0550     /* don't disconnect if it's not connected */
0551     if (mtu->g.speed == USB_SPEED_UNKNOWN)
0552         driver = NULL;
0553     else
0554         mtu->g.speed = USB_SPEED_UNKNOWN;
0555 
0556     /* deactivate the hardware */
0557     if (mtu->softconnect) {
0558         mtu->softconnect = 0;
0559         mtu3_dev_on_off(mtu, 0);
0560     }
0561 
0562     /*
0563      * killing any outstanding requests will quiesce the driver;
0564      * then report disconnect
0565      */
0566     nuke(mtu->ep0, -ESHUTDOWN);
0567     for (i = 1; i < mtu->num_eps; i++) {
0568         nuke(mtu->in_eps + i, -ESHUTDOWN);
0569         nuke(mtu->out_eps + i, -ESHUTDOWN);
0570     }
0571 
0572     if (driver) {
0573         spin_unlock(&mtu->lock);
0574         driver->disconnect(&mtu->g);
0575         spin_lock(&mtu->lock);
0576     }
0577 }
0578 
0579 static int mtu3_gadget_stop(struct usb_gadget *g)
0580 {
0581     struct mtu3 *mtu = gadget_to_mtu3(g);
0582     unsigned long flags;
0583 
0584     dev_dbg(mtu->dev, "%s\n", __func__);
0585 
0586     spin_lock_irqsave(&mtu->lock, flags);
0587 
0588     stop_activity(mtu);
0589     mtu->gadget_driver = NULL;
0590 
0591     if (mtu->ssusb->dr_mode == USB_DR_MODE_PERIPHERAL)
0592         mtu3_stop(mtu);
0593 
0594     spin_unlock_irqrestore(&mtu->lock, flags);
0595 
0596     synchronize_irq(mtu->irq);
0597     return 0;
0598 }
0599 
0600 static void
0601 mtu3_gadget_set_speed(struct usb_gadget *g, enum usb_device_speed speed)
0602 {
0603     struct mtu3 *mtu = gadget_to_mtu3(g);
0604     unsigned long flags;
0605 
0606     dev_dbg(mtu->dev, "%s %s\n", __func__, usb_speed_string(speed));
0607 
0608     spin_lock_irqsave(&mtu->lock, flags);
0609     mtu->speed = speed;
0610     spin_unlock_irqrestore(&mtu->lock, flags);
0611 }
0612 
0613 static void mtu3_gadget_async_callbacks(struct usb_gadget *g, bool enable)
0614 {
0615     struct mtu3 *mtu = gadget_to_mtu3(g);
0616     unsigned long flags;
0617 
0618     dev_dbg(mtu->dev, "%s %s\n", __func__, enable ? "en" : "dis");
0619 
0620     spin_lock_irqsave(&mtu->lock, flags);
0621     mtu->async_callbacks = enable;
0622     spin_unlock_irqrestore(&mtu->lock, flags);
0623 }
0624 
0625 static const struct usb_gadget_ops mtu3_gadget_ops = {
0626     .get_frame = mtu3_gadget_get_frame,
0627     .wakeup = mtu3_gadget_wakeup,
0628     .set_selfpowered = mtu3_gadget_set_self_powered,
0629     .pullup = mtu3_gadget_pullup,
0630     .udc_start = mtu3_gadget_start,
0631     .udc_stop = mtu3_gadget_stop,
0632     .udc_set_speed = mtu3_gadget_set_speed,
0633     .udc_async_callbacks = mtu3_gadget_async_callbacks,
0634 };
0635 
0636 static void mtu3_state_reset(struct mtu3 *mtu)
0637 {
0638     mtu->address = 0;
0639     mtu->ep0_state = MU3D_EP0_STATE_SETUP;
0640     mtu->may_wakeup = 0;
0641     mtu->u1_enable = 0;
0642     mtu->u2_enable = 0;
0643     mtu->delayed_status = false;
0644     mtu->test_mode = false;
0645 }
0646 
0647 static void init_hw_ep(struct mtu3 *mtu, struct mtu3_ep *mep,
0648         u32 epnum, u32 is_in)
0649 {
0650     mep->epnum = epnum;
0651     mep->mtu = mtu;
0652     mep->is_in = is_in;
0653 
0654     INIT_LIST_HEAD(&mep->req_list);
0655 
0656     sprintf(mep->name, "ep%d%s", epnum,
0657         !epnum ? "" : (is_in ? "in" : "out"));
0658 
0659     mep->ep.name = mep->name;
0660     INIT_LIST_HEAD(&mep->ep.ep_list);
0661 
0662     /* initialize maxpacket as SS */
0663     if (!epnum) {
0664         usb_ep_set_maxpacket_limit(&mep->ep, 512);
0665         mep->ep.caps.type_control = true;
0666         mep->ep.ops = &mtu3_ep0_ops;
0667         mtu->g.ep0 = &mep->ep;
0668     } else {
0669         usb_ep_set_maxpacket_limit(&mep->ep, 1024);
0670         mep->ep.caps.type_iso = true;
0671         mep->ep.caps.type_bulk = true;
0672         mep->ep.caps.type_int = true;
0673         mep->ep.ops = &mtu3_ep_ops;
0674         list_add_tail(&mep->ep.ep_list, &mtu->g.ep_list);
0675     }
0676 
0677     dev_dbg(mtu->dev, "%s, name=%s, maxp=%d\n", __func__, mep->ep.name,
0678          mep->ep.maxpacket);
0679 
0680     if (!epnum) {
0681         mep->ep.caps.dir_in = true;
0682         mep->ep.caps.dir_out = true;
0683     } else if (is_in) {
0684         mep->ep.caps.dir_in = true;
0685     } else {
0686         mep->ep.caps.dir_out = true;
0687     }
0688 }
0689 
0690 static void mtu3_gadget_init_eps(struct mtu3 *mtu)
0691 {
0692     u8 epnum;
0693 
0694     /* initialize endpoint list just once */
0695     INIT_LIST_HEAD(&(mtu->g.ep_list));
0696 
0697     dev_dbg(mtu->dev, "%s num_eps(1 for a pair of tx&rx ep)=%d\n",
0698         __func__, mtu->num_eps);
0699 
0700     init_hw_ep(mtu, mtu->ep0, 0, 0);
0701     for (epnum = 1; epnum < mtu->num_eps; epnum++) {
0702         init_hw_ep(mtu, mtu->in_eps + epnum, epnum, 1);
0703         init_hw_ep(mtu, mtu->out_eps + epnum, epnum, 0);
0704     }
0705 }
0706 
0707 int mtu3_gadget_setup(struct mtu3 *mtu)
0708 {
0709     mtu->g.ops = &mtu3_gadget_ops;
0710     mtu->g.max_speed = mtu->max_speed;
0711     mtu->g.speed = USB_SPEED_UNKNOWN;
0712     mtu->g.sg_supported = 0;
0713     mtu->g.name = MTU3_DRIVER_NAME;
0714     mtu->g.irq = mtu->irq;
0715     mtu->is_active = 0;
0716     mtu->delayed_status = false;
0717 
0718     mtu3_gadget_init_eps(mtu);
0719 
0720     return usb_add_gadget_udc(mtu->dev, &mtu->g);
0721 }
0722 
0723 void mtu3_gadget_cleanup(struct mtu3 *mtu)
0724 {
0725     usb_del_gadget_udc(&mtu->g);
0726 }
0727 
0728 void mtu3_gadget_resume(struct mtu3 *mtu)
0729 {
0730     dev_dbg(mtu->dev, "gadget RESUME\n");
0731     if (mtu->async_callbacks && mtu->gadget_driver && mtu->gadget_driver->resume) {
0732         spin_unlock(&mtu->lock);
0733         mtu->gadget_driver->resume(&mtu->g);
0734         spin_lock(&mtu->lock);
0735     }
0736 }
0737 
0738 /* called when SOF packets stop for 3+ msec or enters U3 */
0739 void mtu3_gadget_suspend(struct mtu3 *mtu)
0740 {
0741     dev_dbg(mtu->dev, "gadget SUSPEND\n");
0742     if (mtu->async_callbacks && mtu->gadget_driver && mtu->gadget_driver->suspend) {
0743         spin_unlock(&mtu->lock);
0744         mtu->gadget_driver->suspend(&mtu->g);
0745         spin_lock(&mtu->lock);
0746     }
0747 }
0748 
0749 /* called when VBUS drops below session threshold, and in other cases */
0750 void mtu3_gadget_disconnect(struct mtu3 *mtu)
0751 {
0752     dev_dbg(mtu->dev, "gadget DISCONNECT\n");
0753     if (mtu->async_callbacks && mtu->gadget_driver && mtu->gadget_driver->disconnect) {
0754         spin_unlock(&mtu->lock);
0755         mtu->gadget_driver->disconnect(&mtu->g);
0756         spin_lock(&mtu->lock);
0757     }
0758 
0759     mtu3_state_reset(mtu);
0760     usb_gadget_set_state(&mtu->g, USB_STATE_NOTATTACHED);
0761 }
0762 
0763 void mtu3_gadget_reset(struct mtu3 *mtu)
0764 {
0765     dev_dbg(mtu->dev, "gadget RESET\n");
0766 
0767     /* report disconnect, if we didn't flush EP state */
0768     if (mtu->g.speed != USB_SPEED_UNKNOWN)
0769         mtu3_gadget_disconnect(mtu);
0770     else
0771         mtu3_state_reset(mtu);
0772 }
[ Source navigation ] [ Diff markup ] [ Identifier search ] [ general search ]

This page was automatically generated by the 2.1.0 LXR engine.

The LXR team
Valid CSS 2.1! Valid HTML 4.01!