source: src/linux/universal/linux-4.9/drivers/usb/dwc3/gadget.c @ 31859

Last change on this file since 31859 was 31859, checked in by brainslayer, 10 days ago

kernel update

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