source: src/linux/universal/linux-4.4/drivers/usb/dwc3/gadget.c @ 31884

Last change on this file since 31884 was 31884, checked in by brainslayer, 6 weeks ago

update kernels

File size: 80.3 KB
Line 
1/**
2 * gadget.c - DesignWare USB3 DRD Controller Gadget Framework Link
3 *
4 * Copyright (C) 2010-2011 Texas Instruments Incorporated - http://www.ti.com
5 *
6 * Authors: Felipe Balbi <balbi@ti.com>,
7 *          Sebastian Andrzej Siewior <bigeasy@linutronix.de>
8 *
9 * This program is free software: you can redistribute it and/or modify
10 * it under the terms of the GNU General Public License version 2  of
11 * the License as published by the Free Software Foundation.
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#include <linux/kernel.h>
20#include <linux/delay.h>
21#include <linux/slab.h>
22#include <linux/spinlock.h>
23#include <linux/platform_device.h>
24#include <linux/pm_runtime.h>
25#include <linux/interrupt.h>
26#include <linux/io.h>
27#include <linux/list.h>
28#include <linux/dma-mapping.h>
29
30#include <linux/usb/ch9.h>
31#include <linux/usb/gadget.h>
32
33#include "debug.h"
34#include "core.h"
35#include "gadget.h"
36#include "io.h"
37
38#ifdef CONFIG_USB_DWC3_AL_RMN_2648
39#include <linux/of.h>
40#include <mach/alpine_machine.h>
41#include "al_hal/al_hal_common.h"
42#include "al_hal/al_hal_serdes_regs.h"
43#endif
44
45#ifdef CONFIG_USB_DWC3_AL_VBUS_GPIO
46#include <linux/irq.h>
47#include <linux/of_gpio.h>
48#include "linux/workqueue.h"
49#endif
50
51/**
52 * dwc3_gadget_set_test_mode - Enables USB2 Test Modes
53 * @dwc: pointer to our context structure
54 * @mode: the mode to set (J, K SE0 NAK, Force Enable)
55 *
56 * Caller should take care of locking. This function will
57 * return 0 on success or -EINVAL if wrong Test Selector
58 * is passed
59 */
60int dwc3_gadget_set_test_mode(struct dwc3 *dwc, int mode)
61{
62        u32             reg;
63
64        reg = dwc3_readl(dwc->regs, DWC3_DCTL);
65        reg &= ~DWC3_DCTL_TSTCTRL_MASK;
66
67        switch (mode) {
68        case TEST_J:
69        case TEST_K:
70        case TEST_SE0_NAK:
71        case TEST_PACKET:
72        case TEST_FORCE_EN:
73                reg |= mode << 1;
74                break;
75        default:
76                return -EINVAL;
77        }
78
79        dwc3_writel(dwc->regs, DWC3_DCTL, reg);
80
81        return 0;
82}
83
84/**
85 * dwc3_gadget_get_link_state - Gets current state of USB Link
86 * @dwc: pointer to our context structure
87 *
88 * Caller should take care of locking. This function will
89 * return the link state on success (>= 0) or -ETIMEDOUT.
90 */
91int dwc3_gadget_get_link_state(struct dwc3 *dwc)
92{
93        u32             reg;
94
95        reg = dwc3_readl(dwc->regs, DWC3_DSTS);
96
97        return DWC3_DSTS_USBLNKST(reg);
98}
99
100/**
101 * dwc3_gadget_set_link_state - Sets USB Link to a particular State
102 * @dwc: pointer to our context structure
103 * @state: the state to put link into
104 *
105 * Caller should take care of locking. This function will
106 * return 0 on success or -ETIMEDOUT.
107 */
108int dwc3_gadget_set_link_state(struct dwc3 *dwc, enum dwc3_link_state state)
109{
110        int             retries = 10000;
111        u32             reg;
112
113        /*
114         * Wait until device controller is ready. Only applies to 1.94a and
115         * later RTL.
116         */
117        if (dwc->revision >= DWC3_REVISION_194A) {
118                while (--retries) {
119                        reg = dwc3_readl(dwc->regs, DWC3_DSTS);
120                        if (reg & DWC3_DSTS_DCNRD)
121                                udelay(5);
122                        else
123                                break;
124                }
125
126                if (retries <= 0)
127                        return -ETIMEDOUT;
128        }
129
130        reg = dwc3_readl(dwc->regs, DWC3_DCTL);
131        reg &= ~DWC3_DCTL_ULSTCHNGREQ_MASK;
132
133        /* set requested state */
134        reg |= DWC3_DCTL_ULSTCHNGREQ(state);
135        dwc3_writel(dwc->regs, DWC3_DCTL, reg);
136
137        /*
138         * The following code is racy when called from dwc3_gadget_wakeup,
139         * and is not needed, at least on newer versions
140         */
141        if (dwc->revision >= DWC3_REVISION_194A)
142                return 0;
143
144        /* wait for a change in DSTS */
145        retries = 10000;
146        while (--retries) {
147                reg = dwc3_readl(dwc->regs, DWC3_DSTS);
148
149                if (DWC3_DSTS_USBLNKST(reg) == state)
150                        return 0;
151
152                udelay(5);
153        }
154
155        dwc3_trace(trace_dwc3_gadget,
156                        "link state change request timed out");
157
158        return -ETIMEDOUT;
159}
160
161/**
162 * dwc3_gadget_resize_tx_fifos - reallocate fifo spaces for current use-case
163 * @dwc: pointer to our context structure
164 *
165 * This function will a best effort FIFO allocation in order
166 * to improve FIFO usage and throughput, while still allowing
167 * us to enable as many endpoints as possible.
168 *
169 * Keep in mind that this operation will be highly dependent
170 * on the configured size for RAM1 - which contains TxFifo -,
171 * the amount of endpoints enabled on coreConsultant tool, and
172 * the width of the Master Bus.
173 *
174 * In the ideal world, we would always be able to satisfy the
175 * following equation:
176 *
177 * ((512 + 2 * MDWIDTH-Bytes) + (Number of IN Endpoints - 1) * \
178 * (3 * (1024 + MDWIDTH-Bytes) + MDWIDTH-Bytes)) / MDWIDTH-Bytes
179 *
180 * Unfortunately, due to many variables that's not always the case.
181 */
182int dwc3_gadget_resize_tx_fifos(struct dwc3 *dwc)
183{
184        int             last_fifo_depth = 0;
185        int             ram1_depth;
186        int             fifo_size;
187        int             mdwidth;
188        int             num;
189
190        if (!dwc->needs_fifo_resize)
191                return 0;
192
193        ram1_depth = DWC3_RAM1_DEPTH(dwc->hwparams.hwparams7);
194        mdwidth = DWC3_MDWIDTH(dwc->hwparams.hwparams0);
195
196        /* MDWIDTH is represented in bits, we need it in bytes */
197        mdwidth >>= 3;
198
199        /*
200         * FIXME For now we will only allocate 1 wMaxPacketSize space
201         * for each enabled endpoint, later patches will come to
202         * improve this algorithm so that we better use the internal
203         * FIFO space
204         */
205        for (num = 0; num < dwc->num_in_eps; num++) {
206                /* bit0 indicates direction; 1 means IN ep */
207                struct dwc3_ep  *dep = dwc->eps[(num << 1) | 1];
208                int             mult = 1;
209                int             tmp;
210
211                if (!(dep->flags & DWC3_EP_ENABLED))
212                        continue;
213
214                if (usb_endpoint_xfer_bulk(dep->endpoint.desc)
215                                || usb_endpoint_xfer_isoc(dep->endpoint.desc))
216                        mult = 3;
217
218                /*
219                 * REVISIT: the following assumes we will always have enough
220                 * space available on the FIFO RAM for all possible use cases.
221                 * Make sure that's true somehow and change FIFO allocation
222                 * accordingly.
223                 *
224                 * If we have Bulk or Isochronous endpoints, we want
225                 * them to be able to be very, very fast. So we're giving
226                 * those endpoints a fifo_size which is enough for 3 full
227                 * packets
228                 */
229                tmp = mult * (dep->endpoint.maxpacket + mdwidth);
230                tmp += mdwidth;
231
232                fifo_size = DIV_ROUND_UP(tmp, mdwidth);
233
234                fifo_size |= (last_fifo_depth << 16);
235
236                dwc3_trace(trace_dwc3_gadget, "%s: Fifo Addr %04x Size %d",
237                                dep->name, last_fifo_depth, fifo_size & 0xffff);
238
239                dwc3_writel(dwc->regs, DWC3_GTXFIFOSIZ(num), fifo_size);
240
241                last_fifo_depth += (fifo_size & 0xffff);
242        }
243
244        return 0;
245}
246
247void dwc3_gadget_giveback(struct dwc3_ep *dep, struct dwc3_request *req,
248                int status)
249{
250        struct dwc3                     *dwc = dep->dwc;
251        unsigned int                    unmap_after_complete = false;
252        int                             i;
253
254        if (req->queued) {
255                i = 0;
256                do {
257                        dep->busy_slot++;
258                        /*
259                         * Skip LINK TRB. We can't use req->trb and check for
260                         * DWC3_TRBCTL_LINK_TRB because it points the TRB we
261                         * just completed (not the LINK TRB).
262                         */
263                        if (((dep->busy_slot & DWC3_TRB_MASK) ==
264                                DWC3_TRB_NUM- 1) &&
265                                usb_endpoint_xfer_isoc(dep->endpoint.desc))
266                                dep->busy_slot++;
267                } while(++i < req->request.num_mapped_sgs);
268                req->queued = false;
269        }
270        list_del(&req->list);
271        req->trb = NULL;
272
273        if (req->request.status == -EINPROGRESS)
274                req->request.status = status;
275
276        /*
277         * NOTICE we don't want to unmap before calling ->complete() if we're
278         * dealing with a bounced ep0 request. If we unmap it here, we would end
279         * up overwritting the contents of req->buf and this could confuse the
280         * gadget driver.
281         */
282        if (dwc->ep0_bounced && dep->number <= 1) {
283                dwc->ep0_bounced = false;
284                unmap_after_complete = true;
285        } else {
286                usb_gadget_unmap_request(&dwc->gadget,
287                                &req->request, req->direction);
288        }
289
290        dev_dbg(dwc->dev, "request %p from %s completed %d/%d ===> %d\n",
291                        req, dep->name, req->request.actual,
292                        req->request.length, status);
293        trace_dwc3_gadget_giveback(req);
294
295        spin_unlock(&dwc->lock);
296        usb_gadget_giveback_request(&dep->endpoint, &req->request);
297        spin_lock(&dwc->lock);
298
299        if (unmap_after_complete)
300                usb_gadget_unmap_request(&dwc->gadget,
301                                &req->request, req->direction);
302}
303
304int dwc3_send_gadget_generic_command(struct dwc3 *dwc, unsigned cmd, u32 param)
305{
306        u32             timeout = 500;
307        u32             reg;
308
309        trace_dwc3_gadget_generic_cmd(cmd, param);
310
311        dwc3_writel(dwc->regs, DWC3_DGCMDPAR, param);
312        dwc3_writel(dwc->regs, DWC3_DGCMD, cmd | DWC3_DGCMD_CMDACT);
313
314        do {
315                reg = dwc3_readl(dwc->regs, DWC3_DGCMD);
316                if (!(reg & DWC3_DGCMD_CMDACT)) {
317                        dwc3_trace(trace_dwc3_gadget,
318                                        "Command Complete --> %d",
319                                        DWC3_DGCMD_STATUS(reg));
320                        if (DWC3_DGCMD_STATUS(reg))
321                                return -EINVAL;
322                        return 0;
323                }
324
325                /*
326                 * We can't sleep here, because it's also called from
327                 * interrupt context.
328                 */
329                timeout--;
330                if (!timeout) {
331                        dwc3_trace(trace_dwc3_gadget,
332                                        "Command Timed Out");
333                        return -ETIMEDOUT;
334                }
335                udelay(1);
336        } while (1);
337}
338
339int dwc3_send_gadget_ep_cmd(struct dwc3 *dwc, unsigned ep,
340                unsigned cmd, struct dwc3_gadget_ep_cmd_params *params)
341{
342        struct dwc3_ep          *dep = dwc->eps[ep];
343        u32                     timeout = 500;
344        u32                     reg;
345
346        trace_dwc3_gadget_ep_cmd(dep, cmd, params);
347
348        dwc3_writel(dwc->regs, DWC3_DEPCMDPAR0(ep), params->param0);
349        dwc3_writel(dwc->regs, DWC3_DEPCMDPAR1(ep), params->param1);
350        dwc3_writel(dwc->regs, DWC3_DEPCMDPAR2(ep), params->param2);
351
352        dwc3_writel(dwc->regs, DWC3_DEPCMD(ep), cmd | DWC3_DEPCMD_CMDACT);
353        do {
354                reg = dwc3_readl(dwc->regs, DWC3_DEPCMD(ep));
355                if (!(reg & DWC3_DEPCMD_CMDACT)) {
356                        dwc3_trace(trace_dwc3_gadget,
357                                        "Command Complete --> %d",
358                                        DWC3_DEPCMD_STATUS(reg));
359                        if (DWC3_DEPCMD_STATUS(reg))
360                                return -EINVAL;
361                        return 0;
362                }
363
364                /*
365                 * We can't sleep here, because it is also called from
366                 * interrupt context.
367                 */
368                timeout--;
369                if (!timeout) {
370                        dwc3_trace(trace_dwc3_gadget,
371                                        "Command Timed Out");
372                        return -ETIMEDOUT;
373                }
374
375                udelay(1);
376        } while (1);
377}
378
379static dma_addr_t dwc3_trb_dma_offset(struct dwc3_ep *dep,
380                struct dwc3_trb *trb)
381{
382        u32             offset = (char *) trb - (char *) dep->trb_pool;
383
384        return dep->trb_pool_dma + offset;
385}
386
387static int dwc3_alloc_trb_pool(struct dwc3_ep *dep)
388{
389        struct dwc3             *dwc = dep->dwc;
390
391        if (dep->trb_pool)
392                return 0;
393
394        dep->trb_pool = dma_alloc_coherent(dwc->dev,
395                        sizeof(struct dwc3_trb) * DWC3_TRB_NUM,
396                        &dep->trb_pool_dma, GFP_KERNEL);
397        if (!dep->trb_pool) {
398                dev_err(dep->dwc->dev, "failed to allocate trb pool for %s\n",
399                                dep->name);
400                return -ENOMEM;
401        }
402
403        return 0;
404}
405
406static void dwc3_free_trb_pool(struct dwc3_ep *dep)
407{
408        struct dwc3             *dwc = dep->dwc;
409
410        dma_free_coherent(dwc->dev, sizeof(struct dwc3_trb) * DWC3_TRB_NUM,
411                        dep->trb_pool, dep->trb_pool_dma);
412
413        dep->trb_pool = NULL;
414        dep->trb_pool_dma = 0;
415}
416
417static int dwc3_gadget_set_xfer_resource(struct dwc3 *dwc, struct dwc3_ep *dep);
418
419/**
420 * dwc3_gadget_start_config - Configure EP resources
421 * @dwc: pointer to our controller context structure
422 * @dep: endpoint that is being enabled
423 *
424 * The assignment of transfer resources cannot perfectly follow the
425 * data book due to the fact that the controller driver does not have
426 * all knowledge of the configuration in advance. It is given this
427 * information piecemeal by the composite gadget framework after every
428 * SET_CONFIGURATION and SET_INTERFACE. Trying to follow the databook
429 * programming model in this scenario can cause errors. For two
430 * reasons:
431 *
432 * 1) The databook says to do DEPSTARTCFG for every SET_CONFIGURATION
433 * and SET_INTERFACE (8.1.5). This is incorrect in the scenario of
434 * multiple interfaces.
435 *
436 * 2) The databook does not mention doing more DEPXFERCFG for new
437 * endpoint on alt setting (8.1.6).
438 *
439 * The following simplified method is used instead:
440 *
441 * All hardware endpoints can be assigned a transfer resource and this
442 * setting will stay persistent until either a core reset or
443 * hibernation. So whenever we do a DEPSTARTCFG(0) we can go ahead and
444 * do DEPXFERCFG for every hardware endpoint as well. We are
445 * guaranteed that there are as many transfer resources as endpoints.
446 *
447 * This function is called for each endpoint when it is being enabled
448 * but is triggered only when called for EP0-out, which always happens
449 * first, and which should only happen in one of the above conditions.
450 */
451static int dwc3_gadget_start_config(struct dwc3 *dwc, struct dwc3_ep *dep)
452{
453        struct dwc3_gadget_ep_cmd_params params;
454        u32                     cmd;
455        int                     i;
456        int                     ret;
457
458        if (dep->number)
459                return 0;
460
461        memset(&params, 0x00, sizeof(params));
462        cmd = DWC3_DEPCMD_DEPSTARTCFG;
463
464        ret = dwc3_send_gadget_ep_cmd(dwc, 0, cmd, &params);
465        if (ret)
466                return ret;
467
468        for (i = 0; i < DWC3_ENDPOINTS_NUM; i++) {
469                struct dwc3_ep *dep = dwc->eps[i];
470
471                if (!dep)
472                        continue;
473
474                ret = dwc3_gadget_set_xfer_resource(dwc, dep);
475                if (ret)
476                        return ret;
477        }
478
479        return 0;
480}
481
482static int dwc3_gadget_set_ep_config(struct dwc3 *dwc, struct dwc3_ep *dep,
483                const struct usb_endpoint_descriptor *desc,
484                const struct usb_ss_ep_comp_descriptor *comp_desc,
485                bool ignore, bool restore)
486{
487        struct dwc3_gadget_ep_cmd_params params;
488
489        memset(&params, 0x00, sizeof(params));
490
491        params.param0 = DWC3_DEPCFG_EP_TYPE(usb_endpoint_type(desc))
492                | DWC3_DEPCFG_MAX_PACKET_SIZE(usb_endpoint_maxp(desc));
493
494        /* Burst size is only needed in SuperSpeed mode */
495        if (dwc->gadget.speed == USB_SPEED_SUPER) {
496                u32 burst = dep->endpoint.maxburst - 1;
497
498                params.param0 |= DWC3_DEPCFG_BURST_SIZE(burst);
499        }
500
501        if (ignore)
502                params.param0 |= DWC3_DEPCFG_IGN_SEQ_NUM;
503
504        if (restore) {
505                params.param0 |= DWC3_DEPCFG_ACTION_RESTORE;
506                params.param2 |= dep->saved_state;
507        }
508
509        params.param1 = DWC3_DEPCFG_XFER_COMPLETE_EN
510                | DWC3_DEPCFG_XFER_NOT_READY_EN;
511
512        if (usb_ss_max_streams(comp_desc) && usb_endpoint_xfer_bulk(desc)) {
513                params.param1 |= DWC3_DEPCFG_STREAM_CAPABLE
514                        | DWC3_DEPCFG_STREAM_EVENT_EN;
515                dep->stream_capable = true;
516        }
517
518        if (!usb_endpoint_xfer_control(desc))
519                params.param1 |= DWC3_DEPCFG_XFER_IN_PROGRESS_EN;
520
521        /*
522         * We are doing 1:1 mapping for endpoints, meaning
523         * Physical Endpoints 2 maps to Logical Endpoint 2 and
524         * so on. We consider the direction bit as part of the physical
525         * endpoint number. So USB endpoint 0x81 is 0x03.
526         */
527        params.param1 |= DWC3_DEPCFG_EP_NUMBER(dep->number);
528
529        /*
530         * We must use the lower 16 TX FIFOs even though
531         * HW might have more
532         */
533        if (dep->direction)
534                params.param0 |= DWC3_DEPCFG_FIFO_NUMBER(dep->number >> 1);
535
536        if (desc->bInterval) {
537                params.param1 |= DWC3_DEPCFG_BINTERVAL_M1(desc->bInterval - 1);
538                dep->interval = 1 << (desc->bInterval - 1);
539        }
540
541        return dwc3_send_gadget_ep_cmd(dwc, dep->number,
542                        DWC3_DEPCMD_SETEPCONFIG, &params);
543}
544
545static int dwc3_gadget_set_xfer_resource(struct dwc3 *dwc, struct dwc3_ep *dep)
546{
547        struct dwc3_gadget_ep_cmd_params params;
548
549        memset(&params, 0x00, sizeof(params));
550
551        params.param0 = DWC3_DEPXFERCFG_NUM_XFER_RES(1);
552
553        return dwc3_send_gadget_ep_cmd(dwc, dep->number,
554                        DWC3_DEPCMD_SETTRANSFRESOURCE, &params);
555}
556
557/**
558 * __dwc3_gadget_ep_enable - Initializes a HW endpoint
559 * @dep: endpoint to be initialized
560 * @desc: USB Endpoint Descriptor
561 *
562 * Caller should take care of locking
563 */
564static int __dwc3_gadget_ep_enable(struct dwc3_ep *dep,
565                const struct usb_endpoint_descriptor *desc,
566                const struct usb_ss_ep_comp_descriptor *comp_desc,
567                bool ignore, bool restore)
568{
569        struct dwc3             *dwc = dep->dwc;
570        u32                     reg;
571        int                     ret;
572
573        dwc3_trace(trace_dwc3_gadget, "Enabling %s", dep->name);
574
575        if (!(dep->flags & DWC3_EP_ENABLED)) {
576                ret = dwc3_gadget_start_config(dwc, dep);
577                if (ret)
578                        return ret;
579        }
580
581        ret = dwc3_gadget_set_ep_config(dwc, dep, desc, comp_desc, ignore,
582                        restore);
583        if (ret)
584                return ret;
585
586        if (!(dep->flags & DWC3_EP_ENABLED)) {
587                struct dwc3_trb *trb_st_hw;
588                struct dwc3_trb *trb_link;
589
590                dep->endpoint.desc = desc;
591                dep->comp_desc = comp_desc;
592                dep->type = usb_endpoint_type(desc);
593                dep->flags |= DWC3_EP_ENABLED;
594
595                reg = dwc3_readl(dwc->regs, DWC3_DALEPENA);
596                reg |= DWC3_DALEPENA_EP(dep->number);
597                dwc3_writel(dwc->regs, DWC3_DALEPENA, reg);
598
599                if (!usb_endpoint_xfer_isoc(desc))
600                        return 0;
601
602                /* Link TRB for ISOC. The HWO bit is never reset */
603                trb_st_hw = &dep->trb_pool[0];
604
605                trb_link = &dep->trb_pool[DWC3_TRB_NUM - 1];
606                memset(trb_link, 0, sizeof(*trb_link));
607
608                trb_link->bpl = lower_32_bits(dwc3_trb_dma_offset(dep, trb_st_hw));
609                trb_link->bph = upper_32_bits(dwc3_trb_dma_offset(dep, trb_st_hw));
610                trb_link->ctrl |= DWC3_TRBCTL_LINK_TRB;
611                trb_link->ctrl |= DWC3_TRB_CTRL_HWO;
612        }
613
614        switch (usb_endpoint_type(desc)) {
615        case USB_ENDPOINT_XFER_CONTROL:
616                strlcat(dep->name, "-control", sizeof(dep->name));
617                break;
618        case USB_ENDPOINT_XFER_ISOC:
619                strlcat(dep->name, "-isoc", sizeof(dep->name));
620                break;
621        case USB_ENDPOINT_XFER_BULK:
622                strlcat(dep->name, "-bulk", sizeof(dep->name));
623                break;
624        case USB_ENDPOINT_XFER_INT:
625                strlcat(dep->name, "-int", sizeof(dep->name));
626                break;
627        default:
628                dev_err(dwc->dev, "invalid endpoint transfer type\n");
629        }
630
631        return 0;
632}
633
634static void dwc3_stop_active_transfer(struct dwc3 *dwc, u32 epnum, bool force);
635static void dwc3_remove_requests(struct dwc3 *dwc, struct dwc3_ep *dep)
636{
637        struct dwc3_request             *req;
638
639        if (!list_empty(&dep->req_queued)) {
640                dwc3_stop_active_transfer(dwc, dep->number, true);
641
642                /* - giveback all requests to gadget driver */
643                while (!list_empty(&dep->req_queued)) {
644                        req = next_request(&dep->req_queued);
645
646                        dwc3_gadget_giveback(dep, req, -ESHUTDOWN);
647                }
648        }
649
650        while (!list_empty(&dep->request_list)) {
651                req = next_request(&dep->request_list);
652
653                dwc3_gadget_giveback(dep, req, -ESHUTDOWN);
654        }
655}
656
657/**
658 * __dwc3_gadget_ep_disable - Disables a HW endpoint
659 * @dep: the endpoint to disable
660 *
661 * This function also removes requests which are currently processed ny the
662 * hardware and those which are not yet scheduled.
663 * Caller should take care of locking.
664 */
665static int __dwc3_gadget_ep_disable(struct dwc3_ep *dep)
666{
667        struct dwc3             *dwc = dep->dwc;
668        u32                     reg;
669
670        dwc3_trace(trace_dwc3_gadget, "Disabling %s", dep->name);
671
672        dwc3_remove_requests(dwc, dep);
673
674        /* make sure HW endpoint isn't stalled */
675        if (dep->flags & DWC3_EP_STALL)
676                __dwc3_gadget_ep_set_halt(dep, 0, false);
677
678        reg = dwc3_readl(dwc->regs, DWC3_DALEPENA);
679        reg &= ~DWC3_DALEPENA_EP(dep->number);
680        dwc3_writel(dwc->regs, DWC3_DALEPENA, reg);
681
682        dep->stream_capable = false;
683        dep->endpoint.desc = NULL;
684        dep->comp_desc = NULL;
685        dep->type = 0;
686        dep->flags = 0;
687
688        snprintf(dep->name, sizeof(dep->name), "ep%d%s",
689                        dep->number >> 1,
690                        (dep->number & 1) ? "in" : "out");
691
692        return 0;
693}
694
695/* -------------------------------------------------------------------------- */
696
697static int dwc3_gadget_ep0_enable(struct usb_ep *ep,
698                const struct usb_endpoint_descriptor *desc)
699{
700        return -EINVAL;
701}
702
703static int dwc3_gadget_ep0_disable(struct usb_ep *ep)
704{
705        return -EINVAL;
706}
707
708/* -------------------------------------------------------------------------- */
709
710static int dwc3_gadget_ep_enable(struct usb_ep *ep,
711                const struct usb_endpoint_descriptor *desc)
712{
713        struct dwc3_ep                  *dep;
714        struct dwc3                     *dwc;
715        unsigned long                   flags;
716        int                             ret;
717
718        if (!ep || !desc || desc->bDescriptorType != USB_DT_ENDPOINT) {
719                pr_debug("dwc3: invalid parameters\n");
720                return -EINVAL;
721        }
722
723        if (!desc->wMaxPacketSize) {
724                pr_debug("dwc3: missing wMaxPacketSize\n");
725                return -EINVAL;
726        }
727
728        dep = to_dwc3_ep(ep);
729        dwc = dep->dwc;
730
731        if (dep->flags & DWC3_EP_ENABLED) {
732                dev_WARN_ONCE(dwc->dev, true, "%s is already enabled\n",
733                                dep->name);
734                return 0;
735        }
736
737        spin_lock_irqsave(&dwc->lock, flags);
738        ret = __dwc3_gadget_ep_enable(dep, desc, ep->comp_desc, false, false);
739        spin_unlock_irqrestore(&dwc->lock, flags);
740
741        return ret;
742}
743
744static int dwc3_gadget_ep_disable(struct usb_ep *ep)
745{
746        struct dwc3_ep                  *dep;
747        struct dwc3                     *dwc;
748        unsigned long                   flags;
749        int                             ret;
750
751        if (!ep) {
752                pr_debug("dwc3: invalid parameters\n");
753                return -EINVAL;
754        }
755
756        dep = to_dwc3_ep(ep);
757        dwc = dep->dwc;
758
759        if (!(dep->flags & DWC3_EP_ENABLED)) {
760                dev_WARN_ONCE(dwc->dev, true, "%s is already disabled\n",
761                                dep->name);
762                return 0;
763        }
764
765        spin_lock_irqsave(&dwc->lock, flags);
766        ret = __dwc3_gadget_ep_disable(dep);
767        spin_unlock_irqrestore(&dwc->lock, flags);
768
769        return ret;
770}
771
772static struct usb_request *dwc3_gadget_ep_alloc_request(struct usb_ep *ep,
773        gfp_t gfp_flags)
774{
775        struct dwc3_request             *req;
776        struct dwc3_ep                  *dep = to_dwc3_ep(ep);
777
778        req = kzalloc(sizeof(*req), gfp_flags);
779        if (!req)
780                return NULL;
781
782        req->epnum      = dep->number;
783        req->dep        = dep;
784
785        trace_dwc3_alloc_request(req);
786
787        return &req->request;
788}
789
790static void dwc3_gadget_ep_free_request(struct usb_ep *ep,
791                struct usb_request *request)
792{
793        struct dwc3_request             *req = to_dwc3_request(request);
794
795        trace_dwc3_free_request(req);
796        kfree(req);
797}
798
799/**
800 * dwc3_prepare_one_trb - setup one TRB from one request
801 * @dep: endpoint for which this request is prepared
802 * @req: dwc3_request pointer
803 */
804static void dwc3_prepare_one_trb(struct dwc3_ep *dep,
805                struct dwc3_request *req, dma_addr_t dma,
806                unsigned length, unsigned last, unsigned chain, unsigned node)
807{
808        struct dwc3_trb         *trb;
809
810        dwc3_trace(trace_dwc3_gadget, "%s: req %p dma %08llx length %d%s%s",
811                        dep->name, req, (unsigned long long) dma,
812                        length, last ? " last" : "",
813                        chain ? " chain" : "");
814
815
816        trb = &dep->trb_pool[dep->free_slot & DWC3_TRB_MASK];
817
818        if (!req->trb) {
819                dwc3_gadget_move_request_queued(req);
820                req->trb = trb;
821                req->trb_dma = dwc3_trb_dma_offset(dep, trb);
822                req->start_slot = dep->free_slot & DWC3_TRB_MASK;
823        }
824
825        dep->free_slot++;
826        /* Skip the LINK-TRB on ISOC */
827        if (((dep->free_slot & DWC3_TRB_MASK) == DWC3_TRB_NUM - 1) &&
828                        usb_endpoint_xfer_isoc(dep->endpoint.desc))
829                dep->free_slot++;
830
831        trb->size = DWC3_TRB_SIZE_LENGTH(length);
832        trb->bpl = lower_32_bits(dma);
833        trb->bph = upper_32_bits(dma);
834
835        switch (usb_endpoint_type(dep->endpoint.desc)) {
836        case USB_ENDPOINT_XFER_CONTROL:
837                trb->ctrl = DWC3_TRBCTL_CONTROL_SETUP;
838                break;
839
840        case USB_ENDPOINT_XFER_ISOC:
841                if (!node)
842                        trb->ctrl = DWC3_TRBCTL_ISOCHRONOUS_FIRST;
843                else
844                        trb->ctrl = DWC3_TRBCTL_ISOCHRONOUS;
845                break;
846
847        case USB_ENDPOINT_XFER_BULK:
848        case USB_ENDPOINT_XFER_INT:
849                trb->ctrl = DWC3_TRBCTL_NORMAL;
850                break;
851        default:
852                /*
853                 * This is only possible with faulty memory because we
854                 * checked it already :)
855                 */
856                BUG();
857        }
858
859        if (!req->request.no_interrupt && !chain)
860                trb->ctrl |= DWC3_TRB_CTRL_IOC;
861
862        if (usb_endpoint_xfer_isoc(dep->endpoint.desc)) {
863                trb->ctrl |= DWC3_TRB_CTRL_ISP_IMI;
864                trb->ctrl |= DWC3_TRB_CTRL_CSP;
865        } else if (last) {
866                trb->ctrl |= DWC3_TRB_CTRL_LST;
867        }
868
869        if (chain)
870                trb->ctrl |= DWC3_TRB_CTRL_CHN;
871
872        if (usb_endpoint_xfer_bulk(dep->endpoint.desc) && dep->stream_capable)
873                trb->ctrl |= DWC3_TRB_CTRL_SID_SOFN(req->request.stream_id);
874
875        trb->ctrl |= DWC3_TRB_CTRL_HWO;
876
877        trace_dwc3_prepare_trb(dep, trb);
878}
879
880/*
881 * dwc3_prepare_trbs - setup TRBs from requests
882 * @dep: endpoint for which requests are being prepared
883 * @starting: true if the endpoint is idle and no requests are queued.
884 *
885 * The function goes through the requests list and sets up TRBs for the
886 * transfers. The function returns once there are no more TRBs available or
887 * it runs out of requests.
888 */
889static void dwc3_prepare_trbs(struct dwc3_ep *dep, bool starting)
890{
891        struct dwc3_request     *req, *n;
892        u32                     trbs_left;
893        u32                     max;
894        unsigned int            last_one = 0;
895
896        BUILD_BUG_ON_NOT_POWER_OF_2(DWC3_TRB_NUM);
897
898        /* the first request must not be queued */
899        trbs_left = (dep->busy_slot - dep->free_slot) & DWC3_TRB_MASK;
900
901        /* Can't wrap around on a non-isoc EP since there's no link TRB */
902        if (!usb_endpoint_xfer_isoc(dep->endpoint.desc)) {
903                max = DWC3_TRB_NUM - (dep->free_slot & DWC3_TRB_MASK);
904                if (trbs_left > max)
905                        trbs_left = max;
906        }
907
908        /*
909         * If busy & slot are equal than it is either full or empty. If we are
910         * starting to process requests then we are empty. Otherwise we are
911         * full and don't do anything
912         */
913        if (!trbs_left) {
914                if (!starting)
915                        return;
916                trbs_left = DWC3_TRB_NUM;
917                /*
918                 * In case we start from scratch, we queue the ISOC requests
919                 * starting from slot 1. This is done because we use ring
920                 * buffer and have no LST bit to stop us. Instead, we place
921                 * IOC bit every TRB_NUM/4. We try to avoid having an interrupt
922                 * after the first request so we start at slot 1 and have
923                 * 7 requests proceed before we hit the first IOC.
924                 * Other transfer types don't use the ring buffer and are
925                 * processed from the first TRB until the last one. Since we
926                 * don't wrap around we have to start at the beginning.
927                 */
928                if (usb_endpoint_xfer_isoc(dep->endpoint.desc)) {
929                        dep->busy_slot = 1;
930                        dep->free_slot = 1;
931                } else {
932                        dep->busy_slot = 0;
933                        dep->free_slot = 0;
934                }
935        }
936
937        /* The last TRB is a link TRB, not used for xfer */
938        if ((trbs_left <= 1) && usb_endpoint_xfer_isoc(dep->endpoint.desc))
939                return;
940
941        list_for_each_entry_safe(req, n, &dep->request_list, list) {
942                unsigned        length;
943                dma_addr_t      dma;
944                last_one = false;
945
946                if (req->request.num_mapped_sgs > 0) {
947                        struct usb_request *request = &req->request;
948                        struct scatterlist *sg = request->sg;
949                        struct scatterlist *s;
950                        int             i;
951
952                        for_each_sg(sg, s, request->num_mapped_sgs, i) {
953                                unsigned chain = true;
954
955                                length = sg_dma_len(s);
956                                dma = sg_dma_address(s);
957
958                                if (i == (request->num_mapped_sgs - 1) ||
959                                                sg_is_last(s)) {
960                                        if (list_empty(&dep->request_list))
961                                                last_one = true;
962                                        chain = false;
963                                }
964
965                                trbs_left--;
966                                if (!trbs_left)
967                                        last_one = true;
968
969                                if (last_one)
970                                        chain = false;
971
972                                dwc3_prepare_one_trb(dep, req, dma, length,
973                                                last_one, chain, i);
974
975                                if (last_one)
976                                        break;
977                        }
978
979                        if (last_one)
980                                break;
981                } else {
982                        dma = req->request.dma;
983                        length = req->request.length;
984                        trbs_left--;
985
986                        if (!trbs_left)
987                                last_one = 1;
988
989                        /* Is this the last request? */
990                        if (list_is_last(&req->list, &dep->request_list))
991                                last_one = 1;
992
993                        dwc3_prepare_one_trb(dep, req, dma, length,
994                                        last_one, false, 0);
995
996                        if (last_one)
997                                break;
998                }
999        }
1000}
1001
1002static int __dwc3_gadget_kick_transfer(struct dwc3_ep *dep, u16 cmd_param,
1003                int start_new)
1004{
1005        struct dwc3_gadget_ep_cmd_params params;
1006        struct dwc3_request             *req;
1007        struct dwc3                     *dwc = dep->dwc;
1008        int                             ret;
1009        u32                             cmd;
1010
1011        if (start_new && (dep->flags & DWC3_EP_BUSY)) {
1012                dwc3_trace(trace_dwc3_gadget, "%s: endpoint busy", dep->name);
1013                return -EBUSY;
1014        }
1015
1016        /*
1017         * If we are getting here after a short-out-packet we don't enqueue any
1018         * new requests as we try to set the IOC bit only on the last request.
1019         */
1020        if (start_new) {
1021                if (list_empty(&dep->req_queued))
1022                        dwc3_prepare_trbs(dep, start_new);
1023
1024                /* req points to the first request which will be sent */
1025                req = next_request(&dep->req_queued);
1026        } else {
1027                dwc3_prepare_trbs(dep, start_new);
1028
1029                /*
1030                 * req points to the first request where HWO changed from 0 to 1
1031                 */
1032                req = next_request(&dep->req_queued);
1033        }
1034        if (!req) {
1035                dep->flags |= DWC3_EP_PENDING_REQUEST;
1036                return 0;
1037        }
1038
1039        memset(&params, 0, sizeof(params));
1040
1041        if (start_new) {
1042                params.param0 = upper_32_bits(req->trb_dma);
1043                params.param1 = lower_32_bits(req->trb_dma);
1044                cmd = DWC3_DEPCMD_STARTTRANSFER;
1045        } else {
1046                cmd = DWC3_DEPCMD_UPDATETRANSFER;
1047        }
1048
1049        cmd |= DWC3_DEPCMD_PARAM(cmd_param);
1050        ret = dwc3_send_gadget_ep_cmd(dwc, dep->number, cmd, &params);
1051        if (ret < 0) {
1052                dev_dbg(dwc->dev, "failed to send STARTTRANSFER command\n");
1053
1054                /*
1055                 * FIXME we need to iterate over the list of requests
1056                 * here and stop, unmap, free and del each of the linked
1057                 * requests instead of what we do now.
1058                 */
1059                usb_gadget_unmap_request(&dwc->gadget, &req->request,
1060                                req->direction);
1061                list_del(&req->list);
1062                return ret;
1063        }
1064
1065        dep->flags |= DWC3_EP_BUSY;
1066
1067        if (start_new) {
1068                dep->resource_index = dwc3_gadget_ep_get_transfer_index(dwc,
1069                                dep->number);
1070                WARN_ON_ONCE(!dep->resource_index);
1071        }
1072
1073        return 0;
1074}
1075
1076static void __dwc3_gadget_start_isoc(struct dwc3 *dwc,
1077                struct dwc3_ep *dep, u32 cur_uf)
1078{
1079        u32 uf;
1080
1081        if (list_empty(&dep->request_list)) {
1082                dwc3_trace(trace_dwc3_gadget,
1083                                "ISOC ep %s run out for requests",
1084                                dep->name);
1085                dep->flags |= DWC3_EP_PENDING_REQUEST;
1086                return;
1087        }
1088
1089        /* 4 micro frames in the future */
1090        uf = cur_uf + dep->interval * 4;
1091
1092        __dwc3_gadget_kick_transfer(dep, uf, 1);
1093}
1094
1095static void dwc3_gadget_start_isoc(struct dwc3 *dwc,
1096                struct dwc3_ep *dep, const struct dwc3_event_depevt *event)
1097{
1098        u32 cur_uf, mask;
1099
1100        mask = ~(dep->interval - 1);
1101        cur_uf = event->parameters & mask;
1102
1103        __dwc3_gadget_start_isoc(dwc, dep, cur_uf);
1104}
1105
1106static int __dwc3_gadget_ep_queue(struct dwc3_ep *dep, struct dwc3_request *req)
1107{
1108        struct dwc3             *dwc = dep->dwc;
1109        int                     ret;
1110
1111        req->request.actual     = 0;
1112        req->request.status     = -EINPROGRESS;
1113        req->direction          = dep->direction;
1114        req->epnum              = dep->number;
1115
1116        trace_dwc3_ep_queue(req);
1117
1118        ret = usb_gadget_map_request(&dwc->gadget, &req->request,
1119                        dep->direction);
1120        if (ret)
1121                return ret;
1122
1123        list_add_tail(&req->list, &dep->request_list);
1124
1125        /*
1126         * If there are no pending requests and the endpoint isn't already
1127         * busy, we will just start the request straight away.
1128         *
1129         * This will save one IRQ (XFER_NOT_READY) and possibly make it a
1130         * little bit faster.
1131         */
1132        if (!usb_endpoint_xfer_isoc(dep->endpoint.desc) &&
1133                        !usb_endpoint_xfer_int(dep->endpoint.desc) &&
1134                        !(dep->flags & DWC3_EP_BUSY)) {
1135                ret = __dwc3_gadget_kick_transfer(dep, 0, true);
1136                goto out;
1137        }
1138
1139        /*
1140         * There are a few special cases:
1141         *
1142         * 1. XferNotReady with empty list of requests. We need to kick the
1143         *    transfer here in that situation, otherwise we will be NAKing
1144         *    forever. If we get XferNotReady before gadget driver has a
1145         *    chance to queue a request, we will ACK the IRQ but won't be
1146         *    able to receive the data until the next request is queued.
1147         *    The following code is handling exactly that.
1148         *
1149         */
1150        if (dep->flags & DWC3_EP_PENDING_REQUEST) {
1151                /*
1152                 * If xfernotready is already elapsed and it is a case
1153                 * of isoc transfer, then issue END TRANSFER, so that
1154                 * you can receive xfernotready again and can have
1155                 * notion of current microframe.
1156                 */
1157                if (usb_endpoint_xfer_isoc(dep->endpoint.desc)) {
1158                        if (list_empty(&dep->req_queued)) {
1159                                dwc3_stop_active_transfer(dwc, dep->number, true);
1160                                dep->flags = DWC3_EP_ENABLED;
1161                        }
1162                        return 0;
1163                }
1164
1165                ret = __dwc3_gadget_kick_transfer(dep, 0, true);
1166                if (!ret)
1167                        dep->flags &= ~DWC3_EP_PENDING_REQUEST;
1168
1169                goto out;
1170        }
1171
1172        /*
1173         * 2. XferInProgress on Isoc EP with an active transfer. We need to
1174         *    kick the transfer here after queuing a request, otherwise the
1175         *    core may not see the modified TRB(s).
1176         */
1177        if (usb_endpoint_xfer_isoc(dep->endpoint.desc) &&
1178                        (dep->flags & DWC3_EP_BUSY) &&
1179                        !(dep->flags & DWC3_EP_MISSED_ISOC)) {
1180                WARN_ON_ONCE(!dep->resource_index);
1181                ret = __dwc3_gadget_kick_transfer(dep, dep->resource_index,
1182                                false);
1183                goto out;
1184        }
1185
1186        /*
1187         * 4. Stream Capable Bulk Endpoints. We need to start the transfer
1188         * right away, otherwise host will not know we have streams to be
1189         * handled.
1190         */
1191        if (dep->stream_capable)
1192                ret = __dwc3_gadget_kick_transfer(dep, 0, true);
1193
1194out:
1195        if (ret && ret != -EBUSY)
1196                dev_dbg(dwc->dev, "%s: failed to kick transfers\n",
1197                                dep->name);
1198        if (ret == -EBUSY)
1199                ret = 0;
1200
1201        return ret;
1202}
1203
1204static int dwc3_gadget_ep_queue(struct usb_ep *ep, struct usb_request *request,
1205        gfp_t gfp_flags)
1206{
1207        struct dwc3_request             *req = to_dwc3_request(request);
1208        struct dwc3_ep                  *dep = to_dwc3_ep(ep);
1209        struct dwc3                     *dwc = dep->dwc;
1210
1211        unsigned long                   flags;
1212
1213        int                             ret;
1214
1215        spin_lock_irqsave(&dwc->lock, flags);
1216        if (!dep->endpoint.desc) {
1217                dev_dbg(dwc->dev, "trying to queue request %p to disabled %s\n",
1218                                request, ep->name);
1219                ret = -ESHUTDOWN;
1220                goto out;
1221        }
1222
1223        if (WARN(req->dep != dep, "request %p belongs to '%s'\n",
1224                                request, req->dep->name)) {
1225                ret = -EINVAL;
1226                goto out;
1227        }
1228
1229        ret = __dwc3_gadget_ep_queue(dep, req);
1230
1231out:
1232        spin_unlock_irqrestore(&dwc->lock, flags);
1233
1234        return ret;
1235}
1236
1237static int dwc3_gadget_ep_dequeue(struct usb_ep *ep,
1238                struct usb_request *request)
1239{
1240        struct dwc3_request             *req = to_dwc3_request(request);
1241        struct dwc3_request             *r = NULL;
1242
1243        struct dwc3_ep                  *dep = to_dwc3_ep(ep);
1244        struct dwc3                     *dwc = dep->dwc;
1245
1246        unsigned long                   flags;
1247        int                             ret = 0;
1248
1249        trace_dwc3_ep_dequeue(req);
1250
1251        spin_lock_irqsave(&dwc->lock, flags);
1252
1253        list_for_each_entry(r, &dep->request_list, list) {
1254                if (r == req)
1255                        break;
1256        }
1257
1258        if (r != req) {
1259                list_for_each_entry(r, &dep->req_queued, list) {
1260                        if (r == req)
1261                                break;
1262                }
1263                if (r == req) {
1264                        /* wait until it is processed */
1265                        dwc3_stop_active_transfer(dwc, dep->number, true);
1266                        goto out1;
1267                }
1268                dev_err(dwc->dev, "request %p was not queued to %s\n",
1269                                request, ep->name);
1270                ret = -EINVAL;
1271                goto out0;
1272        }
1273
1274out1:
1275        /* giveback the request */
1276        dwc3_gadget_giveback(dep, req, -ECONNRESET);
1277
1278out0:
1279        spin_unlock_irqrestore(&dwc->lock, flags);
1280
1281        return ret;
1282}
1283
1284int __dwc3_gadget_ep_set_halt(struct dwc3_ep *dep, int value, int protocol)
1285{
1286        struct dwc3_gadget_ep_cmd_params        params;
1287        struct dwc3                             *dwc = dep->dwc;
1288        int                                     ret;
1289
1290        if (usb_endpoint_xfer_isoc(dep->endpoint.desc)) {
1291                dev_err(dwc->dev, "%s is of Isochronous type\n", dep->name);
1292                return -EINVAL;
1293        }
1294
1295        memset(&params, 0x00, sizeof(params));
1296
1297        if (value) {
1298                if (!protocol && ((dep->direction && dep->flags & DWC3_EP_BUSY) ||
1299                                (!list_empty(&dep->req_queued) ||
1300                                 !list_empty(&dep->request_list)))) {
1301                        dev_dbg(dwc->dev, "%s: pending request, cannot halt\n",
1302                                        dep->name);
1303                        return -EAGAIN;
1304                }
1305
1306                ret = dwc3_send_gadget_ep_cmd(dwc, dep->number,
1307                        DWC3_DEPCMD_SETSTALL, &params);
1308                if (ret)
1309                        dev_err(dwc->dev, "failed to set STALL on %s\n",
1310                                        dep->name);
1311                else
1312                        dep->flags |= DWC3_EP_STALL;
1313        } else {
1314                ret = dwc3_send_gadget_ep_cmd(dwc, dep->number,
1315                        DWC3_DEPCMD_CLEARSTALL, &params);
1316                if (ret)
1317                        dev_err(dwc->dev, "failed to clear STALL on %s\n",
1318                                        dep->name);
1319                else
1320                        dep->flags &= ~(DWC3_EP_STALL | DWC3_EP_WEDGE);
1321        }
1322
1323        return ret;
1324}
1325
1326static int dwc3_gadget_ep_set_halt(struct usb_ep *ep, int value)
1327{
1328        struct dwc3_ep                  *dep = to_dwc3_ep(ep);
1329        struct dwc3                     *dwc = dep->dwc;
1330
1331        unsigned long                   flags;
1332
1333        int                             ret;
1334
1335        spin_lock_irqsave(&dwc->lock, flags);
1336        ret = __dwc3_gadget_ep_set_halt(dep, value, false);
1337        spin_unlock_irqrestore(&dwc->lock, flags);
1338
1339        return ret;
1340}
1341
1342static int dwc3_gadget_ep_set_wedge(struct usb_ep *ep)
1343{
1344        struct dwc3_ep                  *dep = to_dwc3_ep(ep);
1345        struct dwc3                     *dwc = dep->dwc;
1346        unsigned long                   flags;
1347        int                             ret;
1348
1349        spin_lock_irqsave(&dwc->lock, flags);
1350        dep->flags |= DWC3_EP_WEDGE;
1351
1352        if (dep->number == 0 || dep->number == 1)
1353                ret = __dwc3_gadget_ep0_set_halt(ep, 1);
1354        else
1355                ret = __dwc3_gadget_ep_set_halt(dep, 1, false);
1356        spin_unlock_irqrestore(&dwc->lock, flags);
1357
1358        return ret;
1359}
1360
1361/* -------------------------------------------------------------------------- */
1362
1363static struct usb_endpoint_descriptor dwc3_gadget_ep0_desc = {
1364        .bLength        = USB_DT_ENDPOINT_SIZE,
1365        .bDescriptorType = USB_DT_ENDPOINT,
1366        .bmAttributes   = USB_ENDPOINT_XFER_CONTROL,
1367};
1368
1369static const struct usb_ep_ops dwc3_gadget_ep0_ops = {
1370        .enable         = dwc3_gadget_ep0_enable,
1371        .disable        = dwc3_gadget_ep0_disable,
1372        .alloc_request  = dwc3_gadget_ep_alloc_request,
1373        .free_request   = dwc3_gadget_ep_free_request,
1374        .queue          = dwc3_gadget_ep0_queue,
1375        .dequeue        = dwc3_gadget_ep_dequeue,
1376        .set_halt       = dwc3_gadget_ep0_set_halt,
1377        .set_wedge      = dwc3_gadget_ep_set_wedge,
1378};
1379
1380static const struct usb_ep_ops dwc3_gadget_ep_ops = {
1381        .enable         = dwc3_gadget_ep_enable,
1382        .disable        = dwc3_gadget_ep_disable,
1383        .alloc_request  = dwc3_gadget_ep_alloc_request,
1384        .free_request   = dwc3_gadget_ep_free_request,
1385        .queue          = dwc3_gadget_ep_queue,
1386        .dequeue        = dwc3_gadget_ep_dequeue,
1387        .set_halt       = dwc3_gadget_ep_set_halt,
1388        .set_wedge      = dwc3_gadget_ep_set_wedge,
1389};
1390
1391/* -------------------------------------------------------------------------- */
1392
1393static int dwc3_gadget_get_frame(struct usb_gadget *g)
1394{
1395        struct dwc3             *dwc = gadget_to_dwc(g);
1396        u32                     reg;
1397
1398        reg = dwc3_readl(dwc->regs, DWC3_DSTS);
1399        return DWC3_DSTS_SOFFN(reg);
1400}
1401
1402static int dwc3_gadget_wakeup(struct usb_gadget *g)
1403{
1404        struct dwc3             *dwc = gadget_to_dwc(g);
1405
1406        unsigned long           timeout;
1407        unsigned long           flags;
1408
1409        u32                     reg;
1410
1411        int                     ret = 0;
1412
1413        u8                      link_state;
1414        u8                      speed;
1415
1416        spin_lock_irqsave(&dwc->lock, flags);
1417
1418        /*
1419         * According to the Databook Remote wakeup request should
1420         * be issued only when the device is in early suspend state.
1421         *
1422         * We can check that via USB Link State bits in DSTS register.
1423         */
1424        reg = dwc3_readl(dwc->regs, DWC3_DSTS);
1425
1426        speed = reg & DWC3_DSTS_CONNECTSPD;
1427        if (speed == DWC3_DSTS_SUPERSPEED) {
1428                dev_dbg(dwc->dev, "no wakeup on SuperSpeed\n");
1429                ret = -EINVAL;
1430                goto out;
1431        }
1432
1433        link_state = DWC3_DSTS_USBLNKST(reg);
1434
1435        switch (link_state) {
1436        case DWC3_LINK_STATE_RX_DET:    /* in HS, means Early Suspend */
1437        case DWC3_LINK_STATE_U3:        /* in HS, means SUSPEND */
1438                break;
1439        default:
1440                dev_dbg(dwc->dev, "can't wakeup from link state %d\n",
1441                                link_state);
1442                ret = -EINVAL;
1443                goto out;
1444        }
1445
1446        ret = dwc3_gadget_set_link_state(dwc, DWC3_LINK_STATE_RECOV);
1447        if (ret < 0) {
1448                dev_err(dwc->dev, "failed to put link in Recovery\n");
1449                goto out;
1450        }
1451
1452        /* Recent versions do this automatically */
1453        if (dwc->revision < DWC3_REVISION_194A) {
1454                /* write zeroes to Link Change Request */
1455                reg = dwc3_readl(dwc->regs, DWC3_DCTL);
1456                reg &= ~DWC3_DCTL_ULSTCHNGREQ_MASK;
1457                dwc3_writel(dwc->regs, DWC3_DCTL, reg);
1458        }
1459
1460        /* poll until Link State changes to ON */
1461        timeout = jiffies + msecs_to_jiffies(100);
1462
1463        while (!time_after(jiffies, timeout)) {
1464                reg = dwc3_readl(dwc->regs, DWC3_DSTS);
1465
1466                /* in HS, means ON */
1467                if (DWC3_DSTS_USBLNKST(reg) == DWC3_LINK_STATE_U0)
1468                        break;
1469        }
1470
1471        if (DWC3_DSTS_USBLNKST(reg) != DWC3_LINK_STATE_U0) {
1472                dev_err(dwc->dev, "failed to send remote wakeup\n");
1473                ret = -EINVAL;
1474        }
1475
1476out:
1477        spin_unlock_irqrestore(&dwc->lock, flags);
1478
1479        return ret;
1480}
1481
1482static int dwc3_gadget_set_selfpowered(struct usb_gadget *g,
1483                int is_selfpowered)
1484{
1485        struct dwc3             *dwc = gadget_to_dwc(g);
1486        unsigned long           flags;
1487
1488        spin_lock_irqsave(&dwc->lock, flags);
1489        g->is_selfpowered = !!is_selfpowered;
1490        spin_unlock_irqrestore(&dwc->lock, flags);
1491
1492        return 0;
1493}
1494
1495static int dwc3_gadget_run_stop(struct dwc3 *dwc, int is_on, int suspend)
1496{
1497        u32                     reg;
1498        u32                     timeout = 500;
1499
1500        reg = dwc3_readl(dwc->regs, DWC3_DCTL);
1501        if (is_on) {
1502                if (dwc->revision <= DWC3_REVISION_187A) {
1503                        reg &= ~DWC3_DCTL_TRGTULST_MASK;
1504                        reg |= DWC3_DCTL_TRGTULST_RX_DET;
1505                }
1506
1507                if (dwc->revision >= DWC3_REVISION_194A)
1508                        reg &= ~DWC3_DCTL_KEEP_CONNECT;
1509                reg |= DWC3_DCTL_RUN_STOP;
1510
1511                if (dwc->has_hibernation)
1512                        reg |= DWC3_DCTL_KEEP_CONNECT;
1513
1514                dwc->pullups_connected = true;
1515        } else {
1516                reg &= ~DWC3_DCTL_RUN_STOP;
1517
1518                if (dwc->has_hibernation && !suspend)
1519                        reg &= ~DWC3_DCTL_KEEP_CONNECT;
1520
1521                dwc->pullups_connected = false;
1522        }
1523
1524        dwc3_writel(dwc->regs, DWC3_DCTL, reg);
1525
1526        do {
1527                reg = dwc3_readl(dwc->regs, DWC3_DSTS);
1528                if (is_on) {
1529                        if (!(reg & DWC3_DSTS_DEVCTRLHLT))
1530                                break;
1531                } else {
1532                        if (reg & DWC3_DSTS_DEVCTRLHLT)
1533                                break;
1534                }
1535                timeout--;
1536                if (!timeout)
1537                        return -ETIMEDOUT;
1538                udelay(1);
1539        } while (1);
1540
1541        dwc3_trace(trace_dwc3_gadget, "gadget %s data soft-%s",
1542                        dwc->gadget_driver
1543                        ? dwc->gadget_driver->function : "no-function",
1544                        is_on ? "connect" : "disconnect");
1545
1546        return 0;
1547}
1548
1549static int dwc3_gadget_pullup(struct usb_gadget *g, int is_on)
1550{
1551        struct dwc3             *dwc = gadget_to_dwc(g);
1552        unsigned long           flags;
1553        int                     ret;
1554
1555        is_on = !!is_on;
1556
1557        spin_lock_irqsave(&dwc->lock, flags);
1558        ret = dwc3_gadget_run_stop(dwc, is_on, false);
1559        spin_unlock_irqrestore(&dwc->lock, flags);
1560
1561        return ret;
1562}
1563
1564static void dwc3_gadget_enable_irq(struct dwc3 *dwc)
1565{
1566        u32                     reg;
1567
1568        /* Enable all but Start and End of Frame IRQs */
1569        reg = (DWC3_DEVTEN_VNDRDEVTSTRCVEDEN |
1570                        DWC3_DEVTEN_EVNTOVERFLOWEN |
1571                        DWC3_DEVTEN_CMDCMPLTEN |
1572                        DWC3_DEVTEN_ERRTICERREN |
1573                        DWC3_DEVTEN_WKUPEVTEN |
1574                        DWC3_DEVTEN_ULSTCNGEN |
1575                        DWC3_DEVTEN_CONNECTDONEEN |
1576                        DWC3_DEVTEN_USBRSTEN |
1577                        DWC3_DEVTEN_DISCONNEVTEN);
1578
1579        dwc3_writel(dwc->regs, DWC3_DEVTEN, reg);
1580}
1581
1582static void dwc3_gadget_disable_irq(struct dwc3 *dwc)
1583{
1584        /* mask all interrupts */
1585        dwc3_writel(dwc->regs, DWC3_DEVTEN, 0x00);
1586}
1587
1588static irqreturn_t dwc3_interrupt(int irq, void *_dwc);
1589static irqreturn_t dwc3_thread_interrupt(int irq, void *_dwc);
1590
1591static int dwc3_gadget_start(struct usb_gadget *g,
1592                struct usb_gadget_driver *driver)
1593{
1594        struct dwc3             *dwc = gadget_to_dwc(g);
1595        struct dwc3_ep          *dep;
1596        unsigned long           flags;
1597        int                     ret = 0;
1598        int                     irq;
1599        u32                     reg;
1600
1601        irq = platform_get_irq(to_platform_device(dwc->dev), 0);
1602        ret = request_threaded_irq(irq, dwc3_interrupt, dwc3_thread_interrupt,
1603                        IRQF_SHARED, "dwc3", dwc);
1604        if (ret) {
1605                dev_err(dwc->dev, "failed to request irq #%d --> %d\n",
1606                                irq, ret);
1607                goto err0;
1608        }
1609
1610        spin_lock_irqsave(&dwc->lock, flags);
1611
1612        if (dwc->gadget_driver) {
1613                dev_err(dwc->dev, "%s is already bound to %s\n",
1614                                dwc->gadget.name,
1615                                dwc->gadget_driver->driver.name);
1616                ret = -EBUSY;
1617                goto err1;
1618        }
1619
1620        dwc->gadget_driver      = driver;
1621
1622        reg = dwc3_readl(dwc->regs, DWC3_DCFG);
1623        reg &= ~(DWC3_DCFG_SPEED_MASK);
1624
1625        /**
1626         * WORKAROUND: DWC3 revision < 2.20a have an issue
1627         * which would cause metastability state on Run/Stop
1628         * bit if we try to force the IP to USB2-only mode.
1629         *
1630         * Because of that, we cannot configure the IP to any
1631         * speed other than the SuperSpeed
1632         *
1633         * Refers to:
1634         *
1635         * STAR#9000525659: Clock Domain Crossing on DCTL in
1636         * USB 2.0 Mode
1637         */
1638        if (dwc->revision < DWC3_REVISION_220A) {
1639                reg |= DWC3_DCFG_SUPERSPEED;
1640        } else {
1641                switch (dwc->maximum_speed) {
1642                case USB_SPEED_LOW:
1643                        reg |= DWC3_DSTS_LOWSPEED;
1644                        break;
1645                case USB_SPEED_FULL:
1646                        reg |= DWC3_DSTS_FULLSPEED1;
1647                        break;
1648                case USB_SPEED_HIGH:
1649                        reg |= DWC3_DSTS_HIGHSPEED;
1650                        break;
1651                case USB_SPEED_SUPER:   /* FALLTHROUGH */
1652                case USB_SPEED_UNKNOWN: /* FALTHROUGH */
1653                default:
1654                        reg |= DWC3_DSTS_SUPERSPEED;
1655                }
1656        }
1657        dwc3_writel(dwc->regs, DWC3_DCFG, reg);
1658
1659        /* Start with SuperSpeed Default */
1660        dwc3_gadget_ep0_desc.wMaxPacketSize = cpu_to_le16(512);
1661
1662        dep = dwc->eps[0];
1663        ret = __dwc3_gadget_ep_enable(dep, &dwc3_gadget_ep0_desc, NULL, false,
1664                        false);
1665        if (ret) {
1666                dev_err(dwc->dev, "failed to enable %s\n", dep->name);
1667                goto err2;
1668        }
1669
1670        dep = dwc->eps[1];
1671        ret = __dwc3_gadget_ep_enable(dep, &dwc3_gadget_ep0_desc, NULL, false,
1672                        false);
1673        if (ret) {
1674                dev_err(dwc->dev, "failed to enable %s\n", dep->name);
1675                goto err3;
1676        }
1677
1678        /* begin to receive SETUP packets */
1679        dwc->ep0state = EP0_SETUP_PHASE;
1680        dwc3_ep0_out_start(dwc);
1681
1682        dwc3_gadget_enable_irq(dwc);
1683
1684        spin_unlock_irqrestore(&dwc->lock, flags);
1685
1686        return 0;
1687
1688err3:
1689        __dwc3_gadget_ep_disable(dwc->eps[0]);
1690
1691err2:
1692        dwc->gadget_driver = NULL;
1693
1694err1:
1695        spin_unlock_irqrestore(&dwc->lock, flags);
1696
1697        free_irq(irq, dwc);
1698
1699err0:
1700        return ret;
1701}
1702
1703static int dwc3_gadget_stop(struct usb_gadget *g)
1704{
1705        struct dwc3             *dwc = gadget_to_dwc(g);
1706        unsigned long           flags;
1707        int                     irq;
1708
1709        spin_lock_irqsave(&dwc->lock, flags);
1710
1711        dwc3_gadget_disable_irq(dwc);
1712        __dwc3_gadget_ep_disable(dwc->eps[0]);
1713        __dwc3_gadget_ep_disable(dwc->eps[1]);
1714
1715        dwc->gadget_driver      = NULL;
1716
1717        spin_unlock_irqrestore(&dwc->lock, flags);
1718
1719        irq = platform_get_irq(to_platform_device(dwc->dev), 0);
1720        free_irq(irq, dwc);
1721
1722        return 0;
1723}
1724
1725static const struct usb_gadget_ops dwc3_gadget_ops = {
1726        .get_frame              = dwc3_gadget_get_frame,
1727        .wakeup                 = dwc3_gadget_wakeup,
1728        .set_selfpowered        = dwc3_gadget_set_selfpowered,
1729        .pullup                 = dwc3_gadget_pullup,
1730        .udc_start              = dwc3_gadget_start,
1731        .udc_stop               = dwc3_gadget_stop,
1732};
1733
1734/* -------------------------------------------------------------------------- */
1735
1736static int dwc3_gadget_init_hw_endpoints(struct dwc3 *dwc,
1737                u8 num, u32 direction)
1738{
1739        struct dwc3_ep                  *dep;
1740        u8                              i;
1741
1742        for (i = 0; i < num; i++) {
1743                u8 epnum = (i << 1) | (!!direction);
1744
1745                dep = kzalloc(sizeof(*dep), GFP_KERNEL);
1746                if (!dep)
1747                        return -ENOMEM;
1748
1749                dep->dwc = dwc;
1750                dep->number = epnum;
1751                dep->direction = !!direction;
1752                dwc->eps[epnum] = dep;
1753
1754                snprintf(dep->name, sizeof(dep->name), "ep%d%s", epnum >> 1,
1755                                (epnum & 1) ? "in" : "out");
1756
1757                dep->endpoint.name = dep->name;
1758
1759                dwc3_trace(trace_dwc3_gadget, "initializing %s", dep->name);
1760
1761                if (epnum == 0 || epnum == 1) {
1762                        usb_ep_set_maxpacket_limit(&dep->endpoint, 512);
1763                        dep->endpoint.maxburst = 1;
1764                        dep->endpoint.ops = &dwc3_gadget_ep0_ops;
1765                        if (!epnum)
1766                                dwc->gadget.ep0 = &dep->endpoint;
1767                } else {
1768                        int             ret;
1769
1770                        usb_ep_set_maxpacket_limit(&dep->endpoint, 1024);
1771                        dep->endpoint.max_streams = 15;
1772                        dep->endpoint.ops = &dwc3_gadget_ep_ops;
1773                        list_add_tail(&dep->endpoint.ep_list,
1774                                        &dwc->gadget.ep_list);
1775
1776                        ret = dwc3_alloc_trb_pool(dep);
1777                        if (ret)
1778                                return ret;
1779                }
1780
1781                if (epnum == 0 || epnum == 1) {
1782                        dep->endpoint.caps.type_control = true;
1783                } else {
1784                        dep->endpoint.caps.type_iso = true;
1785                        dep->endpoint.caps.type_bulk = true;
1786                        dep->endpoint.caps.type_int = true;
1787                }
1788
1789                dep->endpoint.caps.dir_in = !!direction;
1790                dep->endpoint.caps.dir_out = !direction;
1791
1792                INIT_LIST_HEAD(&dep->request_list);
1793                INIT_LIST_HEAD(&dep->req_queued);
1794        }
1795
1796        return 0;
1797}
1798
1799static int dwc3_gadget_init_endpoints(struct dwc3 *dwc)
1800{
1801        int                             ret;
1802
1803        INIT_LIST_HEAD(&dwc->gadget.ep_list);
1804
1805        ret = dwc3_gadget_init_hw_endpoints(dwc, dwc->num_out_eps, 0);
1806        if (ret < 0) {
1807                dwc3_trace(trace_dwc3_gadget,
1808                                "failed to allocate OUT endpoints");
1809                return ret;
1810        }
1811
1812        ret = dwc3_gadget_init_hw_endpoints(dwc, dwc->num_in_eps, 1);
1813        if (ret < 0) {
1814                dwc3_trace(trace_dwc3_gadget,
1815                                "failed to allocate IN endpoints");
1816                return ret;
1817        }
1818
1819        ret = __dwc3_gadget_kick_transfer(dep, 0, 1);
1820        if (ret && ret != -EBUSY) {
1821                dev_dbg(dwc->dev, "%s: failed to kick transfers\n",
1822                                dep->name);
1823                return ret;
1824        }
1825
1826        return 0;
1827}
1828
1829static void dwc3_gadget_free_endpoints(struct dwc3 *dwc)
1830{
1831        struct dwc3_ep                  *dep;
1832        u8                              epnum;
1833
1834        for (epnum = 0; epnum < DWC3_ENDPOINTS_NUM; epnum++) {
1835                dep = dwc->eps[epnum];
1836                if (!dep)
1837                        continue;
1838                /*
1839                 * Physical endpoints 0 and 1 are special; they form the
1840                 * bi-directional USB endpoint 0.
1841                 *
1842                 * For those two physical endpoints, we don't allocate a TRB
1843                 * pool nor do we add them the endpoints list. Due to that, we
1844                 * shouldn't do these two operations otherwise we would end up
1845                 * with all sorts of bugs when removing dwc3.ko.
1846                 */
1847                if (epnum != 0 && epnum != 1) {
1848                        dwc3_free_trb_pool(dep);
1849                        list_del(&dep->endpoint.ep_list);
1850                }
1851
1852                kfree(dep);
1853        }
1854}
1855
1856/* -------------------------------------------------------------------------- */
1857
1858static int __dwc3_cleanup_done_trbs(struct dwc3 *dwc, struct dwc3_ep *dep,
1859                struct dwc3_request *req, struct dwc3_trb *trb,
1860                const struct dwc3_event_depevt *event, int status)
1861{
1862        unsigned int            count;
1863        unsigned int            s_pkt = 0;
1864        unsigned int            trb_status;
1865
1866        trace_dwc3_complete_trb(dep, trb);
1867
1868        if ((trb->ctrl & DWC3_TRB_CTRL_HWO) && status != -ESHUTDOWN)
1869                /*
1870                 * We continue despite the error. There is not much we
1871                 * can do. If we don't clean it up we loop forever. If
1872                 * we skip the TRB then it gets overwritten after a
1873                 * while since we use them in a ring buffer. A BUG()
1874                 * would help. Lets hope that if this occurs, someone
1875                 * fixes the root cause instead of looking away :)
1876                 */
1877                dev_err(dwc->dev, "%s's TRB (%p) still owned by HW\n",
1878                                dep->name, trb);
1879        count = trb->size & DWC3_TRB_SIZE_MASK;
1880
1881        if (dep->direction) {
1882                if (count) {
1883                        trb_status = DWC3_TRB_SIZE_TRBSTS(trb->size);
1884                        if (trb_status == DWC3_TRBSTS_MISSED_ISOC) {
1885                                dev_dbg(dwc->dev, "incomplete IN transfer %s\n",
1886                                                dep->name);
1887                                /*
1888                                 * If missed isoc occurred and there is
1889                                 * no request queued then issue END
1890                                 * TRANSFER, so that core generates
1891                                 * next xfernotready and we will issue
1892                                 * a fresh START TRANSFER.
1893                                 * If there are still queued request
1894                                 * then wait, do not issue either END
1895                                 * or UPDATE TRANSFER, just attach next
1896                                 * request in request_list during
1897                                 * giveback.If any future queued request
1898                                 * is successfully transferred then we
1899                                 * will issue UPDATE TRANSFER for all
1900                                 * request in the request_list.
1901                                 */
1902                                dep->flags |= DWC3_EP_MISSED_ISOC;
1903                        } else {
1904                                dev_err(dwc->dev, "incomplete IN transfer %s\n",
1905                                                dep->name);
1906                                status = -ECONNRESET;
1907                        }
1908                } else {
1909                        dep->flags &= ~DWC3_EP_MISSED_ISOC;
1910                }
1911        } else {
1912                if (count && (event->status & DEPEVT_STATUS_SHORT))
1913                        s_pkt = 1;
1914        }
1915
1916        if (s_pkt)
1917                return 1;
1918        if ((event->status & DEPEVT_STATUS_LST) &&
1919                        (trb->ctrl & (DWC3_TRB_CTRL_LST |
1920                                DWC3_TRB_CTRL_HWO)))
1921                return 1;
1922        if ((event->status & DEPEVT_STATUS_IOC) &&
1923                        (trb->ctrl & DWC3_TRB_CTRL_IOC))
1924                return 1;
1925        return 0;
1926}
1927
1928static int dwc3_cleanup_done_reqs(struct dwc3 *dwc, struct dwc3_ep *dep,
1929                const struct dwc3_event_depevt *event, int status)
1930{
1931        struct dwc3_request     *req;
1932        struct dwc3_trb         *trb;
1933        unsigned int            slot;
1934        unsigned int            i;
1935        int                     count = 0;
1936        int                     ret;
1937
1938        do {
1939                req = next_request(&dep->req_queued);
1940                if (!req) {
1941                        WARN_ON_ONCE(1);
1942                        return 1;
1943                }
1944                i = 0;
1945                do {
1946                        slot = req->start_slot + i;
1947                        if ((slot == DWC3_TRB_NUM - 1) &&
1948                                usb_endpoint_xfer_isoc(dep->endpoint.desc))
1949                                slot++;
1950                        slot %= DWC3_TRB_NUM;
1951                        trb = &dep->trb_pool[slot];
1952                        count += trb->size & DWC3_TRB_SIZE_MASK;
1953
1954
1955                        ret = __dwc3_cleanup_done_trbs(dwc, dep, req, trb,
1956                                        event, status);
1957                        if (ret)
1958                                break;
1959                } while (++i < req->request.num_mapped_sgs);
1960
1961                /*
1962                 * We assume here we will always receive the entire data block
1963                 * which we should receive. Meaning, if we program RX to
1964                 * receive 4K but we receive only 2K, we assume that's all we
1965                 * should receive and we simply bounce the request back to the
1966                 * gadget driver for further processing.
1967                 */
1968                req->request.actual += req->request.length - count;
1969                dwc3_gadget_giveback(dep, req, status);
1970
1971                if (ret)
1972                        break;
1973        } while (1);
1974
1975        if (usb_endpoint_xfer_isoc(dep->endpoint.desc) &&
1976                        list_empty(&dep->req_queued)) {
1977                if (list_empty(&dep->request_list)) {
1978                        /*
1979                         * If there is no entry in request list then do
1980                         * not issue END TRANSFER now. Just set PENDING
1981                         * flag, so that END TRANSFER is issued when an
1982                         * entry is added into request list.
1983                         */
1984                        dep->flags = DWC3_EP_PENDING_REQUEST;
1985                } else {
1986                        dwc3_stop_active_transfer(dwc, dep->number, true);
1987                        dep->flags = DWC3_EP_ENABLED;
1988                }
1989                return 1;
1990        }
1991
1992        if (usb_endpoint_xfer_isoc(dep->endpoint.desc))
1993                if ((event->status & DEPEVT_STATUS_IOC) &&
1994                                (trb->ctrl & DWC3_TRB_CTRL_IOC))
1995                        return 0;
1996        return 1;
1997}
1998
1999static void dwc3_endpoint_transfer_complete(struct dwc3 *dwc,
2000                struct dwc3_ep *dep, const struct dwc3_event_depevt *event)
2001{
2002        unsigned                status = 0;
2003        int                     clean_busy;
2004        u32                     is_xfer_complete;
2005
2006        is_xfer_complete = (event->endpoint_event == DWC3_DEPEVT_XFERCOMPLETE);
2007
2008        if (event->status & DEPEVT_STATUS_BUSERR)
2009                status = -ECONNRESET;
2010
2011        clean_busy = dwc3_cleanup_done_reqs(dwc, dep, event, status);
2012        if (clean_busy && (is_xfer_complete ||
2013                                usb_endpoint_xfer_isoc(dep->endpoint.desc)))
2014                dep->flags &= ~DWC3_EP_BUSY;
2015
2016        /*
2017         * WORKAROUND: This is the 2nd half of U1/U2 -> U0 workaround.
2018         * See dwc3_gadget_linksts_change_interrupt() for 1st half.
2019         */
2020        if (dwc->revision < DWC3_REVISION_183A) {
2021                u32             reg;
2022                int             i;
2023
2024                for (i = 0; i < DWC3_ENDPOINTS_NUM; i++) {
2025                        dep = dwc->eps[i];
2026
2027                        if (!(dep->flags & DWC3_EP_ENABLED))
2028                                continue;
2029
2030                        if (!list_empty(&dep->req_queued))
2031                                return;
2032                }
2033
2034                reg = dwc3_readl(dwc->regs, DWC3_DCTL);
2035                reg |= dwc->u1u2;
2036                dwc3_writel(dwc->regs, DWC3_DCTL, reg);
2037
2038                dwc->u1u2 = 0;
2039        }
2040
2041        if (!usb_endpoint_xfer_isoc(dep->endpoint.desc)) {
2042                int ret;
2043
2044                ret = __dwc3_gadget_kick_transfer(dep, 0, is_xfer_complete);
2045                if (!ret || ret == -EBUSY)
2046                        return;
2047        }
2048}
2049
2050static void dwc3_endpoint_interrupt(struct dwc3 *dwc,
2051                const struct dwc3_event_depevt *event)
2052{
2053        struct dwc3_ep          *dep;
2054        u8                      epnum = event->endpoint_number;
2055        int ret;
2056
2057        dep = dwc->eps[epnum];
2058
2059        if (!(dep->flags & DWC3_EP_ENABLED))
2060                return;
2061
2062        if (epnum == 0 || epnum == 1) {
2063                dwc3_ep0_interrupt(dwc, event);
2064                return;
2065        }
2066
2067        switch (event->endpoint_event) {
2068        case DWC3_DEPEVT_XFERCOMPLETE:
2069                dep->resource_index = 0;
2070
2071                if (usb_endpoint_xfer_isoc(dep->endpoint.desc)) {
2072                        dev_dbg(dwc->dev, "%s is an Isochronous endpoint\n",
2073                                        dep->name);
2074                        return;
2075                }
2076
2077                dwc3_endpoint_transfer_complete(dwc, dep, event);
2078                break;
2079        case DWC3_DEPEVT_XFERINPROGRESS:
2080                dwc3_endpoint_transfer_complete(dwc, dep, event);
2081                break;
2082        case DWC3_DEPEVT_XFERNOTREADY:
2083                if (usb_endpoint_xfer_isoc(dep->endpoint.desc)) {
2084                        dwc3_gadget_start_isoc(dwc, dep, event);
2085                } else {
2086                        int active;
2087                        int ret;
2088
2089                        active = event->status & DEPEVT_STATUS_TRANSFER_ACTIVE;
2090
2091                        dwc3_trace(trace_dwc3_gadget, "%s: reason %s",
2092                                        dep->name, active ? "Transfer Active"
2093                                        : "Transfer Not Active");
2094
2095                        ret = __dwc3_gadget_kick_transfer(dep, 0, !active);
2096                        if (!ret || ret == -EBUSY)
2097                                return;
2098
2099                        dev_dbg(dwc->dev, "%s: failed to kick transfers\n",
2100                                        dep->name);
2101                }
2102
2103                break;
2104        case DWC3_DEPEVT_STREAMEVT:
2105                if (!usb_endpoint_xfer_bulk(dep->endpoint.desc)) {
2106                        dev_err(dwc->dev, "Stream event for non-Bulk %s\n",
2107                                        dep->name);
2108                        return;
2109                }
2110
2111                switch (event->status) {
2112                case DEPEVT_STREAMEVT_FOUND:
2113                        dwc3_trace(trace_dwc3_gadget,
2114                                        "Stream %d found and started",
2115                                        event->parameters);
2116
2117                        break;
2118                case DEPEVT_STREAMEVT_NOTFOUND:
2119                        /* FALLTHROUGH */
2120                default:
2121                        dev_dbg(dwc->dev, "Couldn't find suitable stream\n");
2122                }
2123                break;
2124        case DWC3_DEPEVT_RXTXFIFOEVT:
2125                dev_dbg(dwc->dev, "%s FIFO Overrun\n", dep->name);
2126                break;
2127        case DWC3_DEPEVT_EPCMDCMPLT:
2128                dwc3_trace(trace_dwc3_gadget, "Endpoint Command Complete");
2129                break;
2130        }
2131}
2132
2133static void dwc3_disconnect_gadget(struct dwc3 *dwc)
2134{
2135        if (dwc->gadget_driver && dwc->gadget_driver->disconnect) {
2136                spin_unlock(&dwc->lock);
2137                dwc->gadget_driver->disconnect(&dwc->gadget);
2138                spin_lock(&dwc->lock);
2139        }
2140}
2141
2142static void dwc3_suspend_gadget(struct dwc3 *dwc)
2143{
2144        if (dwc->gadget_driver && dwc->gadget_driver->suspend) {
2145                spin_unlock(&dwc->lock);
2146                dwc->gadget_driver->suspend(&dwc->gadget);
2147                spin_lock(&dwc->lock);
2148        }
2149}
2150
2151static void dwc3_resume_gadget(struct dwc3 *dwc)
2152{
2153        if (dwc->gadget_driver && dwc->gadget_driver->resume) {
2154                spin_unlock(&dwc->lock);
2155                dwc->gadget_driver->resume(&dwc->gadget);
2156                spin_lock(&dwc->lock);
2157        }
2158}
2159
2160static void dwc3_reset_gadget(struct dwc3 *dwc)
2161{
2162        if (!dwc->gadget_driver)
2163                return;
2164
2165        if (dwc->gadget.speed != USB_SPEED_UNKNOWN) {
2166                spin_unlock(&dwc->lock);
2167                usb_gadget_udc_reset(&dwc->gadget, dwc->gadget_driver);
2168                spin_lock(&dwc->lock);
2169        }
2170}
2171
2172static void dwc3_stop_active_transfer(struct dwc3 *dwc, u32 epnum, bool force)
2173{
2174        struct dwc3_ep *dep;
2175        struct dwc3_gadget_ep_cmd_params params;
2176        u32 cmd;
2177        int ret;
2178
2179        dep = dwc->eps[epnum];
2180
2181        if (!dep->resource_index)
2182                return;
2183
2184        /*
2185         * NOTICE: We are violating what the Databook says about the
2186         * EndTransfer command. Ideally we would _always_ wait for the
2187         * EndTransfer Command Completion IRQ, but that's causing too
2188         * much trouble synchronizing between us and gadget driver.
2189         *
2190         * We have discussed this with the IP Provider and it was
2191         * suggested to giveback all requests here, but give HW some
2192         * extra time to synchronize with the interconnect. We're using
2193         * an arbitrary 100us delay for that.
2194         *
2195         * Note also that a similar handling was tested by Synopsys
2196         * (thanks a lot Paul) and nothing bad has come out of it.
2197         * In short, what we're doing is:
2198         *
2199         * - Issue EndTransfer WITH CMDIOC bit set
2200         * - Wait 100us
2201         */
2202
2203        cmd = DWC3_DEPCMD_ENDTRANSFER;
2204        cmd |= force ? DWC3_DEPCMD_HIPRI_FORCERM : 0;
2205        cmd |= DWC3_DEPCMD_CMDIOC;
2206        cmd |= DWC3_DEPCMD_PARAM(dep->resource_index);
2207        memset(&params, 0, sizeof(params));
2208        ret = dwc3_send_gadget_ep_cmd(dwc, dep->number, cmd, &params);
2209        WARN_ON_ONCE(ret);
2210        dep->resource_index = 0;
2211        dep->flags &= ~DWC3_EP_BUSY;
2212        udelay(100);
2213}
2214
2215static void dwc3_stop_active_transfers(struct dwc3 *dwc)
2216{
2217        u32 epnum;
2218
2219        for (epnum = 2; epnum < DWC3_ENDPOINTS_NUM; epnum++) {
2220                struct dwc3_ep *dep;
2221
2222                dep = dwc->eps[epnum];
2223                if (!dep)
2224                        continue;
2225
2226                if (!(dep->flags & DWC3_EP_ENABLED))
2227                        continue;
2228
2229                dwc3_remove_requests(dwc, dep);
2230        }
2231}
2232
2233static void dwc3_clear_stall_all_ep(struct dwc3 *dwc)
2234{
2235        u32 epnum;
2236
2237        for (epnum = 1; epnum < DWC3_ENDPOINTS_NUM; epnum++) {
2238                struct dwc3_ep *dep;
2239                struct dwc3_gadget_ep_cmd_params params;
2240                int ret;
2241
2242                dep = dwc->eps[epnum];
2243                if (!dep)
2244                        continue;
2245
2246                if (!(dep->flags & DWC3_EP_STALL))
2247                        continue;
2248
2249                dep->flags &= ~DWC3_EP_STALL;
2250
2251                memset(&params, 0, sizeof(params));
2252                ret = dwc3_send_gadget_ep_cmd(dwc, dep->number,
2253                                DWC3_DEPCMD_CLEARSTALL, &params);
2254                WARN_ON_ONCE(ret);
2255        }
2256}
2257
2258static void dwc3_gadget_disconnect_interrupt(struct dwc3 *dwc)
2259{
2260        int                     reg;
2261
2262        reg = dwc3_readl(dwc->regs, DWC3_DCTL);
2263        reg &= ~DWC3_DCTL_INITU1ENA;
2264        dwc3_writel(dwc->regs, DWC3_DCTL, reg);
2265
2266        reg &= ~DWC3_DCTL_INITU2ENA;
2267        dwc3_writel(dwc->regs, DWC3_DCTL, reg);
2268
2269        dwc3_disconnect_gadget(dwc);
2270
2271        dwc->gadget.speed = USB_SPEED_UNKNOWN;
2272        dwc->setup_packet_pending = false;
2273        usb_gadget_set_state(&dwc->gadget, USB_STATE_NOTATTACHED);
2274}
2275
2276static void dwc3_gadget_reset_interrupt(struct dwc3 *dwc)
2277{
2278        u32                     reg;
2279
2280        /*
2281         * WORKAROUND: DWC3 revisions <1.88a have an issue which
2282         * would cause a missing Disconnect Event if there's a
2283         * pending Setup Packet in the FIFO.
2284         *
2285         * There's no suggested workaround on the official Bug
2286         * report, which states that "unless the driver/application
2287         * is doing any special handling of a disconnect event,
2288         * there is no functional issue".
2289         *
2290         * Unfortunately, it turns out that we _do_ some special
2291         * handling of a disconnect event, namely complete all
2292         * pending transfers, notify gadget driver of the
2293         * disconnection, and so on.
2294         *
2295         * Our suggested workaround is to follow the Disconnect
2296         * Event steps here, instead, based on a setup_packet_pending
2297         * flag. Such flag gets set whenever we have a XferNotReady
2298         * event on EP0 and gets cleared on XferComplete for the
2299         * same endpoint.
2300         *
2301         * Refers to:
2302         *
2303         * STAR#9000466709: RTL: Device : Disconnect event not
2304         * generated if setup packet pending in FIFO
2305         */
2306        if (dwc->revision < DWC3_REVISION_188A) {
2307                if (dwc->setup_packet_pending)
2308                        dwc3_gadget_disconnect_interrupt(dwc);
2309        }
2310
2311        dwc3_reset_gadget(dwc);
2312
2313        reg = dwc3_readl(dwc->regs, DWC3_DCTL);
2314        reg &= ~DWC3_DCTL_TSTCTRL_MASK;
2315        dwc3_writel(dwc->regs, DWC3_DCTL, reg);
2316        dwc->test_mode = false;
2317
2318        dwc3_stop_active_transfers(dwc);
2319        dwc3_clear_stall_all_ep(dwc);
2320
2321        /* Reset device address to zero */
2322        reg = dwc3_readl(dwc->regs, DWC3_DCFG);
2323        reg &= ~(DWC3_DCFG_DEVADDR_MASK);
2324        dwc3_writel(dwc->regs, DWC3_DCFG, reg);
2325}
2326
2327static void dwc3_update_ram_clk_sel(struct dwc3 *dwc, u32 speed)
2328{
2329        u32 reg;
2330        u32 usb30_clock = DWC3_GCTL_CLK_BUS;
2331
2332        /*
2333         * We change the clock only at SS but I dunno why I would want to do
2334         * this. Maybe it becomes part of the power saving plan.
2335         */
2336
2337        if (speed != DWC3_DSTS_SUPERSPEED)
2338                return;
2339
2340        /*
2341         * RAMClkSel is reset to 0 after USB reset, so it must be reprogrammed
2342         * each time on Connect Done.
2343         */
2344        if (!usb30_clock)
2345                return;
2346
2347        reg = dwc3_readl(dwc->regs, DWC3_GCTL);
2348        reg |= DWC3_GCTL_RAMCLKSEL(usb30_clock);
2349        dwc3_writel(dwc->regs, DWC3_GCTL, reg);
2350}
2351
2352static void dwc3_gadget_conndone_interrupt(struct dwc3 *dwc)
2353{
2354        struct dwc3_ep          *dep;
2355        int                     ret;
2356        u32                     reg;
2357        u8                      speed;
2358
2359        reg = dwc3_readl(dwc->regs, DWC3_DSTS);
2360        speed = reg & DWC3_DSTS_CONNECTSPD;
2361        dwc->speed = speed;
2362
2363        dwc3_update_ram_clk_sel(dwc, speed);
2364
2365        switch (speed) {
2366        case DWC3_DCFG_SUPERSPEED:
2367                /*
2368                 * WORKAROUND: DWC3 revisions <1.90a have an issue which
2369                 * would cause a missing USB3 Reset event.
2370                 *
2371                 * In such situations, we should force a USB3 Reset
2372                 * event by calling our dwc3_gadget_reset_interrupt()
2373                 * routine.
2374                 *
2375                 * Refers to:
2376                 *
2377                 * STAR#9000483510: RTL: SS : USB3 reset event may
2378                 * not be generated always when the link enters poll
2379                 */
2380                if (dwc->revision < DWC3_REVISION_190A)
2381                        dwc3_gadget_reset_interrupt(dwc);
2382
2383                dwc3_gadget_ep0_desc.wMaxPacketSize = cpu_to_le16(512);
2384                dwc->gadget.ep0->maxpacket = 512;
2385                dwc->gadget.speed = USB_SPEED_SUPER;
2386                break;
2387        case DWC3_DCFG_HIGHSPEED:
2388                dwc3_gadget_ep0_desc.wMaxPacketSize = cpu_to_le16(64);
2389                dwc->gadget.ep0->maxpacket = 64;
2390                dwc->gadget.speed = USB_SPEED_HIGH;
2391                break;
2392        case DWC3_DCFG_FULLSPEED2:
2393        case DWC3_DCFG_FULLSPEED1:
2394                dwc3_gadget_ep0_desc.wMaxPacketSize = cpu_to_le16(64);
2395                dwc->gadget.ep0->maxpacket = 64;
2396                dwc->gadget.speed = USB_SPEED_FULL;
2397                break;
2398        case DWC3_DCFG_LOWSPEED:
2399                dwc3_gadget_ep0_desc.wMaxPacketSize = cpu_to_le16(8);
2400                dwc->gadget.ep0->maxpacket = 8;
2401                dwc->gadget.speed = USB_SPEED_LOW;
2402                break;
2403        }
2404
2405        /* Enable USB2 LPM Capability */
2406
2407        if ((dwc->revision > DWC3_REVISION_194A)
2408                        && (speed != DWC3_DCFG_SUPERSPEED)) {
2409                reg = dwc3_readl(dwc->regs, DWC3_DCFG);
2410                reg |= DWC3_DCFG_LPM_CAP;
2411                dwc3_writel(dwc->regs, DWC3_DCFG, reg);
2412
2413                reg = dwc3_readl(dwc->regs, DWC3_DCTL);
2414                reg &= ~(DWC3_DCTL_HIRD_THRES_MASK | DWC3_DCTL_L1_HIBER_EN);
2415
2416                reg |= DWC3_DCTL_HIRD_THRES(dwc->hird_threshold);
2417
2418                /*
2419                 * When dwc3 revisions >= 2.40a, LPM Erratum is enabled and
2420                 * DCFG.LPMCap is set, core responses with an ACK and the
2421                 * BESL value in the LPM token is less than or equal to LPM
2422                 * NYET threshold.
2423                 */
2424                WARN_ONCE(dwc->revision < DWC3_REVISION_240A
2425                                && dwc->has_lpm_erratum,
2426                                "LPM Erratum not available on dwc3 revisisions < 2.40a\n");
2427
2428                if (dwc->has_lpm_erratum && dwc->revision >= DWC3_REVISION_240A)
2429                        reg |= DWC3_DCTL_LPM_ERRATA(dwc->lpm_nyet_threshold);
2430
2431                dwc3_writel(dwc->regs, DWC3_DCTL, reg);
2432        } else {
2433                reg = dwc3_readl(dwc->regs, DWC3_DCTL);
2434                reg &= ~DWC3_DCTL_HIRD_THRES_MASK;
2435                dwc3_writel(dwc->regs, DWC3_DCTL, reg);
2436        }
2437
2438        dep = dwc->eps[0];
2439        ret = __dwc3_gadget_ep_enable(dep, &dwc3_gadget_ep0_desc, NULL, true,
2440                        false);
2441        if (ret) {
2442                dev_err(dwc->dev, "failed to enable %s\n", dep->name);
2443                return;
2444        }
2445
2446        dep = dwc->eps[1];
2447        ret = __dwc3_gadget_ep_enable(dep, &dwc3_gadget_ep0_desc, NULL, true,
2448                        false);
2449        if (ret) {
2450                dev_err(dwc->dev, "failed to enable %s\n", dep->name);
2451                return;
2452        }
2453
2454        /*
2455         * Configure PHY via GUSB3PIPECTLn if required.
2456         *
2457         * Update GTXFIFOSIZn
2458         *
2459         * In both cases reset values should be sufficient.
2460         */
2461}
2462
2463static void dwc3_gadget_wakeup_interrupt(struct dwc3 *dwc)
2464{
2465        /*
2466         * TODO take core out of low power mode when that's
2467         * implemented.
2468         */
2469
2470        dwc->gadget_driver->resume(&dwc->gadget);
2471}
2472
2473#ifdef CONFIG_USB_DWC3_AL_RMN_2648
2474#define DWC3_GDBGLTSSM_LINK_STATE_MASK          0x03C00000
2475#define DWC3_GDBGLTSSM_LINK_STATE_SHIFT         22
2476#define DWC3_GDBGLTSSM_LINK_SUB_STATE_MASK      0x003C0000
2477#define DWC3_GDBGLTSSM_LINK_SUB_STATE_SHIFT     18
2478#define DWC3_POLLING_LFPS                       2
2479#define DWC3_POLLING_TSEQ                       3
2480#define DWC3_GDBGLTSSM_RXEQTRAIN_SHIFT          8
2481
2482#define SERDES_RXEQEVAL_OVERRIDE_EN_ADDR        6
2483#define SERDES_RXEQEVAL_OVERRIDE_EN             (1 << 4)
2484#define SERDES_RXEQEVAL_OVERRIDE_ADDR           3
2485#define SERDES_RXEQEVAL_OVERRIDE_SET            (1 << 6)
2486#define SERDES_TXDETECTRX_OVERRIDE_EN_ADDR      7
2487#define SERDES_TXDETECTRX_OVERRIDE_EN           (1 << 5)
2488#define SERDES_TXDETECTRX_OVERRIDE_ADDR         4
2489
2490#define AL_SRDS_REG_TYPE_PCS                    1
2491#define SRDS_CORE_REG_ADDR(page, type, offset)\
2492        (((page) << 13) | ((type) << 12) | (offset))
2493
2494static inline void al_serdes_reg_write(
2495        struct al_serdes_regs           *regs_base,
2496        u32                             page,
2497        int                             type,
2498        u16                             offset,
2499        u8                              data)
2500{
2501        writel(SRDS_CORE_REG_ADDR(page, type, offset),
2502                        &regs_base->gen.reg_addr);
2503
2504        writel(data, &regs_base->gen.reg_data);
2505}
2506
2507static inline void dwc3_al_rmn_2648(struct dwc3 *dwc)
2508{
2509        struct al_serdes_regs *serdes_regs = dwc->serdes_regs_base;
2510        uint32_t gdbgltssm = dwc3_readl(dwc->regs, DWC3_GDBGLTSSM);
2511        uint32_t link_sub_state, rxeqtrain;
2512        bool rxeqeval_override = false;
2513        bool rxeqeval_set = false;
2514        bool txdetectrx_override = false;
2515
2516        do {
2517                link_sub_state = AL_REG_FIELD_GET(gdbgltssm,
2518                                DWC3_GDBGLTSSM_LINK_SUB_STATE_MASK,
2519                                DWC3_GDBGLTSSM_LINK_SUB_STATE_SHIFT);
2520                rxeqtrain = AL_REG_BIT_GET(gdbgltssm,
2521                                DWC3_GDBGLTSSM_RXEQTRAIN_SHIFT);
2522
2523                switch (link_sub_state) {
2524                case DWC3_POLLING_LFPS:
2525                        if (!rxeqeval_override) {
2526                                dev_dbg(dwc->dev, "%s: rxeqeval override\n",
2527                                                __func__);
2528                                al_serdes_reg_write(
2529                                        serdes_regs,
2530                                        dwc->serdes_lane,
2531                                        AL_SRDS_REG_TYPE_PCS,
2532                                        SERDES_RXEQEVAL_OVERRIDE_ADDR,
2533                                        0);
2534                                al_serdes_reg_write(
2535                                        serdes_regs,
2536                                        dwc->serdes_lane,
2537                                        AL_SRDS_REG_TYPE_PCS,
2538                                        SERDES_RXEQEVAL_OVERRIDE_EN_ADDR,
2539                                        SERDES_RXEQEVAL_OVERRIDE_EN);
2540                                rxeqeval_override = true;
2541                        }
2542                        if (rxeqtrain && !rxeqeval_set) {
2543                                dev_dbg(dwc->dev, "%s: txdetectrx override\n",
2544                                                __func__);
2545                                al_serdes_reg_write(
2546                                        serdes_regs,
2547                                        dwc->serdes_lane,
2548                                        AL_SRDS_REG_TYPE_PCS,
2549                                        SERDES_TXDETECTRX_OVERRIDE_ADDR,
2550                                        0);
2551                                al_serdes_reg_write(
2552                                        serdes_regs,
2553                                        dwc->serdes_lane,
2554                                        AL_SRDS_REG_TYPE_PCS,
2555                                        SERDES_TXDETECTRX_OVERRIDE_EN_ADDR,
2556                                        SERDES_TXDETECTRX_OVERRIDE_EN);
2557                                txdetectrx_override = true;
2558
2559                                dev_dbg(dwc->dev, "%s: rxeqeval set\n",
2560                                                __func__);
2561                                al_serdes_reg_write(
2562                                        serdes_regs,
2563                                        dwc->serdes_lane,
2564                                        AL_SRDS_REG_TYPE_PCS,
2565                                        SERDES_RXEQEVAL_OVERRIDE_ADDR,
2566                                        SERDES_RXEQEVAL_OVERRIDE_SET);
2567                                rxeqeval_set = true;
2568                        }
2569                        break;
2570                case DWC3_POLLING_TSEQ:
2571                        if (rxeqtrain && !rxeqeval_set) {
2572                                dev_dbg(dwc->dev, "%s: rxeqeval set\n",
2573                                                __func__);
2574                                al_serdes_reg_write(
2575                                        serdes_regs,
2576                                        dwc->serdes_lane,
2577                                        AL_SRDS_REG_TYPE_PCS,
2578                                        SERDES_RXEQEVAL_OVERRIDE_ADDR,
2579                                        SERDES_RXEQEVAL_OVERRIDE_SET);
2580                                rxeqeval_set = true;
2581                        }
2582                        if (txdetectrx_override){
2583                                dev_dbg(dwc->dev,
2584                                        "%s: stop txdetectrx override\n",
2585                                                __func__);
2586                                al_serdes_reg_write(
2587                                        serdes_regs,
2588                                        dwc->serdes_lane,
2589                                        AL_SRDS_REG_TYPE_PCS,
2590                                        SERDES_TXDETECTRX_OVERRIDE_EN_ADDR,
2591                                        0);
2592                                txdetectrx_override = false;
2593                        }
2594                        if (!rxeqtrain && rxeqeval_set) {
2595                                dev_dbg(dwc->dev, "%s: rxeqeval clear\n",
2596                                                __func__);
2597                                al_serdes_reg_write(
2598                                        serdes_regs,
2599                                        dwc->serdes_lane,
2600                                        AL_SRDS_REG_TYPE_PCS,
2601                                        SERDES_RXEQEVAL_OVERRIDE_ADDR,
2602                                        0);
2603                                rxeqeval_set = false;
2604                        }
2605                        break;
2606                default:
2607                        if (rxeqeval_override) {
2608                                dev_dbg(dwc->dev,
2609                                        "%s: stop rxeqeval override\n",
2610                                                __func__);
2611                                al_serdes_reg_write(
2612                                        serdes_regs,
2613                                        dwc->serdes_lane,
2614                                        AL_SRDS_REG_TYPE_PCS,
2615                                        SERDES_RXEQEVAL_OVERRIDE_EN_ADDR,
2616                                        0);
2617                                rxeqeval_override = false;
2618                        }
2619                        if (rxeqeval_set) {
2620                                dev_dbg(dwc->dev, "%s: rxeqeval clear\n",
2621                                                __func__);
2622                                al_serdes_reg_write(
2623                                        serdes_regs,
2624                                        dwc->serdes_lane,
2625                                        AL_SRDS_REG_TYPE_PCS,
2626                                        SERDES_RXEQEVAL_OVERRIDE_ADDR,
2627                                        0);
2628                                rxeqeval_set = false;
2629                        }
2630                        if (txdetectrx_override){
2631                                dev_dbg(dwc->dev,
2632                                        "%s: stop txdetectrx override\n",
2633                                                __func__);
2634                                al_serdes_reg_write(
2635                                        serdes_regs,
2636                                        dwc->serdes_lane,
2637                                        AL_SRDS_REG_TYPE_PCS,
2638                                        SERDES_TXDETECTRX_OVERRIDE_EN_ADDR,
2639                                        0);
2640                                txdetectrx_override = false;
2641                        }
2642                        break;
2643                }
2644
2645                gdbgltssm = dwc3_readl(dwc->regs, DWC3_GDBGLTSSM);
2646        } while(AL_REG_FIELD_GET(gdbgltssm,
2647                        DWC3_GDBGLTSSM_LINK_STATE_MASK,
2648                        DWC3_GDBGLTSSM_LINK_STATE_SHIFT) ==
2649                                        DWC3_LINK_STATE_POLL);
2650}
2651#endif
2652
2653static void dwc3_gadget_linksts_change_interrupt(struct dwc3 *dwc,
2654                unsigned int evtinfo)
2655{
2656        enum dwc3_link_state    next = evtinfo & DWC3_LINK_STATE_MASK;
2657        unsigned int            pwropt;
2658
2659        /*
2660         * WORKAROUND: DWC3 < 2.50a have an issue when configured without
2661         * Hibernation mode enabled which would show up when device detects
2662         * host-initiated U3 exit.
2663         *
2664         * In that case, device will generate a Link State Change Interrupt
2665         * from U3 to RESUME which is only necessary if Hibernation is
2666         * configured in.
2667         *
2668         * There are no functional changes due to such spurious event and we
2669         * just need to ignore it.
2670         *
2671         * Refers to:
2672         *
2673         * STAR#9000570034 RTL: SS Resume event generated in non-Hibernation
2674         * operational mode
2675         */
2676        pwropt = DWC3_GHWPARAMS1_EN_PWROPT(dwc->hwparams.hwparams1);
2677        if ((dwc->revision < DWC3_REVISION_250A) &&
2678                        (pwropt != DWC3_GHWPARAMS1_EN_PWROPT_HIB)) {
2679                if ((dwc->link_state == DWC3_LINK_STATE_U3) &&
2680                                (next == DWC3_LINK_STATE_RESUME)) {
2681                        dwc3_trace(trace_dwc3_gadget,
2682                                        "ignoring transition U3 -> Resume");
2683                        return;
2684                }
2685        }
2686
2687        /*
2688         * WORKAROUND: DWC3 Revisions <1.83a have an issue which, depending
2689         * on the link partner, the USB session might do multiple entry/exit
2690         * of low power states before a transfer takes place.
2691         *
2692         * Due to this problem, we might experience lower throughput. The
2693         * suggested workaround is to disable DCTL[12:9] bits if we're
2694         * transitioning from U1/U2 to U0 and enable those bits again
2695         * after a transfer completes and there are no pending transfers
2696         * on any of the enabled endpoints.
2697         *
2698         * This is the first half of that workaround.
2699         *
2700         * Refers to:
2701         *
2702         * STAR#9000446952: RTL: Device SS : if U1/U2 ->U0 takes >128us
2703         * core send LGO_Ux entering U0
2704         */
2705        if (dwc->revision < DWC3_REVISION_183A) {
2706                if (next == DWC3_LINK_STATE_U0) {
2707                        u32     u1u2;
2708                        u32     reg;
2709
2710                        switch (dwc->link_state) {
2711                        case DWC3_LINK_STATE_U1:
2712                        case DWC3_LINK_STATE_U2:
2713                                reg = dwc3_readl(dwc->regs, DWC3_DCTL);
2714                                u1u2 = reg & (DWC3_DCTL_INITU2ENA
2715                                                | DWC3_DCTL_ACCEPTU2ENA
2716                                                | DWC3_DCTL_INITU1ENA
2717                                                | DWC3_DCTL_ACCEPTU1ENA);
2718
2719                                if (!dwc->u1u2)
2720                                        dwc->u1u2 = reg & u1u2;
2721
2722                                reg &= ~u1u2;
2723
2724                                dwc3_writel(dwc->regs, DWC3_DCTL, reg);
2725                                break;
2726                        default:
2727                                /* do nothing */
2728                                break;
2729                        }
2730                }
2731        }
2732
2733        switch (next) {
2734        case DWC3_LINK_STATE_U1:
2735                if (dwc->speed == USB_SPEED_SUPER)
2736                        dwc3_suspend_gadget(dwc);
2737                break;
2738        case DWC3_LINK_STATE_U2:
2739        case DWC3_LINK_STATE_U3:
2740                dwc3_suspend_gadget(dwc);
2741                break;
2742        case DWC3_LINK_STATE_RESUME:
2743                dwc3_resume_gadget(dwc);
2744                break;
2745        default:
2746                /* do nothing */
2747                break;
2748        }
2749
2750#ifdef CONFIG_USB_DWC3_AL_RMN_2648
2751        if (next == DWC3_LINK_STATE_POLL) {
2752                /*
2753                 * Addressing RMN: 2648
2754                 *
2755                 * RMN description:
2756                 * USB Serdes LFPS is sent instead of valid TSEQ seq.
2757                 * The issue is caused by the fact that OCTL_PMA_TXBEACON_A
2758                 * (in dualusb_4lane_32b_if_usb.v) is not updated in S_EQEVAL,
2759                 * S_EQEVAL_2 and S_EQEVAL_3 states.
2760                 * Thus, if S_EQEVAL is entered when OCTL_PMA_TXBEACON_A is
2761                 * asserted, it'll stay asserted during the whole equalization
2762                 * process.
2763                 * OCTL_PMA_TXBEACON_A asserted when both TxElecIdle and
2764                 * TxDetectRx PIPE signals are asserted.
2765                 * S_EQEVAL is entered when RxEqEval signal is asserted in the
2766                 * Serdes.
2767                 *
2768                 * Software flow:
2769                 * Take control of TxDetectRx and RxEqEval signals in the
2770                 * Serdes.
2771                 * When RxEqTrain bit is set in GDBGLTSSM register,
2772                 * make sure TxDetectRx is deasserted and only then assert
2773                 * RxEqEval.
2774                 */
2775                dwc3_al_rmn_2648(dwc);
2776        }
2777#endif
2778        dwc->link_state = next;
2779}
2780
2781static void dwc3_gadget_hibernation_interrupt(struct dwc3 *dwc,
2782                unsigned int evtinfo)
2783{
2784        unsigned int is_ss = evtinfo & BIT(4);
2785
2786        /**
2787         * WORKAROUND: DWC3 revison 2.20a with hibernation support
2788         * have a known issue which can cause USB CV TD.9.23 to fail
2789         * randomly.
2790         *
2791         * Because of this issue, core could generate bogus hibernation
2792         * events which SW needs to ignore.
2793         *
2794         * Refers to:
2795         *
2796         * STAR#9000546576: Device Mode Hibernation: Issue in USB 2.0
2797         * Device Fallback from SuperSpeed
2798         */
2799        if (is_ss ^ (dwc->speed == USB_SPEED_SUPER))
2800                return;
2801
2802        /* enter hibernation here */
2803}
2804
2805static void dwc3_gadget_interrupt(struct dwc3 *dwc,
2806                const struct dwc3_event_devt *event)
2807{
2808        switch (event->type) {
2809        case DWC3_DEVICE_EVENT_DISCONNECT:
2810                dwc3_gadget_disconnect_interrupt(dwc);
2811                break;
2812        case DWC3_DEVICE_EVENT_RESET:
2813                dwc3_gadget_reset_interrupt(dwc);
2814                break;
2815        case DWC3_DEVICE_EVENT_CONNECT_DONE:
2816                dwc3_gadget_conndone_interrupt(dwc);
2817                break;
2818        case DWC3_DEVICE_EVENT_WAKEUP:
2819                dwc3_gadget_wakeup_interrupt(dwc);
2820                break;
2821        case DWC3_DEVICE_EVENT_HIBER_REQ:
2822                if (dev_WARN_ONCE(dwc->dev, !dwc->has_hibernation,
2823                                        "unexpected hibernation event\n"))
2824                        break;
2825
2826                dwc3_gadget_hibernation_interrupt(dwc, event->event_info);
2827                break;
2828        case DWC3_DEVICE_EVENT_LINK_STATUS_CHANGE:
2829                dwc3_gadget_linksts_change_interrupt(dwc, event->event_info);
2830                break;
2831        case DWC3_DEVICE_EVENT_EOPF:
2832                dwc3_trace(trace_dwc3_gadget, "End of Periodic Frame");
2833                break;
2834        case DWC3_DEVICE_EVENT_SOF:
2835                dwc3_trace(trace_dwc3_gadget, "Start of Periodic Frame");
2836                break;
2837        case DWC3_DEVICE_EVENT_ERRATIC_ERROR:
2838                dwc3_trace(trace_dwc3_gadget, "Erratic Error");
2839                break;
2840        case DWC3_DEVICE_EVENT_CMD_CMPL:
2841                dwc3_trace(trace_dwc3_gadget, "Command Complete");
2842                break;
2843        case DWC3_DEVICE_EVENT_OVERFLOW:
2844                dwc3_trace(trace_dwc3_gadget, "Overflow");
2845                break;
2846        default:
2847                dev_WARN(dwc->dev, "UNKNOWN IRQ %d\n", event->type);
2848        }
2849}
2850
2851static void dwc3_process_event_entry(struct dwc3 *dwc,
2852                const union dwc3_event *event)
2853{
2854        trace_dwc3_event(event->raw);
2855
2856        /* Endpoint IRQ, handle it and return early */
2857        if (event->type.is_devspec == 0) {
2858                /* depevt */
2859                return dwc3_endpoint_interrupt(dwc, &event->depevt);
2860        }
2861
2862        switch (event->type.type) {
2863        case DWC3_EVENT_TYPE_DEV:
2864                dwc3_gadget_interrupt(dwc, &event->devt);
2865                break;
2866        /* REVISIT what to do with Carkit and I2C events ? */
2867        default:
2868                dev_err(dwc->dev, "UNKNOWN IRQ type %d\n", event->raw);
2869        }
2870}
2871
2872static irqreturn_t dwc3_process_event_buf(struct dwc3 *dwc, u32 buf)
2873{
2874        struct dwc3_event_buffer *evt;
2875        irqreturn_t ret = IRQ_NONE;
2876        int left;
2877        u32 reg;
2878
2879        evt = dwc->ev_buffs[buf];
2880        left = evt->count;
2881
2882        if (!(evt->flags & DWC3_EVENT_PENDING))
2883                return IRQ_NONE;
2884
2885        while (left > 0) {
2886                union dwc3_event event;
2887
2888                event.raw = *(u32 *) (evt->buf + evt->lpos);
2889
2890                dwc3_process_event_entry(dwc, &event);
2891
2892                /*
2893                 * FIXME we wrap around correctly to the next entry as
2894                 * almost all entries are 4 bytes in size. There is one
2895                 * entry which has 12 bytes which is a regular entry
2896                 * followed by 8 bytes data. ATM I don't know how
2897                 * things are organized if we get next to the a
2898                 * boundary so I worry about that once we try to handle
2899                 * that.
2900                 */
2901                evt->lpos = (evt->lpos + 4) % DWC3_EVENT_BUFFERS_SIZE;
2902                left -= 4;
2903
2904                dwc3_writel(dwc->regs, DWC3_GEVNTCOUNT(buf), 4);
2905        }
2906
2907        evt->count = 0;
2908        evt->flags &= ~DWC3_EVENT_PENDING;
2909        ret = IRQ_HANDLED;
2910
2911        /* Unmask interrupt */
2912        reg = dwc3_readl(dwc->regs, DWC3_GEVNTSIZ(buf));
2913        reg &= ~DWC3_GEVNTSIZ_INTMASK;
2914        dwc3_writel(dwc->regs, DWC3_GEVNTSIZ(buf), reg);
2915
2916        return ret;
2917}
2918
2919static irqreturn_t dwc3_thread_interrupt(int irq, void *_dwc)
2920{
2921        struct dwc3 *dwc = _dwc;
2922        unsigned long flags;
2923        irqreturn_t ret = IRQ_NONE;
2924        int i;
2925
2926        spin_lock_irqsave(&dwc->lock, flags);
2927
2928        for (i = 0; i < dwc->num_event_buffers; i++)
2929                ret |= dwc3_process_event_buf(dwc, i);
2930
2931        spin_unlock_irqrestore(&dwc->lock, flags);
2932
2933        return ret;
2934}
2935
2936static irqreturn_t dwc3_check_event_buf(struct dwc3 *dwc, u32 buf)
2937{
2938        struct dwc3_event_buffer *evt;
2939        u32 count;
2940        u32 reg;
2941
2942        evt = dwc->ev_buffs[buf];
2943
2944        count = dwc3_readl(dwc->regs, DWC3_GEVNTCOUNT(buf));
2945        count &= DWC3_GEVNTCOUNT_MASK;
2946        if (!count)
2947                return IRQ_NONE;
2948
2949        evt->count = count;
2950        evt->flags |= DWC3_EVENT_PENDING;
2951
2952        /* Mask interrupt */
2953        reg = dwc3_readl(dwc->regs, DWC3_GEVNTSIZ(buf));
2954        reg |= DWC3_GEVNTSIZ_INTMASK;
2955        dwc3_writel(dwc->regs, DWC3_GEVNTSIZ(buf), reg);
2956
2957        return IRQ_WAKE_THREAD;
2958}
2959
2960static irqreturn_t dwc3_interrupt(int irq, void *_dwc)
2961{
2962        struct dwc3                     *dwc = _dwc;
2963        int                             i;
2964        irqreturn_t                     ret = IRQ_NONE;
2965
2966        for (i = 0; i < dwc->num_event_buffers; i++) {
2967                irqreturn_t status;
2968
2969                status = dwc3_check_event_buf(dwc, i);
2970                if (status == IRQ_WAKE_THREAD)
2971                        ret = status;
2972        }
2973
2974        return ret;
2975}
2976
2977#ifdef CONFIG_USB_DWC3_AL_VBUS_GPIO
2978static void dwc3_vbus_work(struct work_struct *work)
2979{
2980        struct dwc3 *dwc = container_of(work, struct dwc3, vbus_work.work);
2981        unsigned long flags;
2982        int vbus;
2983
2984        spin_lock_irqsave(&dwc->lock, flags);
2985
2986        vbus = gpio_get_value(dwc->vbus_gpio);
2987        if (vbus == dwc->vbus_active) {
2988                spin_unlock_irqrestore(&dwc->lock, flags);
2989                return;
2990        }
2991
2992        dwc->vbus_active = vbus;
2993
2994        if (vbus) {
2995                dev_dbg(dwc->dev, "%s: vbus_connect\n", __func__);
2996                if (dwc->gadget_driver)
2997                        dwc3_gadget_run_stop(dwc, 1);
2998        } else {
2999                dev_dbg(dwc->dev, "%s: vbus_disconnect\n", __func__);
3000                if (dwc->gadget_driver)
3001                        dwc3_gadget_run_stop(dwc, 0);
3002        }
3003
3004        spin_unlock_irqrestore(&dwc->lock, flags);
3005}
3006
3007static irqreturn_t dwc3_vbus_irq(int irq, void *data)
3008{
3009        struct dwc3 *dwc = data;
3010
3011        schedule_delayed_work(&dwc->vbus_work, msecs_to_jiffies(100));
3012
3013        return IRQ_HANDLED;
3014}
3015#endif
3016
3017/**
3018 * dwc3_gadget_init - Initializes gadget related registers
3019 * @dwc: pointer to our controller context structure
3020 *
3021 * Returns 0 on success otherwise negative errno.
3022 */
3023int dwc3_gadget_init(struct dwc3 *dwc)
3024{
3025        int                                     ret;
3026#if defined(CONFIG_USB_DWC3_AL_RMN_2648) || \
3027                defined(CONFIG_USB_DWC3_AL_VBUS_GPIO)
3028        struct device_node                      *np;
3029#endif
3030
3031        dwc->ctrl_req = dma_alloc_coherent(dwc->dev, sizeof(*dwc->ctrl_req),
3032                        &dwc->ctrl_req_addr, GFP_KERNEL);
3033        if (!dwc->ctrl_req) {
3034                dev_err(dwc->dev, "failed to allocate ctrl request\n");
3035                ret = -ENOMEM;
3036                goto err0;
3037        }
3038
3039        dwc->ep0_trb = dma_alloc_coherent(dwc->dev, sizeof(*dwc->ep0_trb) * 2,
3040                        &dwc->ep0_trb_addr, GFP_KERNEL);
3041        if (!dwc->ep0_trb) {
3042                dev_err(dwc->dev, "failed to allocate ep0 trb\n");
3043                ret = -ENOMEM;
3044                goto err1;
3045        }
3046
3047        dwc->setup_buf = kzalloc(DWC3_EP0_BOUNCE_SIZE, GFP_KERNEL);
3048        if (!dwc->setup_buf) {
3049                ret = -ENOMEM;
3050                goto err2;
3051        }
3052
3053        dwc->ep0_bounce = dma_alloc_coherent(dwc->dev,
3054                        DWC3_EP0_BOUNCE_SIZE, &dwc->ep0_bounce_addr,
3055                        GFP_KERNEL);
3056        if (!dwc->ep0_bounce) {
3057                dev_err(dwc->dev, "failed to allocate ep0 bounce buffer\n");
3058                ret = -ENOMEM;
3059                goto err3;
3060        }
3061
3062        dwc->gadget.ops                 = &dwc3_gadget_ops;
3063        dwc->gadget.speed               = USB_SPEED_UNKNOWN;
3064        dwc->gadget.sg_supported        = true;
3065        dwc->gadget.name                = "dwc3-gadget";
3066
3067        /*
3068         * FIXME We might be setting max_speed to <SUPER, however versions
3069         * <2.20a of dwc3 have an issue with metastability (documented
3070         * elsewhere in this driver) which tells us we can't set max speed to
3071         * anything lower than SUPER.
3072         *
3073         * Because gadget.max_speed is only used by composite.c and function
3074         * drivers (i.e. it won't go into dwc3's registers) we are allowing this
3075         * to happen so we avoid sending SuperSpeed Capability descriptor
3076         * together with our BOS descriptor as that could confuse host into
3077         * thinking we can handle super speed.
3078         *
3079         * Note that, in fact, we won't even support GetBOS requests when speed
3080         * is less than super speed because we don't have means, yet, to tell
3081         * composite.c that we are USB 2.0 + LPM ECN.
3082         */
3083        if (dwc->revision < DWC3_REVISION_220A)
3084                dwc3_trace(trace_dwc3_gadget,
3085                                "Changing max_speed on rev %08x\n",
3086                                dwc->revision);
3087
3088        dwc->gadget.max_speed           = dwc->maximum_speed;
3089
3090        /*
3091         * Per databook, DWC3 needs buffer size to be aligned to MaxPacketSize
3092         * on ep out.
3093         */
3094        dwc->gadget.quirk_ep_out_aligned_size = true;
3095
3096        /*
3097         * REVISIT: Here we should clear all pending IRQs to be
3098         * sure we're starting from a well known location.
3099         */
3100
3101        ret = dwc3_gadget_init_endpoints(dwc);
3102        if (ret)
3103                goto err4;
3104
3105#ifdef CONFIG_USB_DWC3_AL_RMN_2648
3106        np = of_find_compatible_node(NULL, NULL, "annapurna-labs,al-usb");
3107        if (!np) {
3108                dev_err(dwc->dev, "failed to get usb data from device tree --> %d\n",
3109                                ret);
3110                goto err5;
3111        }
3112
3113        if (of_property_read_u32(np, "serdes-group", &dwc->serdes_group)) {
3114                dev_err(dwc->dev, "failed to get serdes group --> %d\n", ret);
3115                goto err5;
3116        }
3117
3118        if (of_property_read_u32(np, "serdes-lane",  &dwc->serdes_lane)) {
3119                dev_err(dwc->dev, "failed to get serdes lane --> %d\n", ret);
3120                goto err5;
3121        }
3122
3123        dwc->serdes_regs_base = alpine_serdes_resource_get(dwc->serdes_group);
3124        if (!dwc->serdes_regs_base) {
3125                dev_err(dwc->dev, "failed to get serdes regs base --> %d\n",
3126                                ret);
3127                goto err5;
3128        }
3129#endif
3130
3131#ifdef CONFIG_USB_DWC3_AL_VBUS_GPIO
3132        INIT_DELAYED_WORK(&dwc->vbus_work, dwc3_vbus_work);
3133
3134        np = of_find_compatible_node(NULL, NULL, "annapurna-labs,al-usb");
3135        dwc->vbus_gpio = of_get_named_gpio(np, "vbus-gpio", 0);
3136
3137        if (gpio_is_valid(dwc->vbus_gpio)) {
3138                int vbus_gpio_irq = gpio_to_irq(dwc->vbus_gpio);
3139                dwc->vbus_active = 0;
3140
3141                ret = gpio_request_one(dwc->vbus_gpio, GPIOF_DIR_IN,
3142                                "dwc3-vbus");
3143                if (ret) {
3144                        dev_err(dwc->dev, "failed to request vbus gpio #%d --> %d\n",
3145                                        dwc->vbus_gpio, ret);
3146                        goto err5;
3147                }
3148
3149                irq_set_irq_type(vbus_gpio_irq, IRQ_TYPE_EDGE_BOTH);
3150                if (ret) {
3151                        dev_err(dwc->dev, "failed to set type for vbus gpio irq #%d --> %d\n",
3152                                        vbus_gpio_irq, ret);
3153                        goto err7;
3154                }
3155
3156                ret = request_irq(vbus_gpio_irq, dwc3_vbus_irq, 0, "dwc3-vbus",
3157                                dwc);
3158                if (ret) {
3159                        dev_err(dwc->dev, "failed to request vbus gpio irq #%d --> %d\n",
3160                                        vbus_gpio_irq, ret);
3161                        goto err6;
3162                }
3163        }
3164#endif
3165
3166        ret = usb_add_gadget_udc(dwc->dev, &dwc->gadget);
3167        if (ret) {
3168                dev_err(dwc->dev, "failed to register udc\n");
3169                goto err7;
3170        }
3171
3172        return 0;
3173
3174err7:
3175#ifdef CONFIG_USB_DWC3_AL_VBUS_GPIO
3176        if (gpio_is_valid(dwc->vbus_gpio))
3177                free_irq(gpio_to_irq(dwc->vbus_gpio), dwc);
3178#endif
3179
3180err6:
3181#ifdef CONFIG_USB_DWC3_AL_VBUS_GPIO
3182        if (gpio_is_valid(dwc->vbus_gpio))
3183                gpio_free(dwc->vbus_gpio);
3184#endif
3185
3186err4:
3187        dwc3_gadget_free_endpoints(dwc);
3188        dma_free_coherent(dwc->dev, DWC3_EP0_BOUNCE_SIZE,
3189                        dwc->ep0_bounce, dwc->ep0_bounce_addr);
3190
3191err3:
3192        kfree(dwc->setup_buf);
3193
3194err2:
3195        dma_free_coherent(dwc->dev, sizeof(*dwc->ep0_trb) * 2,
3196                        dwc->ep0_trb, dwc->ep0_trb_addr);
3197
3198err1:
3199        dma_free_coherent(dwc->dev, sizeof(*dwc->ctrl_req),
3200                        dwc->ctrl_req, dwc->ctrl_req_addr);
3201
3202err0:
3203        return ret;
3204}
3205
3206/* -------------------------------------------------------------------------- */
3207
3208void dwc3_gadget_exit(struct dwc3 *dwc)
3209{
3210        usb_del_gadget_udc(&dwc->gadget);
3211
3212#ifdef CONFIG_USB_DWC3_AL_VBUS_GPIO
3213        if (gpio_is_valid(dwc->vbus_gpio)) {
3214                free_irq(gpio_to_irq(dwc->vbus_gpio), dwc);
3215                gpio_free(dwc->vbus_gpio);
3216        }
3217#endif
3218
3219        dwc3_gadget_free_endpoints(dwc);
3220
3221        dma_free_coherent(dwc->dev, DWC3_EP0_BOUNCE_SIZE,
3222                        dwc->ep0_bounce, dwc->ep0_bounce_addr);
3223
3224        kfree(dwc->setup_buf);
3225
3226        dma_free_coherent(dwc->dev, sizeof(*dwc->ep0_trb) * 2,
3227                        dwc->ep0_trb, dwc->ep0_trb_addr);
3228
3229        dma_free_coherent(dwc->dev, sizeof(*dwc->ctrl_req),
3230                        dwc->ctrl_req, dwc->ctrl_req_addr);
3231}
3232
3233int dwc3_gadget_suspend(struct dwc3 *dwc)
3234{
3235        if (dwc->pullups_connected) {
3236                dwc3_gadget_disable_irq(dwc);
3237                dwc3_gadget_run_stop(dwc, true, true);
3238        }
3239
3240        __dwc3_gadget_ep_disable(dwc->eps[0]);
3241        __dwc3_gadget_ep_disable(dwc->eps[1]);
3242
3243        dwc->dcfg = dwc3_readl(dwc->regs, DWC3_DCFG);
3244
3245        return 0;
3246}
3247
3248int dwc3_gadget_resume(struct dwc3 *dwc)
3249{
3250        struct dwc3_ep          *dep;
3251        int                     ret;
3252
3253        /* Start with SuperSpeed Default */
3254        dwc3_gadget_ep0_desc.wMaxPacketSize = cpu_to_le16(512);
3255
3256        dep = dwc->eps[0];
3257        ret = __dwc3_gadget_ep_enable(dep, &dwc3_gadget_ep0_desc, NULL, false,
3258                        false);
3259        if (ret)
3260                goto err0;
3261
3262        dep = dwc->eps[1];
3263        ret = __dwc3_gadget_ep_enable(dep, &dwc3_gadget_ep0_desc, NULL, false,
3264                        false);
3265        if (ret)
3266                goto err1;
3267
3268        /* begin to receive SETUP packets */
3269        dwc->ep0state = EP0_SETUP_PHASE;
3270        dwc3_ep0_out_start(dwc);
3271
3272        dwc3_writel(dwc->regs, DWC3_DCFG, dwc->dcfg);
3273
3274        if (dwc->pullups_connected) {
3275                dwc3_gadget_enable_irq(dwc);
3276                dwc3_gadget_run_stop(dwc, true, false);
3277        }
3278
3279        return 0;
3280
3281err1:
3282        __dwc3_gadget_ep_disable(dwc->eps[0]);
3283
3284err0:
3285        return ret;
3286}
Note: See TracBrowser for help on using the repository browser.