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

Last change on this file since 31278 was 31278, checked in by brainslayer, 4 months ago

for alpine, just source add, not yet ported

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