Merge branch 'upstream' of git://git.linux-mips.org/pub/scm/ralf/upstream-linus
[firefly-linux-kernel-4.4.55.git] / drivers / usb / dwc2 / gadget.c
1 /**
2  * Copyright (c) 2011 Samsung Electronics Co., Ltd.
3  *              http://www.samsung.com
4  *
5  * Copyright 2008 Openmoko, Inc.
6  * Copyright 2008 Simtec Electronics
7  *      Ben Dooks <ben@simtec.co.uk>
8  *      http://armlinux.simtec.co.uk/
9  *
10  * S3C USB2.0 High-speed / OtG driver
11  *
12  * This program is free software; you can redistribute it and/or modify
13  * it under the terms of the GNU General Public License version 2 as
14  * published by the Free Software Foundation.
15  */
16
17 #include <linux/kernel.h>
18 #include <linux/module.h>
19 #include <linux/spinlock.h>
20 #include <linux/interrupt.h>
21 #include <linux/platform_device.h>
22 #include <linux/dma-mapping.h>
23 #include <linux/mutex.h>
24 #include <linux/seq_file.h>
25 #include <linux/delay.h>
26 #include <linux/io.h>
27 #include <linux/slab.h>
28 #include <linux/of_platform.h>
29
30 #include <linux/usb/ch9.h>
31 #include <linux/usb/gadget.h>
32 #include <linux/usb/phy.h>
33
34 #include "core.h"
35 #include "hw.h"
36
37 /* conversion functions */
38 static inline struct dwc2_hsotg_req *our_req(struct usb_request *req)
39 {
40         return container_of(req, struct dwc2_hsotg_req, req);
41 }
42
43 static inline struct dwc2_hsotg_ep *our_ep(struct usb_ep *ep)
44 {
45         return container_of(ep, struct dwc2_hsotg_ep, ep);
46 }
47
48 static inline struct dwc2_hsotg *to_hsotg(struct usb_gadget *gadget)
49 {
50         return container_of(gadget, struct dwc2_hsotg, gadget);
51 }
52
53 static inline void __orr32(void __iomem *ptr, u32 val)
54 {
55         dwc2_writel(dwc2_readl(ptr) | val, ptr);
56 }
57
58 static inline void __bic32(void __iomem *ptr, u32 val)
59 {
60         dwc2_writel(dwc2_readl(ptr) & ~val, ptr);
61 }
62
63 static inline struct dwc2_hsotg_ep *index_to_ep(struct dwc2_hsotg *hsotg,
64                                                 u32 ep_index, u32 dir_in)
65 {
66         if (dir_in)
67                 return hsotg->eps_in[ep_index];
68         else
69                 return hsotg->eps_out[ep_index];
70 }
71
72 /* forward declaration of functions */
73 static void dwc2_hsotg_dump(struct dwc2_hsotg *hsotg);
74
75 /**
76  * using_dma - return the DMA status of the driver.
77  * @hsotg: The driver state.
78  *
79  * Return true if we're using DMA.
80  *
81  * Currently, we have the DMA support code worked into everywhere
82  * that needs it, but the AMBA DMA implementation in the hardware can
83  * only DMA from 32bit aligned addresses. This means that gadgets such
84  * as the CDC Ethernet cannot work as they often pass packets which are
85  * not 32bit aligned.
86  *
87  * Unfortunately the choice to use DMA or not is global to the controller
88  * and seems to be only settable when the controller is being put through
89  * a core reset. This means we either need to fix the gadgets to take
90  * account of DMA alignment, or add bounce buffers (yuerk).
91  *
92  * g_using_dma is set depending on dts flag.
93  */
94 static inline bool using_dma(struct dwc2_hsotg *hsotg)
95 {
96         return hsotg->g_using_dma;
97 }
98
99 /**
100  * dwc2_hsotg_en_gsint - enable one or more of the general interrupt
101  * @hsotg: The device state
102  * @ints: A bitmask of the interrupts to enable
103  */
104 static void dwc2_hsotg_en_gsint(struct dwc2_hsotg *hsotg, u32 ints)
105 {
106         u32 gsintmsk = dwc2_readl(hsotg->regs + GINTMSK);
107         u32 new_gsintmsk;
108
109         new_gsintmsk = gsintmsk | ints;
110
111         if (new_gsintmsk != gsintmsk) {
112                 dev_dbg(hsotg->dev, "gsintmsk now 0x%08x\n", new_gsintmsk);
113                 dwc2_writel(new_gsintmsk, hsotg->regs + GINTMSK);
114         }
115 }
116
117 /**
118  * dwc2_hsotg_disable_gsint - disable one or more of the general interrupt
119  * @hsotg: The device state
120  * @ints: A bitmask of the interrupts to enable
121  */
122 static void dwc2_hsotg_disable_gsint(struct dwc2_hsotg *hsotg, u32 ints)
123 {
124         u32 gsintmsk = dwc2_readl(hsotg->regs + GINTMSK);
125         u32 new_gsintmsk;
126
127         new_gsintmsk = gsintmsk & ~ints;
128
129         if (new_gsintmsk != gsintmsk)
130                 dwc2_writel(new_gsintmsk, hsotg->regs + GINTMSK);
131 }
132
133 /**
134  * dwc2_hsotg_ctrl_epint - enable/disable an endpoint irq
135  * @hsotg: The device state
136  * @ep: The endpoint index
137  * @dir_in: True if direction is in.
138  * @en: The enable value, true to enable
139  *
140  * Set or clear the mask for an individual endpoint's interrupt
141  * request.
142  */
143 static void dwc2_hsotg_ctrl_epint(struct dwc2_hsotg *hsotg,
144                                  unsigned int ep, unsigned int dir_in,
145                                  unsigned int en)
146 {
147         unsigned long flags;
148         u32 bit = 1 << ep;
149         u32 daint;
150
151         if (!dir_in)
152                 bit <<= 16;
153
154         local_irq_save(flags);
155         daint = dwc2_readl(hsotg->regs + DAINTMSK);
156         if (en)
157                 daint |= bit;
158         else
159                 daint &= ~bit;
160         dwc2_writel(daint, hsotg->regs + DAINTMSK);
161         local_irq_restore(flags);
162 }
163
164 /**
165  * dwc2_hsotg_init_fifo - initialise non-periodic FIFOs
166  * @hsotg: The device instance.
167  */
168 static void dwc2_hsotg_init_fifo(struct dwc2_hsotg *hsotg)
169 {
170         unsigned int ep;
171         unsigned int addr;
172         int timeout;
173         u32 val;
174
175         /* Reset fifo map if not correctly cleared during previous session */
176         WARN_ON(hsotg->fifo_map);
177         hsotg->fifo_map = 0;
178
179         /* set RX/NPTX FIFO sizes */
180         dwc2_writel(hsotg->g_rx_fifo_sz, hsotg->regs + GRXFSIZ);
181         dwc2_writel((hsotg->g_rx_fifo_sz << FIFOSIZE_STARTADDR_SHIFT) |
182                 (hsotg->g_np_g_tx_fifo_sz << FIFOSIZE_DEPTH_SHIFT),
183                 hsotg->regs + GNPTXFSIZ);
184
185         /*
186          * arange all the rest of the TX FIFOs, as some versions of this
187          * block have overlapping default addresses. This also ensures
188          * that if the settings have been changed, then they are set to
189          * known values.
190          */
191
192         /* start at the end of the GNPTXFSIZ, rounded up */
193         addr = hsotg->g_rx_fifo_sz + hsotg->g_np_g_tx_fifo_sz;
194
195         /*
196          * Configure fifos sizes from provided configuration and assign
197          * them to endpoints dynamically according to maxpacket size value of
198          * given endpoint.
199          */
200         for (ep = 1; ep < MAX_EPS_CHANNELS; ep++) {
201                 if (!hsotg->g_tx_fifo_sz[ep])
202                         continue;
203                 val = addr;
204                 val |= hsotg->g_tx_fifo_sz[ep] << FIFOSIZE_DEPTH_SHIFT;
205                 WARN_ONCE(addr + hsotg->g_tx_fifo_sz[ep] > hsotg->fifo_mem,
206                           "insufficient fifo memory");
207                 addr += hsotg->g_tx_fifo_sz[ep];
208
209                 dwc2_writel(val, hsotg->regs + DPTXFSIZN(ep));
210         }
211
212         /*
213          * according to p428 of the design guide, we need to ensure that
214          * all fifos are flushed before continuing
215          */
216
217         dwc2_writel(GRSTCTL_TXFNUM(0x10) | GRSTCTL_TXFFLSH |
218                GRSTCTL_RXFFLSH, hsotg->regs + GRSTCTL);
219
220         /* wait until the fifos are both flushed */
221         timeout = 100;
222         while (1) {
223                 val = dwc2_readl(hsotg->regs + GRSTCTL);
224
225                 if ((val & (GRSTCTL_TXFFLSH | GRSTCTL_RXFFLSH)) == 0)
226                         break;
227
228                 if (--timeout == 0) {
229                         dev_err(hsotg->dev,
230                                 "%s: timeout flushing fifos (GRSTCTL=%08x)\n",
231                                 __func__, val);
232                         break;
233                 }
234
235                 udelay(1);
236         }
237
238         dev_dbg(hsotg->dev, "FIFOs reset, timeout at %d\n", timeout);
239 }
240
241 /**
242  * @ep: USB endpoint to allocate request for.
243  * @flags: Allocation flags
244  *
245  * Allocate a new USB request structure appropriate for the specified endpoint
246  */
247 static struct usb_request *dwc2_hsotg_ep_alloc_request(struct usb_ep *ep,
248                                                       gfp_t flags)
249 {
250         struct dwc2_hsotg_req *req;
251
252         req = kzalloc(sizeof(struct dwc2_hsotg_req), flags);
253         if (!req)
254                 return NULL;
255
256         INIT_LIST_HEAD(&req->queue);
257
258         return &req->req;
259 }
260
261 /**
262  * is_ep_periodic - return true if the endpoint is in periodic mode.
263  * @hs_ep: The endpoint to query.
264  *
265  * Returns true if the endpoint is in periodic mode, meaning it is being
266  * used for an Interrupt or ISO transfer.
267  */
268 static inline int is_ep_periodic(struct dwc2_hsotg_ep *hs_ep)
269 {
270         return hs_ep->periodic;
271 }
272
273 /**
274  * dwc2_hsotg_unmap_dma - unmap the DMA memory being used for the request
275  * @hsotg: The device state.
276  * @hs_ep: The endpoint for the request
277  * @hs_req: The request being processed.
278  *
279  * This is the reverse of dwc2_hsotg_map_dma(), called for the completion
280  * of a request to ensure the buffer is ready for access by the caller.
281  */
282 static void dwc2_hsotg_unmap_dma(struct dwc2_hsotg *hsotg,
283                                 struct dwc2_hsotg_ep *hs_ep,
284                                 struct dwc2_hsotg_req *hs_req)
285 {
286         struct usb_request *req = &hs_req->req;
287
288         /* ignore this if we're not moving any data */
289         if (hs_req->req.length == 0)
290                 return;
291
292         usb_gadget_unmap_request(&hsotg->gadget, req, hs_ep->dir_in);
293 }
294
295 /**
296  * dwc2_hsotg_write_fifo - write packet Data to the TxFIFO
297  * @hsotg: The controller state.
298  * @hs_ep: The endpoint we're going to write for.
299  * @hs_req: The request to write data for.
300  *
301  * This is called when the TxFIFO has some space in it to hold a new
302  * transmission and we have something to give it. The actual setup of
303  * the data size is done elsewhere, so all we have to do is to actually
304  * write the data.
305  *
306  * The return value is zero if there is more space (or nothing was done)
307  * otherwise -ENOSPC is returned if the FIFO space was used up.
308  *
309  * This routine is only needed for PIO
310  */
311 static int dwc2_hsotg_write_fifo(struct dwc2_hsotg *hsotg,
312                                 struct dwc2_hsotg_ep *hs_ep,
313                                 struct dwc2_hsotg_req *hs_req)
314 {
315         bool periodic = is_ep_periodic(hs_ep);
316         u32 gnptxsts = dwc2_readl(hsotg->regs + GNPTXSTS);
317         int buf_pos = hs_req->req.actual;
318         int to_write = hs_ep->size_loaded;
319         void *data;
320         int can_write;
321         int pkt_round;
322         int max_transfer;
323
324         to_write -= (buf_pos - hs_ep->last_load);
325
326         /* if there's nothing to write, get out early */
327         if (to_write == 0)
328                 return 0;
329
330         if (periodic && !hsotg->dedicated_fifos) {
331                 u32 epsize = dwc2_readl(hsotg->regs + DIEPTSIZ(hs_ep->index));
332                 int size_left;
333                 int size_done;
334
335                 /*
336                  * work out how much data was loaded so we can calculate
337                  * how much data is left in the fifo.
338                  */
339
340                 size_left = DXEPTSIZ_XFERSIZE_GET(epsize);
341
342                 /*
343                  * if shared fifo, we cannot write anything until the
344                  * previous data has been completely sent.
345                  */
346                 if (hs_ep->fifo_load != 0) {
347                         dwc2_hsotg_en_gsint(hsotg, GINTSTS_PTXFEMP);
348                         return -ENOSPC;
349                 }
350
351                 dev_dbg(hsotg->dev, "%s: left=%d, load=%d, fifo=%d, size %d\n",
352                         __func__, size_left,
353                         hs_ep->size_loaded, hs_ep->fifo_load, hs_ep->fifo_size);
354
355                 /* how much of the data has moved */
356                 size_done = hs_ep->size_loaded - size_left;
357
358                 /* how much data is left in the fifo */
359                 can_write = hs_ep->fifo_load - size_done;
360                 dev_dbg(hsotg->dev, "%s: => can_write1=%d\n",
361                         __func__, can_write);
362
363                 can_write = hs_ep->fifo_size - can_write;
364                 dev_dbg(hsotg->dev, "%s: => can_write2=%d\n",
365                         __func__, can_write);
366
367                 if (can_write <= 0) {
368                         dwc2_hsotg_en_gsint(hsotg, GINTSTS_PTXFEMP);
369                         return -ENOSPC;
370                 }
371         } else if (hsotg->dedicated_fifos && hs_ep->index != 0) {
372                 can_write = dwc2_readl(hsotg->regs + DTXFSTS(hs_ep->index));
373
374                 can_write &= 0xffff;
375                 can_write *= 4;
376         } else {
377                 if (GNPTXSTS_NP_TXQ_SPC_AVAIL_GET(gnptxsts) == 0) {
378                         dev_dbg(hsotg->dev,
379                                 "%s: no queue slots available (0x%08x)\n",
380                                 __func__, gnptxsts);
381
382                         dwc2_hsotg_en_gsint(hsotg, GINTSTS_NPTXFEMP);
383                         return -ENOSPC;
384                 }
385
386                 can_write = GNPTXSTS_NP_TXF_SPC_AVAIL_GET(gnptxsts);
387                 can_write *= 4; /* fifo size is in 32bit quantities. */
388         }
389
390         max_transfer = hs_ep->ep.maxpacket * hs_ep->mc;
391
392         dev_dbg(hsotg->dev, "%s: GNPTXSTS=%08x, can=%d, to=%d, max_transfer %d\n",
393                  __func__, gnptxsts, can_write, to_write, max_transfer);
394
395         /*
396          * limit to 512 bytes of data, it seems at least on the non-periodic
397          * FIFO, requests of >512 cause the endpoint to get stuck with a
398          * fragment of the end of the transfer in it.
399          */
400         if (can_write > 512 && !periodic)
401                 can_write = 512;
402
403         /*
404          * limit the write to one max-packet size worth of data, but allow
405          * the transfer to return that it did not run out of fifo space
406          * doing it.
407          */
408         if (to_write > max_transfer) {
409                 to_write = max_transfer;
410
411                 /* it's needed only when we do not use dedicated fifos */
412                 if (!hsotg->dedicated_fifos)
413                         dwc2_hsotg_en_gsint(hsotg,
414                                            periodic ? GINTSTS_PTXFEMP :
415                                            GINTSTS_NPTXFEMP);
416         }
417
418         /* see if we can write data */
419
420         if (to_write > can_write) {
421                 to_write = can_write;
422                 pkt_round = to_write % max_transfer;
423
424                 /*
425                  * Round the write down to an
426                  * exact number of packets.
427                  *
428                  * Note, we do not currently check to see if we can ever
429                  * write a full packet or not to the FIFO.
430                  */
431
432                 if (pkt_round)
433                         to_write -= pkt_round;
434
435                 /*
436                  * enable correct FIFO interrupt to alert us when there
437                  * is more room left.
438                  */
439
440                 /* it's needed only when we do not use dedicated fifos */
441                 if (!hsotg->dedicated_fifos)
442                         dwc2_hsotg_en_gsint(hsotg,
443                                            periodic ? GINTSTS_PTXFEMP :
444                                            GINTSTS_NPTXFEMP);
445         }
446
447         dev_dbg(hsotg->dev, "write %d/%d, can_write %d, done %d\n",
448                  to_write, hs_req->req.length, can_write, buf_pos);
449
450         if (to_write <= 0)
451                 return -ENOSPC;
452
453         hs_req->req.actual = buf_pos + to_write;
454         hs_ep->total_data += to_write;
455
456         if (periodic)
457                 hs_ep->fifo_load += to_write;
458
459         to_write = DIV_ROUND_UP(to_write, 4);
460         data = hs_req->req.buf + buf_pos;
461
462         iowrite32_rep(hsotg->regs + EPFIFO(hs_ep->index), data, to_write);
463
464         return (to_write >= can_write) ? -ENOSPC : 0;
465 }
466
467 /**
468  * get_ep_limit - get the maximum data legnth for this endpoint
469  * @hs_ep: The endpoint
470  *
471  * Return the maximum data that can be queued in one go on a given endpoint
472  * so that transfers that are too long can be split.
473  */
474 static unsigned get_ep_limit(struct dwc2_hsotg_ep *hs_ep)
475 {
476         int index = hs_ep->index;
477         unsigned maxsize;
478         unsigned maxpkt;
479
480         if (index != 0) {
481                 maxsize = DXEPTSIZ_XFERSIZE_LIMIT + 1;
482                 maxpkt = DXEPTSIZ_PKTCNT_LIMIT + 1;
483         } else {
484                 maxsize = 64+64;
485                 if (hs_ep->dir_in)
486                         maxpkt = DIEPTSIZ0_PKTCNT_LIMIT + 1;
487                 else
488                         maxpkt = 2;
489         }
490
491         /* we made the constant loading easier above by using +1 */
492         maxpkt--;
493         maxsize--;
494
495         /*
496          * constrain by packet count if maxpkts*pktsize is greater
497          * than the length register size.
498          */
499
500         if ((maxpkt * hs_ep->ep.maxpacket) < maxsize)
501                 maxsize = maxpkt * hs_ep->ep.maxpacket;
502
503         return maxsize;
504 }
505
506 /**
507  * dwc2_hsotg_start_req - start a USB request from an endpoint's queue
508  * @hsotg: The controller state.
509  * @hs_ep: The endpoint to process a request for
510  * @hs_req: The request to start.
511  * @continuing: True if we are doing more for the current request.
512  *
513  * Start the given request running by setting the endpoint registers
514  * appropriately, and writing any data to the FIFOs.
515  */
516 static void dwc2_hsotg_start_req(struct dwc2_hsotg *hsotg,
517                                 struct dwc2_hsotg_ep *hs_ep,
518                                 struct dwc2_hsotg_req *hs_req,
519                                 bool continuing)
520 {
521         struct usb_request *ureq = &hs_req->req;
522         int index = hs_ep->index;
523         int dir_in = hs_ep->dir_in;
524         u32 epctrl_reg;
525         u32 epsize_reg;
526         u32 epsize;
527         u32 ctrl;
528         unsigned length;
529         unsigned packets;
530         unsigned maxreq;
531
532         if (index != 0) {
533                 if (hs_ep->req && !continuing) {
534                         dev_err(hsotg->dev, "%s: active request\n", __func__);
535                         WARN_ON(1);
536                         return;
537                 } else if (hs_ep->req != hs_req && continuing) {
538                         dev_err(hsotg->dev,
539                                 "%s: continue different req\n", __func__);
540                         WARN_ON(1);
541                         return;
542                 }
543         }
544
545         epctrl_reg = dir_in ? DIEPCTL(index) : DOEPCTL(index);
546         epsize_reg = dir_in ? DIEPTSIZ(index) : DOEPTSIZ(index);
547
548         dev_dbg(hsotg->dev, "%s: DxEPCTL=0x%08x, ep %d, dir %s\n",
549                 __func__, dwc2_readl(hsotg->regs + epctrl_reg), index,
550                 hs_ep->dir_in ? "in" : "out");
551
552         /* If endpoint is stalled, we will restart request later */
553         ctrl = dwc2_readl(hsotg->regs + epctrl_reg);
554
555         if (index && ctrl & DXEPCTL_STALL) {
556                 dev_warn(hsotg->dev, "%s: ep%d is stalled\n", __func__, index);
557                 return;
558         }
559
560         length = ureq->length - ureq->actual;
561         dev_dbg(hsotg->dev, "ureq->length:%d ureq->actual:%d\n",
562                 ureq->length, ureq->actual);
563
564         maxreq = get_ep_limit(hs_ep);
565         if (length > maxreq) {
566                 int round = maxreq % hs_ep->ep.maxpacket;
567
568                 dev_dbg(hsotg->dev, "%s: length %d, max-req %d, r %d\n",
569                         __func__, length, maxreq, round);
570
571                 /* round down to multiple of packets */
572                 if (round)
573                         maxreq -= round;
574
575                 length = maxreq;
576         }
577
578         if (length)
579                 packets = DIV_ROUND_UP(length, hs_ep->ep.maxpacket);
580         else
581                 packets = 1;    /* send one packet if length is zero. */
582
583         if (hs_ep->isochronous && length > (hs_ep->mc * hs_ep->ep.maxpacket)) {
584                 dev_err(hsotg->dev, "req length > maxpacket*mc\n");
585                 return;
586         }
587
588         if (dir_in && index != 0)
589                 if (hs_ep->isochronous)
590                         epsize = DXEPTSIZ_MC(packets);
591                 else
592                         epsize = DXEPTSIZ_MC(1);
593         else
594                 epsize = 0;
595
596         /*
597          * zero length packet should be programmed on its own and should not
598          * be counted in DIEPTSIZ.PktCnt with other packets.
599          */
600         if (dir_in && ureq->zero && !continuing) {
601                 /* Test if zlp is actually required. */
602                 if ((ureq->length >= hs_ep->ep.maxpacket) &&
603                                         !(ureq->length % hs_ep->ep.maxpacket))
604                         hs_ep->send_zlp = 1;
605         }
606
607         epsize |= DXEPTSIZ_PKTCNT(packets);
608         epsize |= DXEPTSIZ_XFERSIZE(length);
609
610         dev_dbg(hsotg->dev, "%s: %d@%d/%d, 0x%08x => 0x%08x\n",
611                 __func__, packets, length, ureq->length, epsize, epsize_reg);
612
613         /* store the request as the current one we're doing */
614         hs_ep->req = hs_req;
615
616         /* write size / packets */
617         dwc2_writel(epsize, hsotg->regs + epsize_reg);
618
619         if (using_dma(hsotg) && !continuing) {
620                 unsigned int dma_reg;
621
622                 /*
623                  * write DMA address to control register, buffer already
624                  * synced by dwc2_hsotg_ep_queue().
625                  */
626
627                 dma_reg = dir_in ? DIEPDMA(index) : DOEPDMA(index);
628                 dwc2_writel(ureq->dma, hsotg->regs + dma_reg);
629
630                 dev_dbg(hsotg->dev, "%s: %pad => 0x%08x\n",
631                         __func__, &ureq->dma, dma_reg);
632         }
633
634         ctrl |= DXEPCTL_EPENA;  /* ensure ep enabled */
635         ctrl |= DXEPCTL_USBACTEP;
636
637         dev_dbg(hsotg->dev, "ep0 state:%d\n", hsotg->ep0_state);
638
639         /* For Setup request do not clear NAK */
640         if (!(index == 0 && hsotg->ep0_state == DWC2_EP0_SETUP))
641                 ctrl |= DXEPCTL_CNAK;   /* clear NAK set by core */
642
643         dev_dbg(hsotg->dev, "%s: DxEPCTL=0x%08x\n", __func__, ctrl);
644         dwc2_writel(ctrl, hsotg->regs + epctrl_reg);
645
646         /*
647          * set these, it seems that DMA support increments past the end
648          * of the packet buffer so we need to calculate the length from
649          * this information.
650          */
651         hs_ep->size_loaded = length;
652         hs_ep->last_load = ureq->actual;
653
654         if (dir_in && !using_dma(hsotg)) {
655                 /* set these anyway, we may need them for non-periodic in */
656                 hs_ep->fifo_load = 0;
657
658                 dwc2_hsotg_write_fifo(hsotg, hs_ep, hs_req);
659         }
660
661         /*
662          * clear the INTknTXFEmpMsk when we start request, more as a aide
663          * to debugging to see what is going on.
664          */
665         if (dir_in)
666                 dwc2_writel(DIEPMSK_INTKNTXFEMPMSK,
667                        hsotg->regs + DIEPINT(index));
668
669         /*
670          * Note, trying to clear the NAK here causes problems with transmit
671          * on the S3C6400 ending up with the TXFIFO becoming full.
672          */
673
674         /* check ep is enabled */
675         if (!(dwc2_readl(hsotg->regs + epctrl_reg) & DXEPCTL_EPENA))
676                 dev_dbg(hsotg->dev,
677                          "ep%d: failed to become enabled (DXEPCTL=0x%08x)?\n",
678                          index, dwc2_readl(hsotg->regs + epctrl_reg));
679
680         dev_dbg(hsotg->dev, "%s: DXEPCTL=0x%08x\n",
681                 __func__, dwc2_readl(hsotg->regs + epctrl_reg));
682
683         /* enable ep interrupts */
684         dwc2_hsotg_ctrl_epint(hsotg, hs_ep->index, hs_ep->dir_in, 1);
685 }
686
687 /**
688  * dwc2_hsotg_map_dma - map the DMA memory being used for the request
689  * @hsotg: The device state.
690  * @hs_ep: The endpoint the request is on.
691  * @req: The request being processed.
692  *
693  * We've been asked to queue a request, so ensure that the memory buffer
694  * is correctly setup for DMA. If we've been passed an extant DMA address
695  * then ensure the buffer has been synced to memory. If our buffer has no
696  * DMA memory, then we map the memory and mark our request to allow us to
697  * cleanup on completion.
698  */
699 static int dwc2_hsotg_map_dma(struct dwc2_hsotg *hsotg,
700                              struct dwc2_hsotg_ep *hs_ep,
701                              struct usb_request *req)
702 {
703         struct dwc2_hsotg_req *hs_req = our_req(req);
704         int ret;
705
706         /* if the length is zero, ignore the DMA data */
707         if (hs_req->req.length == 0)
708                 return 0;
709
710         ret = usb_gadget_map_request(&hsotg->gadget, req, hs_ep->dir_in);
711         if (ret)
712                 goto dma_error;
713
714         return 0;
715
716 dma_error:
717         dev_err(hsotg->dev, "%s: failed to map buffer %p, %d bytes\n",
718                 __func__, req->buf, req->length);
719
720         return -EIO;
721 }
722
723 static int dwc2_hsotg_handle_unaligned_buf_start(struct dwc2_hsotg *hsotg,
724         struct dwc2_hsotg_ep *hs_ep, struct dwc2_hsotg_req *hs_req)
725 {
726         void *req_buf = hs_req->req.buf;
727
728         /* If dma is not being used or buffer is aligned */
729         if (!using_dma(hsotg) || !((long)req_buf & 3))
730                 return 0;
731
732         WARN_ON(hs_req->saved_req_buf);
733
734         dev_dbg(hsotg->dev, "%s: %s: buf=%p length=%d\n", __func__,
735                         hs_ep->ep.name, req_buf, hs_req->req.length);
736
737         hs_req->req.buf = kmalloc(hs_req->req.length, GFP_ATOMIC);
738         if (!hs_req->req.buf) {
739                 hs_req->req.buf = req_buf;
740                 dev_err(hsotg->dev,
741                         "%s: unable to allocate memory for bounce buffer\n",
742                         __func__);
743                 return -ENOMEM;
744         }
745
746         /* Save actual buffer */
747         hs_req->saved_req_buf = req_buf;
748
749         if (hs_ep->dir_in)
750                 memcpy(hs_req->req.buf, req_buf, hs_req->req.length);
751         return 0;
752 }
753
754 static void dwc2_hsotg_handle_unaligned_buf_complete(struct dwc2_hsotg *hsotg,
755         struct dwc2_hsotg_ep *hs_ep, struct dwc2_hsotg_req *hs_req)
756 {
757         /* If dma is not being used or buffer was aligned */
758         if (!using_dma(hsotg) || !hs_req->saved_req_buf)
759                 return;
760
761         dev_dbg(hsotg->dev, "%s: %s: status=%d actual-length=%d\n", __func__,
762                 hs_ep->ep.name, hs_req->req.status, hs_req->req.actual);
763
764         /* Copy data from bounce buffer on successful out transfer */
765         if (!hs_ep->dir_in && !hs_req->req.status)
766                 memcpy(hs_req->saved_req_buf, hs_req->req.buf,
767                                                         hs_req->req.actual);
768
769         /* Free bounce buffer */
770         kfree(hs_req->req.buf);
771
772         hs_req->req.buf = hs_req->saved_req_buf;
773         hs_req->saved_req_buf = NULL;
774 }
775
776 static int dwc2_hsotg_ep_queue(struct usb_ep *ep, struct usb_request *req,
777                               gfp_t gfp_flags)
778 {
779         struct dwc2_hsotg_req *hs_req = our_req(req);
780         struct dwc2_hsotg_ep *hs_ep = our_ep(ep);
781         struct dwc2_hsotg *hs = hs_ep->parent;
782         bool first;
783         int ret;
784
785         dev_dbg(hs->dev, "%s: req %p: %d@%p, noi=%d, zero=%d, snok=%d\n",
786                 ep->name, req, req->length, req->buf, req->no_interrupt,
787                 req->zero, req->short_not_ok);
788
789         /* Prevent new request submission when controller is suspended */
790         if (hs->lx_state == DWC2_L2) {
791                 dev_dbg(hs->dev, "%s: don't submit request while suspended\n",
792                                 __func__);
793                 return -EAGAIN;
794         }
795
796         /* initialise status of the request */
797         INIT_LIST_HEAD(&hs_req->queue);
798         req->actual = 0;
799         req->status = -EINPROGRESS;
800
801         ret = dwc2_hsotg_handle_unaligned_buf_start(hs, hs_ep, hs_req);
802         if (ret)
803                 return ret;
804
805         /* if we're using DMA, sync the buffers as necessary */
806         if (using_dma(hs)) {
807                 ret = dwc2_hsotg_map_dma(hs, hs_ep, req);
808                 if (ret)
809                         return ret;
810         }
811
812         first = list_empty(&hs_ep->queue);
813         list_add_tail(&hs_req->queue, &hs_ep->queue);
814
815         if (first)
816                 dwc2_hsotg_start_req(hs, hs_ep, hs_req, false);
817
818         return 0;
819 }
820
821 static int dwc2_hsotg_ep_queue_lock(struct usb_ep *ep, struct usb_request *req,
822                               gfp_t gfp_flags)
823 {
824         struct dwc2_hsotg_ep *hs_ep = our_ep(ep);
825         struct dwc2_hsotg *hs = hs_ep->parent;
826         unsigned long flags = 0;
827         int ret = 0;
828
829         spin_lock_irqsave(&hs->lock, flags);
830         ret = dwc2_hsotg_ep_queue(ep, req, gfp_flags);
831         spin_unlock_irqrestore(&hs->lock, flags);
832
833         return ret;
834 }
835
836 static void dwc2_hsotg_ep_free_request(struct usb_ep *ep,
837                                       struct usb_request *req)
838 {
839         struct dwc2_hsotg_req *hs_req = our_req(req);
840
841         kfree(hs_req);
842 }
843
844 /**
845  * dwc2_hsotg_complete_oursetup - setup completion callback
846  * @ep: The endpoint the request was on.
847  * @req: The request completed.
848  *
849  * Called on completion of any requests the driver itself
850  * submitted that need cleaning up.
851  */
852 static void dwc2_hsotg_complete_oursetup(struct usb_ep *ep,
853                                         struct usb_request *req)
854 {
855         struct dwc2_hsotg_ep *hs_ep = our_ep(ep);
856         struct dwc2_hsotg *hsotg = hs_ep->parent;
857
858         dev_dbg(hsotg->dev, "%s: ep %p, req %p\n", __func__, ep, req);
859
860         dwc2_hsotg_ep_free_request(ep, req);
861 }
862
863 /**
864  * ep_from_windex - convert control wIndex value to endpoint
865  * @hsotg: The driver state.
866  * @windex: The control request wIndex field (in host order).
867  *
868  * Convert the given wIndex into a pointer to an driver endpoint
869  * structure, or return NULL if it is not a valid endpoint.
870  */
871 static struct dwc2_hsotg_ep *ep_from_windex(struct dwc2_hsotg *hsotg,
872                                            u32 windex)
873 {
874         struct dwc2_hsotg_ep *ep;
875         int dir = (windex & USB_DIR_IN) ? 1 : 0;
876         int idx = windex & 0x7F;
877
878         if (windex >= 0x100)
879                 return NULL;
880
881         if (idx > hsotg->num_of_eps)
882                 return NULL;
883
884         ep = index_to_ep(hsotg, idx, dir);
885
886         if (idx && ep->dir_in != dir)
887                 return NULL;
888
889         return ep;
890 }
891
892 /**
893  * dwc2_hsotg_set_test_mode - Enable usb Test Modes
894  * @hsotg: The driver state.
895  * @testmode: requested usb test mode
896  * Enable usb Test Mode requested by the Host.
897  */
898 int dwc2_hsotg_set_test_mode(struct dwc2_hsotg *hsotg, int testmode)
899 {
900         int dctl = dwc2_readl(hsotg->regs + DCTL);
901
902         dctl &= ~DCTL_TSTCTL_MASK;
903         switch (testmode) {
904         case TEST_J:
905         case TEST_K:
906         case TEST_SE0_NAK:
907         case TEST_PACKET:
908         case TEST_FORCE_EN:
909                 dctl |= testmode << DCTL_TSTCTL_SHIFT;
910                 break;
911         default:
912                 return -EINVAL;
913         }
914         dwc2_writel(dctl, hsotg->regs + DCTL);
915         return 0;
916 }
917
918 /**
919  * dwc2_hsotg_send_reply - send reply to control request
920  * @hsotg: The device state
921  * @ep: Endpoint 0
922  * @buff: Buffer for request
923  * @length: Length of reply.
924  *
925  * Create a request and queue it on the given endpoint. This is useful as
926  * an internal method of sending replies to certain control requests, etc.
927  */
928 static int dwc2_hsotg_send_reply(struct dwc2_hsotg *hsotg,
929                                 struct dwc2_hsotg_ep *ep,
930                                 void *buff,
931                                 int length)
932 {
933         struct usb_request *req;
934         int ret;
935
936         dev_dbg(hsotg->dev, "%s: buff %p, len %d\n", __func__, buff, length);
937
938         req = dwc2_hsotg_ep_alloc_request(&ep->ep, GFP_ATOMIC);
939         hsotg->ep0_reply = req;
940         if (!req) {
941                 dev_warn(hsotg->dev, "%s: cannot alloc req\n", __func__);
942                 return -ENOMEM;
943         }
944
945         req->buf = hsotg->ep0_buff;
946         req->length = length;
947         /*
948          * zero flag is for sending zlp in DATA IN stage. It has no impact on
949          * STATUS stage.
950          */
951         req->zero = 0;
952         req->complete = dwc2_hsotg_complete_oursetup;
953
954         if (length)
955                 memcpy(req->buf, buff, length);
956
957         ret = dwc2_hsotg_ep_queue(&ep->ep, req, GFP_ATOMIC);
958         if (ret) {
959                 dev_warn(hsotg->dev, "%s: cannot queue req\n", __func__);
960                 return ret;
961         }
962
963         return 0;
964 }
965
966 /**
967  * dwc2_hsotg_process_req_status - process request GET_STATUS
968  * @hsotg: The device state
969  * @ctrl: USB control request
970  */
971 static int dwc2_hsotg_process_req_status(struct dwc2_hsotg *hsotg,
972                                         struct usb_ctrlrequest *ctrl)
973 {
974         struct dwc2_hsotg_ep *ep0 = hsotg->eps_out[0];
975         struct dwc2_hsotg_ep *ep;
976         __le16 reply;
977         int ret;
978
979         dev_dbg(hsotg->dev, "%s: USB_REQ_GET_STATUS\n", __func__);
980
981         if (!ep0->dir_in) {
982                 dev_warn(hsotg->dev, "%s: direction out?\n", __func__);
983                 return -EINVAL;
984         }
985
986         switch (ctrl->bRequestType & USB_RECIP_MASK) {
987         case USB_RECIP_DEVICE:
988                 reply = cpu_to_le16(0); /* bit 0 => self powered,
989                                          * bit 1 => remote wakeup */
990                 break;
991
992         case USB_RECIP_INTERFACE:
993                 /* currently, the data result should be zero */
994                 reply = cpu_to_le16(0);
995                 break;
996
997         case USB_RECIP_ENDPOINT:
998                 ep = ep_from_windex(hsotg, le16_to_cpu(ctrl->wIndex));
999                 if (!ep)
1000                         return -ENOENT;
1001
1002                 reply = cpu_to_le16(ep->halted ? 1 : 0);
1003                 break;
1004
1005         default:
1006                 return 0;
1007         }
1008
1009         if (le16_to_cpu(ctrl->wLength) != 2)
1010                 return -EINVAL;
1011
1012         ret = dwc2_hsotg_send_reply(hsotg, ep0, &reply, 2);
1013         if (ret) {
1014                 dev_err(hsotg->dev, "%s: failed to send reply\n", __func__);
1015                 return ret;
1016         }
1017
1018         return 1;
1019 }
1020
1021 static int dwc2_hsotg_ep_sethalt(struct usb_ep *ep, int value);
1022
1023 /**
1024  * get_ep_head - return the first request on the endpoint
1025  * @hs_ep: The controller endpoint to get
1026  *
1027  * Get the first request on the endpoint.
1028  */
1029 static struct dwc2_hsotg_req *get_ep_head(struct dwc2_hsotg_ep *hs_ep)
1030 {
1031         if (list_empty(&hs_ep->queue))
1032                 return NULL;
1033
1034         return list_first_entry(&hs_ep->queue, struct dwc2_hsotg_req, queue);
1035 }
1036
1037 /**
1038  * dwc2_hsotg_process_req_feature - process request {SET,CLEAR}_FEATURE
1039  * @hsotg: The device state
1040  * @ctrl: USB control request
1041  */
1042 static int dwc2_hsotg_process_req_feature(struct dwc2_hsotg *hsotg,
1043                                          struct usb_ctrlrequest *ctrl)
1044 {
1045         struct dwc2_hsotg_ep *ep0 = hsotg->eps_out[0];
1046         struct dwc2_hsotg_req *hs_req;
1047         bool restart;
1048         bool set = (ctrl->bRequest == USB_REQ_SET_FEATURE);
1049         struct dwc2_hsotg_ep *ep;
1050         int ret;
1051         bool halted;
1052         u32 recip;
1053         u32 wValue;
1054         u32 wIndex;
1055
1056         dev_dbg(hsotg->dev, "%s: %s_FEATURE\n",
1057                 __func__, set ? "SET" : "CLEAR");
1058
1059         wValue = le16_to_cpu(ctrl->wValue);
1060         wIndex = le16_to_cpu(ctrl->wIndex);
1061         recip = ctrl->bRequestType & USB_RECIP_MASK;
1062
1063         switch (recip) {
1064         case USB_RECIP_DEVICE:
1065                 switch (wValue) {
1066                 case USB_DEVICE_TEST_MODE:
1067                         if ((wIndex & 0xff) != 0)
1068                                 return -EINVAL;
1069                         if (!set)
1070                                 return -EINVAL;
1071
1072                         hsotg->test_mode = wIndex >> 8;
1073                         ret = dwc2_hsotg_send_reply(hsotg, ep0, NULL, 0);
1074                         if (ret) {
1075                                 dev_err(hsotg->dev,
1076                                         "%s: failed to send reply\n", __func__);
1077                                 return ret;
1078                         }
1079                         break;
1080                 default:
1081                         return -ENOENT;
1082                 }
1083                 break;
1084
1085         case USB_RECIP_ENDPOINT:
1086                 ep = ep_from_windex(hsotg, wIndex);
1087                 if (!ep) {
1088                         dev_dbg(hsotg->dev, "%s: no endpoint for 0x%04x\n",
1089                                 __func__, wIndex);
1090                         return -ENOENT;
1091                 }
1092
1093                 switch (wValue) {
1094                 case USB_ENDPOINT_HALT:
1095                         halted = ep->halted;
1096
1097                         dwc2_hsotg_ep_sethalt(&ep->ep, set);
1098
1099                         ret = dwc2_hsotg_send_reply(hsotg, ep0, NULL, 0);
1100                         if (ret) {
1101                                 dev_err(hsotg->dev,
1102                                         "%s: failed to send reply\n", __func__);
1103                                 return ret;
1104                         }
1105
1106                         /*
1107                          * we have to complete all requests for ep if it was
1108                          * halted, and the halt was cleared by CLEAR_FEATURE
1109                          */
1110
1111                         if (!set && halted) {
1112                                 /*
1113                                  * If we have request in progress,
1114                                  * then complete it
1115                                  */
1116                                 if (ep->req) {
1117                                         hs_req = ep->req;
1118                                         ep->req = NULL;
1119                                         list_del_init(&hs_req->queue);
1120                                         if (hs_req->req.complete) {
1121                                                 spin_unlock(&hsotg->lock);
1122                                                 usb_gadget_giveback_request(
1123                                                         &ep->ep, &hs_req->req);
1124                                                 spin_lock(&hsotg->lock);
1125                                         }
1126                                 }
1127
1128                                 /* If we have pending request, then start it */
1129                                 if (!ep->req) {
1130                                         restart = !list_empty(&ep->queue);
1131                                         if (restart) {
1132                                                 hs_req = get_ep_head(ep);
1133                                                 dwc2_hsotg_start_req(hsotg, ep,
1134                                                                 hs_req, false);
1135                                         }
1136                                 }
1137                         }
1138
1139                         break;
1140
1141                 default:
1142                         return -ENOENT;
1143                 }
1144                 break;
1145         default:
1146                 return -ENOENT;
1147         }
1148         return 1;
1149 }
1150
1151 static void dwc2_hsotg_enqueue_setup(struct dwc2_hsotg *hsotg);
1152
1153 /**
1154  * dwc2_hsotg_stall_ep0 - stall ep0
1155  * @hsotg: The device state
1156  *
1157  * Set stall for ep0 as response for setup request.
1158  */
1159 static void dwc2_hsotg_stall_ep0(struct dwc2_hsotg *hsotg)
1160 {
1161         struct dwc2_hsotg_ep *ep0 = hsotg->eps_out[0];
1162         u32 reg;
1163         u32 ctrl;
1164
1165         dev_dbg(hsotg->dev, "ep0 stall (dir=%d)\n", ep0->dir_in);
1166         reg = (ep0->dir_in) ? DIEPCTL0 : DOEPCTL0;
1167
1168         /*
1169          * DxEPCTL_Stall will be cleared by EP once it has
1170          * taken effect, so no need to clear later.
1171          */
1172
1173         ctrl = dwc2_readl(hsotg->regs + reg);
1174         ctrl |= DXEPCTL_STALL;
1175         ctrl |= DXEPCTL_CNAK;
1176         dwc2_writel(ctrl, hsotg->regs + reg);
1177
1178         dev_dbg(hsotg->dev,
1179                 "written DXEPCTL=0x%08x to %08x (DXEPCTL=0x%08x)\n",
1180                 ctrl, reg, dwc2_readl(hsotg->regs + reg));
1181
1182          /*
1183           * complete won't be called, so we enqueue
1184           * setup request here
1185           */
1186          dwc2_hsotg_enqueue_setup(hsotg);
1187 }
1188
1189 /**
1190  * dwc2_hsotg_process_control - process a control request
1191  * @hsotg: The device state
1192  * @ctrl: The control request received
1193  *
1194  * The controller has received the SETUP phase of a control request, and
1195  * needs to work out what to do next (and whether to pass it on to the
1196  * gadget driver).
1197  */
1198 static void dwc2_hsotg_process_control(struct dwc2_hsotg *hsotg,
1199                                       struct usb_ctrlrequest *ctrl)
1200 {
1201         struct dwc2_hsotg_ep *ep0 = hsotg->eps_out[0];
1202         int ret = 0;
1203         u32 dcfg;
1204
1205         dev_dbg(hsotg->dev,
1206                 "ctrl Type=%02x, Req=%02x, V=%04x, I=%04x, L=%04x\n",
1207                 ctrl->bRequestType, ctrl->bRequest, ctrl->wValue,
1208                 ctrl->wIndex, ctrl->wLength);
1209
1210         if (ctrl->wLength == 0) {
1211                 ep0->dir_in = 1;
1212                 hsotg->ep0_state = DWC2_EP0_STATUS_IN;
1213         } else if (ctrl->bRequestType & USB_DIR_IN) {
1214                 ep0->dir_in = 1;
1215                 hsotg->ep0_state = DWC2_EP0_DATA_IN;
1216         } else {
1217                 ep0->dir_in = 0;
1218                 hsotg->ep0_state = DWC2_EP0_DATA_OUT;
1219         }
1220
1221         if ((ctrl->bRequestType & USB_TYPE_MASK) == USB_TYPE_STANDARD) {
1222                 switch (ctrl->bRequest) {
1223                 case USB_REQ_SET_ADDRESS:
1224                         hsotg->connected = 1;
1225                         dcfg = dwc2_readl(hsotg->regs + DCFG);
1226                         dcfg &= ~DCFG_DEVADDR_MASK;
1227                         dcfg |= (le16_to_cpu(ctrl->wValue) <<
1228                                  DCFG_DEVADDR_SHIFT) & DCFG_DEVADDR_MASK;
1229                         dwc2_writel(dcfg, hsotg->regs + DCFG);
1230
1231                         dev_info(hsotg->dev, "new address %d\n", ctrl->wValue);
1232
1233                         ret = dwc2_hsotg_send_reply(hsotg, ep0, NULL, 0);
1234                         return;
1235
1236                 case USB_REQ_GET_STATUS:
1237                         ret = dwc2_hsotg_process_req_status(hsotg, ctrl);
1238                         break;
1239
1240                 case USB_REQ_CLEAR_FEATURE:
1241                 case USB_REQ_SET_FEATURE:
1242                         ret = dwc2_hsotg_process_req_feature(hsotg, ctrl);
1243                         break;
1244                 }
1245         }
1246
1247         /* as a fallback, try delivering it to the driver to deal with */
1248
1249         if (ret == 0 && hsotg->driver) {
1250                 spin_unlock(&hsotg->lock);
1251                 ret = hsotg->driver->setup(&hsotg->gadget, ctrl);
1252                 spin_lock(&hsotg->lock);
1253                 if (ret < 0)
1254                         dev_dbg(hsotg->dev, "driver->setup() ret %d\n", ret);
1255         }
1256
1257         /*
1258          * the request is either unhandlable, or is not formatted correctly
1259          * so respond with a STALL for the status stage to indicate failure.
1260          */
1261
1262         if (ret < 0)
1263                 dwc2_hsotg_stall_ep0(hsotg);
1264 }
1265
1266 /**
1267  * dwc2_hsotg_complete_setup - completion of a setup transfer
1268  * @ep: The endpoint the request was on.
1269  * @req: The request completed.
1270  *
1271  * Called on completion of any requests the driver itself submitted for
1272  * EP0 setup packets
1273  */
1274 static void dwc2_hsotg_complete_setup(struct usb_ep *ep,
1275                                      struct usb_request *req)
1276 {
1277         struct dwc2_hsotg_ep *hs_ep = our_ep(ep);
1278         struct dwc2_hsotg *hsotg = hs_ep->parent;
1279
1280         if (req->status < 0) {
1281                 dev_dbg(hsotg->dev, "%s: failed %d\n", __func__, req->status);
1282                 return;
1283         }
1284
1285         spin_lock(&hsotg->lock);
1286         if (req->actual == 0)
1287                 dwc2_hsotg_enqueue_setup(hsotg);
1288         else
1289                 dwc2_hsotg_process_control(hsotg, req->buf);
1290         spin_unlock(&hsotg->lock);
1291 }
1292
1293 /**
1294  * dwc2_hsotg_enqueue_setup - start a request for EP0 packets
1295  * @hsotg: The device state.
1296  *
1297  * Enqueue a request on EP0 if necessary to received any SETUP packets
1298  * received from the host.
1299  */
1300 static void dwc2_hsotg_enqueue_setup(struct dwc2_hsotg *hsotg)
1301 {
1302         struct usb_request *req = hsotg->ctrl_req;
1303         struct dwc2_hsotg_req *hs_req = our_req(req);
1304         int ret;
1305
1306         dev_dbg(hsotg->dev, "%s: queueing setup request\n", __func__);
1307
1308         req->zero = 0;
1309         req->length = 8;
1310         req->buf = hsotg->ctrl_buff;
1311         req->complete = dwc2_hsotg_complete_setup;
1312
1313         if (!list_empty(&hs_req->queue)) {
1314                 dev_dbg(hsotg->dev, "%s already queued???\n", __func__);
1315                 return;
1316         }
1317
1318         hsotg->eps_out[0]->dir_in = 0;
1319         hsotg->eps_out[0]->send_zlp = 0;
1320         hsotg->ep0_state = DWC2_EP0_SETUP;
1321
1322         ret = dwc2_hsotg_ep_queue(&hsotg->eps_out[0]->ep, req, GFP_ATOMIC);
1323         if (ret < 0) {
1324                 dev_err(hsotg->dev, "%s: failed queue (%d)\n", __func__, ret);
1325                 /*
1326                  * Don't think there's much we can do other than watch the
1327                  * driver fail.
1328                  */
1329         }
1330 }
1331
1332 static void dwc2_hsotg_program_zlp(struct dwc2_hsotg *hsotg,
1333                                         struct dwc2_hsotg_ep *hs_ep)
1334 {
1335         u32 ctrl;
1336         u8 index = hs_ep->index;
1337         u32 epctl_reg = hs_ep->dir_in ? DIEPCTL(index) : DOEPCTL(index);
1338         u32 epsiz_reg = hs_ep->dir_in ? DIEPTSIZ(index) : DOEPTSIZ(index);
1339
1340         if (hs_ep->dir_in)
1341                 dev_dbg(hsotg->dev, "Sending zero-length packet on ep%d\n",
1342                                                                         index);
1343         else
1344                 dev_dbg(hsotg->dev, "Receiving zero-length packet on ep%d\n",
1345                                                                         index);
1346
1347         dwc2_writel(DXEPTSIZ_MC(1) | DXEPTSIZ_PKTCNT(1) |
1348                     DXEPTSIZ_XFERSIZE(0), hsotg->regs +
1349                     epsiz_reg);
1350
1351         ctrl = dwc2_readl(hsotg->regs + epctl_reg);
1352         ctrl |= DXEPCTL_CNAK;  /* clear NAK set by core */
1353         ctrl |= DXEPCTL_EPENA; /* ensure ep enabled */
1354         ctrl |= DXEPCTL_USBACTEP;
1355         dwc2_writel(ctrl, hsotg->regs + epctl_reg);
1356 }
1357
1358 /**
1359  * dwc2_hsotg_complete_request - complete a request given to us
1360  * @hsotg: The device state.
1361  * @hs_ep: The endpoint the request was on.
1362  * @hs_req: The request to complete.
1363  * @result: The result code (0 => Ok, otherwise errno)
1364  *
1365  * The given request has finished, so call the necessary completion
1366  * if it has one and then look to see if we can start a new request
1367  * on the endpoint.
1368  *
1369  * Note, expects the ep to already be locked as appropriate.
1370  */
1371 static void dwc2_hsotg_complete_request(struct dwc2_hsotg *hsotg,
1372                                        struct dwc2_hsotg_ep *hs_ep,
1373                                        struct dwc2_hsotg_req *hs_req,
1374                                        int result)
1375 {
1376         bool restart;
1377
1378         if (!hs_req) {
1379                 dev_dbg(hsotg->dev, "%s: nothing to complete?\n", __func__);
1380                 return;
1381         }
1382
1383         dev_dbg(hsotg->dev, "complete: ep %p %s, req %p, %d => %p\n",
1384                 hs_ep, hs_ep->ep.name, hs_req, result, hs_req->req.complete);
1385
1386         /*
1387          * only replace the status if we've not already set an error
1388          * from a previous transaction
1389          */
1390
1391         if (hs_req->req.status == -EINPROGRESS)
1392                 hs_req->req.status = result;
1393
1394         if (using_dma(hsotg))
1395                 dwc2_hsotg_unmap_dma(hsotg, hs_ep, hs_req);
1396
1397         dwc2_hsotg_handle_unaligned_buf_complete(hsotg, hs_ep, hs_req);
1398
1399         hs_ep->req = NULL;
1400         list_del_init(&hs_req->queue);
1401
1402         /*
1403          * call the complete request with the locks off, just in case the
1404          * request tries to queue more work for this endpoint.
1405          */
1406
1407         if (hs_req->req.complete) {
1408                 spin_unlock(&hsotg->lock);
1409                 usb_gadget_giveback_request(&hs_ep->ep, &hs_req->req);
1410                 spin_lock(&hsotg->lock);
1411         }
1412
1413         /*
1414          * Look to see if there is anything else to do. Note, the completion
1415          * of the previous request may have caused a new request to be started
1416          * so be careful when doing this.
1417          */
1418
1419         if (!hs_ep->req && result >= 0) {
1420                 restart = !list_empty(&hs_ep->queue);
1421                 if (restart) {
1422                         hs_req = get_ep_head(hs_ep);
1423                         dwc2_hsotg_start_req(hsotg, hs_ep, hs_req, false);
1424                 }
1425         }
1426 }
1427
1428 /**
1429  * dwc2_hsotg_rx_data - receive data from the FIFO for an endpoint
1430  * @hsotg: The device state.
1431  * @ep_idx: The endpoint index for the data
1432  * @size: The size of data in the fifo, in bytes
1433  *
1434  * The FIFO status shows there is data to read from the FIFO for a given
1435  * endpoint, so sort out whether we need to read the data into a request
1436  * that has been made for that endpoint.
1437  */
1438 static void dwc2_hsotg_rx_data(struct dwc2_hsotg *hsotg, int ep_idx, int size)
1439 {
1440         struct dwc2_hsotg_ep *hs_ep = hsotg->eps_out[ep_idx];
1441         struct dwc2_hsotg_req *hs_req = hs_ep->req;
1442         void __iomem *fifo = hsotg->regs + EPFIFO(ep_idx);
1443         int to_read;
1444         int max_req;
1445         int read_ptr;
1446
1447
1448         if (!hs_req) {
1449                 u32 epctl = dwc2_readl(hsotg->regs + DOEPCTL(ep_idx));
1450                 int ptr;
1451
1452                 dev_dbg(hsotg->dev,
1453                          "%s: FIFO %d bytes on ep%d but no req (DXEPCTl=0x%08x)\n",
1454                          __func__, size, ep_idx, epctl);
1455
1456                 /* dump the data from the FIFO, we've nothing we can do */
1457                 for (ptr = 0; ptr < size; ptr += 4)
1458                         (void)dwc2_readl(fifo);
1459
1460                 return;
1461         }
1462
1463         to_read = size;
1464         read_ptr = hs_req->req.actual;
1465         max_req = hs_req->req.length - read_ptr;
1466
1467         dev_dbg(hsotg->dev, "%s: read %d/%d, done %d/%d\n",
1468                 __func__, to_read, max_req, read_ptr, hs_req->req.length);
1469
1470         if (to_read > max_req) {
1471                 /*
1472                  * more data appeared than we where willing
1473                  * to deal with in this request.
1474                  */
1475
1476                 /* currently we don't deal this */
1477                 WARN_ON_ONCE(1);
1478         }
1479
1480         hs_ep->total_data += to_read;
1481         hs_req->req.actual += to_read;
1482         to_read = DIV_ROUND_UP(to_read, 4);
1483
1484         /*
1485          * note, we might over-write the buffer end by 3 bytes depending on
1486          * alignment of the data.
1487          */
1488         ioread32_rep(fifo, hs_req->req.buf + read_ptr, to_read);
1489 }
1490
1491 /**
1492  * dwc2_hsotg_ep0_zlp - send/receive zero-length packet on control endpoint
1493  * @hsotg: The device instance
1494  * @dir_in: If IN zlp
1495  *
1496  * Generate a zero-length IN packet request for terminating a SETUP
1497  * transaction.
1498  *
1499  * Note, since we don't write any data to the TxFIFO, then it is
1500  * currently believed that we do not need to wait for any space in
1501  * the TxFIFO.
1502  */
1503 static void dwc2_hsotg_ep0_zlp(struct dwc2_hsotg *hsotg, bool dir_in)
1504 {
1505         /* eps_out[0] is used in both directions */
1506         hsotg->eps_out[0]->dir_in = dir_in;
1507         hsotg->ep0_state = dir_in ? DWC2_EP0_STATUS_IN : DWC2_EP0_STATUS_OUT;
1508
1509         dwc2_hsotg_program_zlp(hsotg, hsotg->eps_out[0]);
1510 }
1511
1512 static void dwc2_hsotg_change_ep_iso_parity(struct dwc2_hsotg *hsotg,
1513                         u32 epctl_reg)
1514 {
1515         u32 ctrl;
1516
1517         ctrl = dwc2_readl(hsotg->regs + epctl_reg);
1518         if (ctrl & DXEPCTL_EOFRNUM)
1519                 ctrl |= DXEPCTL_SETEVENFR;
1520         else
1521                 ctrl |= DXEPCTL_SETODDFR;
1522         dwc2_writel(ctrl, hsotg->regs + epctl_reg);
1523 }
1524
1525 /**
1526  * dwc2_hsotg_handle_outdone - handle receiving OutDone/SetupDone from RXFIFO
1527  * @hsotg: The device instance
1528  * @epnum: The endpoint received from
1529  *
1530  * The RXFIFO has delivered an OutDone event, which means that the data
1531  * transfer for an OUT endpoint has been completed, either by a short
1532  * packet or by the finish of a transfer.
1533  */
1534 static void dwc2_hsotg_handle_outdone(struct dwc2_hsotg *hsotg, int epnum)
1535 {
1536         u32 epsize = dwc2_readl(hsotg->regs + DOEPTSIZ(epnum));
1537         struct dwc2_hsotg_ep *hs_ep = hsotg->eps_out[epnum];
1538         struct dwc2_hsotg_req *hs_req = hs_ep->req;
1539         struct usb_request *req = &hs_req->req;
1540         unsigned size_left = DXEPTSIZ_XFERSIZE_GET(epsize);
1541         int result = 0;
1542
1543         if (!hs_req) {
1544                 dev_dbg(hsotg->dev, "%s: no request active\n", __func__);
1545                 return;
1546         }
1547
1548         if (epnum == 0 && hsotg->ep0_state == DWC2_EP0_STATUS_OUT) {
1549                 dev_dbg(hsotg->dev, "zlp packet received\n");
1550                 dwc2_hsotg_complete_request(hsotg, hs_ep, hs_req, 0);
1551                 dwc2_hsotg_enqueue_setup(hsotg);
1552                 return;
1553         }
1554
1555         if (using_dma(hsotg)) {
1556                 unsigned size_done;
1557
1558                 /*
1559                  * Calculate the size of the transfer by checking how much
1560                  * is left in the endpoint size register and then working it
1561                  * out from the amount we loaded for the transfer.
1562                  *
1563                  * We need to do this as DMA pointers are always 32bit aligned
1564                  * so may overshoot/undershoot the transfer.
1565                  */
1566
1567                 size_done = hs_ep->size_loaded - size_left;
1568                 size_done += hs_ep->last_load;
1569
1570                 req->actual = size_done;
1571         }
1572
1573         /* if there is more request to do, schedule new transfer */
1574         if (req->actual < req->length && size_left == 0) {
1575                 dwc2_hsotg_start_req(hsotg, hs_ep, hs_req, true);
1576                 return;
1577         }
1578
1579         if (req->actual < req->length && req->short_not_ok) {
1580                 dev_dbg(hsotg->dev, "%s: got %d/%d (short not ok) => error\n",
1581                         __func__, req->actual, req->length);
1582
1583                 /*
1584                  * todo - what should we return here? there's no one else
1585                  * even bothering to check the status.
1586                  */
1587         }
1588
1589         if (epnum == 0 && hsotg->ep0_state == DWC2_EP0_DATA_OUT) {
1590                 /* Move to STATUS IN */
1591                 dwc2_hsotg_ep0_zlp(hsotg, true);
1592                 return;
1593         }
1594
1595         /*
1596          * Slave mode OUT transfers do not go through XferComplete so
1597          * adjust the ISOC parity here.
1598          */
1599         if (!using_dma(hsotg)) {
1600                 hs_ep->has_correct_parity = 1;
1601                 if (hs_ep->isochronous && hs_ep->interval == 1)
1602                         dwc2_hsotg_change_ep_iso_parity(hsotg, DOEPCTL(epnum));
1603         }
1604
1605         dwc2_hsotg_complete_request(hsotg, hs_ep, hs_req, result);
1606 }
1607
1608 /**
1609  * dwc2_hsotg_read_frameno - read current frame number
1610  * @hsotg: The device instance
1611  *
1612  * Return the current frame number
1613  */
1614 static u32 dwc2_hsotg_read_frameno(struct dwc2_hsotg *hsotg)
1615 {
1616         u32 dsts;
1617
1618         dsts = dwc2_readl(hsotg->regs + DSTS);
1619         dsts &= DSTS_SOFFN_MASK;
1620         dsts >>= DSTS_SOFFN_SHIFT;
1621
1622         return dsts;
1623 }
1624
1625 /**
1626  * dwc2_hsotg_handle_rx - RX FIFO has data
1627  * @hsotg: The device instance
1628  *
1629  * The IRQ handler has detected that the RX FIFO has some data in it
1630  * that requires processing, so find out what is in there and do the
1631  * appropriate read.
1632  *
1633  * The RXFIFO is a true FIFO, the packets coming out are still in packet
1634  * chunks, so if you have x packets received on an endpoint you'll get x
1635  * FIFO events delivered, each with a packet's worth of data in it.
1636  *
1637  * When using DMA, we should not be processing events from the RXFIFO
1638  * as the actual data should be sent to the memory directly and we turn
1639  * on the completion interrupts to get notifications of transfer completion.
1640  */
1641 static void dwc2_hsotg_handle_rx(struct dwc2_hsotg *hsotg)
1642 {
1643         u32 grxstsr = dwc2_readl(hsotg->regs + GRXSTSP);
1644         u32 epnum, status, size;
1645
1646         WARN_ON(using_dma(hsotg));
1647
1648         epnum = grxstsr & GRXSTS_EPNUM_MASK;
1649         status = grxstsr & GRXSTS_PKTSTS_MASK;
1650
1651         size = grxstsr & GRXSTS_BYTECNT_MASK;
1652         size >>= GRXSTS_BYTECNT_SHIFT;
1653
1654         dev_dbg(hsotg->dev, "%s: GRXSTSP=0x%08x (%d@%d)\n",
1655                         __func__, grxstsr, size, epnum);
1656
1657         switch ((status & GRXSTS_PKTSTS_MASK) >> GRXSTS_PKTSTS_SHIFT) {
1658         case GRXSTS_PKTSTS_GLOBALOUTNAK:
1659                 dev_dbg(hsotg->dev, "GLOBALOUTNAK\n");
1660                 break;
1661
1662         case GRXSTS_PKTSTS_OUTDONE:
1663                 dev_dbg(hsotg->dev, "OutDone (Frame=0x%08x)\n",
1664                         dwc2_hsotg_read_frameno(hsotg));
1665
1666                 if (!using_dma(hsotg))
1667                         dwc2_hsotg_handle_outdone(hsotg, epnum);
1668                 break;
1669
1670         case GRXSTS_PKTSTS_SETUPDONE:
1671                 dev_dbg(hsotg->dev,
1672                         "SetupDone (Frame=0x%08x, DOPEPCTL=0x%08x)\n",
1673                         dwc2_hsotg_read_frameno(hsotg),
1674                         dwc2_readl(hsotg->regs + DOEPCTL(0)));
1675                 /*
1676                  * Call dwc2_hsotg_handle_outdone here if it was not called from
1677                  * GRXSTS_PKTSTS_OUTDONE. That is, if the core didn't
1678                  * generate GRXSTS_PKTSTS_OUTDONE for setup packet.
1679                  */
1680                 if (hsotg->ep0_state == DWC2_EP0_SETUP)
1681                         dwc2_hsotg_handle_outdone(hsotg, epnum);
1682                 break;
1683
1684         case GRXSTS_PKTSTS_OUTRX:
1685                 dwc2_hsotg_rx_data(hsotg, epnum, size);
1686                 break;
1687
1688         case GRXSTS_PKTSTS_SETUPRX:
1689                 dev_dbg(hsotg->dev,
1690                         "SetupRX (Frame=0x%08x, DOPEPCTL=0x%08x)\n",
1691                         dwc2_hsotg_read_frameno(hsotg),
1692                         dwc2_readl(hsotg->regs + DOEPCTL(0)));
1693
1694                 WARN_ON(hsotg->ep0_state != DWC2_EP0_SETUP);
1695
1696                 dwc2_hsotg_rx_data(hsotg, epnum, size);
1697                 break;
1698
1699         default:
1700                 dev_warn(hsotg->dev, "%s: unknown status %08x\n",
1701                          __func__, grxstsr);
1702
1703                 dwc2_hsotg_dump(hsotg);
1704                 break;
1705         }
1706 }
1707
1708 /**
1709  * dwc2_hsotg_ep0_mps - turn max packet size into register setting
1710  * @mps: The maximum packet size in bytes.
1711  */
1712 static u32 dwc2_hsotg_ep0_mps(unsigned int mps)
1713 {
1714         switch (mps) {
1715         case 64:
1716                 return D0EPCTL_MPS_64;
1717         case 32:
1718                 return D0EPCTL_MPS_32;
1719         case 16:
1720                 return D0EPCTL_MPS_16;
1721         case 8:
1722                 return D0EPCTL_MPS_8;
1723         }
1724
1725         /* bad max packet size, warn and return invalid result */
1726         WARN_ON(1);
1727         return (u32)-1;
1728 }
1729
1730 /**
1731  * dwc2_hsotg_set_ep_maxpacket - set endpoint's max-packet field
1732  * @hsotg: The driver state.
1733  * @ep: The index number of the endpoint
1734  * @mps: The maximum packet size in bytes
1735  *
1736  * Configure the maximum packet size for the given endpoint, updating
1737  * the hardware control registers to reflect this.
1738  */
1739 static void dwc2_hsotg_set_ep_maxpacket(struct dwc2_hsotg *hsotg,
1740                         unsigned int ep, unsigned int mps, unsigned int dir_in)
1741 {
1742         struct dwc2_hsotg_ep *hs_ep;
1743         void __iomem *regs = hsotg->regs;
1744         u32 mpsval;
1745         u32 mcval;
1746         u32 reg;
1747
1748         hs_ep = index_to_ep(hsotg, ep, dir_in);
1749         if (!hs_ep)
1750                 return;
1751
1752         if (ep == 0) {
1753                 /* EP0 is a special case */
1754                 mpsval = dwc2_hsotg_ep0_mps(mps);
1755                 if (mpsval > 3)
1756                         goto bad_mps;
1757                 hs_ep->ep.maxpacket = mps;
1758                 hs_ep->mc = 1;
1759         } else {
1760                 mpsval = mps & DXEPCTL_MPS_MASK;
1761                 if (mpsval > 1024)
1762                         goto bad_mps;
1763                 mcval = ((mps >> 11) & 0x3) + 1;
1764                 hs_ep->mc = mcval;
1765                 if (mcval > 3)
1766                         goto bad_mps;
1767                 hs_ep->ep.maxpacket = mpsval;
1768         }
1769
1770         if (dir_in) {
1771                 reg = dwc2_readl(regs + DIEPCTL(ep));
1772                 reg &= ~DXEPCTL_MPS_MASK;
1773                 reg |= mpsval;
1774                 dwc2_writel(reg, regs + DIEPCTL(ep));
1775         } else {
1776                 reg = dwc2_readl(regs + DOEPCTL(ep));
1777                 reg &= ~DXEPCTL_MPS_MASK;
1778                 reg |= mpsval;
1779                 dwc2_writel(reg, regs + DOEPCTL(ep));
1780         }
1781
1782         return;
1783
1784 bad_mps:
1785         dev_err(hsotg->dev, "ep%d: bad mps of %d\n", ep, mps);
1786 }
1787
1788 /**
1789  * dwc2_hsotg_txfifo_flush - flush Tx FIFO
1790  * @hsotg: The driver state
1791  * @idx: The index for the endpoint (0..15)
1792  */
1793 static void dwc2_hsotg_txfifo_flush(struct dwc2_hsotg *hsotg, unsigned int idx)
1794 {
1795         int timeout;
1796         int val;
1797
1798         dwc2_writel(GRSTCTL_TXFNUM(idx) | GRSTCTL_TXFFLSH,
1799                     hsotg->regs + GRSTCTL);
1800
1801         /* wait until the fifo is flushed */
1802         timeout = 100;
1803
1804         while (1) {
1805                 val = dwc2_readl(hsotg->regs + GRSTCTL);
1806
1807                 if ((val & (GRSTCTL_TXFFLSH)) == 0)
1808                         break;
1809
1810                 if (--timeout == 0) {
1811                         dev_err(hsotg->dev,
1812                                 "%s: timeout flushing fifo (GRSTCTL=%08x)\n",
1813                                 __func__, val);
1814                         break;
1815                 }
1816
1817                 udelay(1);
1818         }
1819 }
1820
1821 /**
1822  * dwc2_hsotg_trytx - check to see if anything needs transmitting
1823  * @hsotg: The driver state
1824  * @hs_ep: The driver endpoint to check.
1825  *
1826  * Check to see if there is a request that has data to send, and if so
1827  * make an attempt to write data into the FIFO.
1828  */
1829 static int dwc2_hsotg_trytx(struct dwc2_hsotg *hsotg,
1830                            struct dwc2_hsotg_ep *hs_ep)
1831 {
1832         struct dwc2_hsotg_req *hs_req = hs_ep->req;
1833
1834         if (!hs_ep->dir_in || !hs_req) {
1835                 /**
1836                  * if request is not enqueued, we disable interrupts
1837                  * for endpoints, excepting ep0
1838                  */
1839                 if (hs_ep->index != 0)
1840                         dwc2_hsotg_ctrl_epint(hsotg, hs_ep->index,
1841                                              hs_ep->dir_in, 0);
1842                 return 0;
1843         }
1844
1845         if (hs_req->req.actual < hs_req->req.length) {
1846                 dev_dbg(hsotg->dev, "trying to write more for ep%d\n",
1847                         hs_ep->index);
1848                 return dwc2_hsotg_write_fifo(hsotg, hs_ep, hs_req);
1849         }
1850
1851         return 0;
1852 }
1853
1854 /**
1855  * dwc2_hsotg_complete_in - complete IN transfer
1856  * @hsotg: The device state.
1857  * @hs_ep: The endpoint that has just completed.
1858  *
1859  * An IN transfer has been completed, update the transfer's state and then
1860  * call the relevant completion routines.
1861  */
1862 static void dwc2_hsotg_complete_in(struct dwc2_hsotg *hsotg,
1863                                   struct dwc2_hsotg_ep *hs_ep)
1864 {
1865         struct dwc2_hsotg_req *hs_req = hs_ep->req;
1866         u32 epsize = dwc2_readl(hsotg->regs + DIEPTSIZ(hs_ep->index));
1867         int size_left, size_done;
1868
1869         if (!hs_req) {
1870                 dev_dbg(hsotg->dev, "XferCompl but no req\n");
1871                 return;
1872         }
1873
1874         /* Finish ZLP handling for IN EP0 transactions */
1875         if (hs_ep->index == 0 && hsotg->ep0_state == DWC2_EP0_STATUS_IN) {
1876                 dev_dbg(hsotg->dev, "zlp packet sent\n");
1877                 dwc2_hsotg_complete_request(hsotg, hs_ep, hs_req, 0);
1878                 if (hsotg->test_mode) {
1879                         int ret;
1880
1881                         ret = dwc2_hsotg_set_test_mode(hsotg, hsotg->test_mode);
1882                         if (ret < 0) {
1883                                 dev_dbg(hsotg->dev, "Invalid Test #%d\n",
1884                                                 hsotg->test_mode);
1885                                 dwc2_hsotg_stall_ep0(hsotg);
1886                                 return;
1887                         }
1888                 }
1889                 dwc2_hsotg_enqueue_setup(hsotg);
1890                 return;
1891         }
1892
1893         /*
1894          * Calculate the size of the transfer by checking how much is left
1895          * in the endpoint size register and then working it out from
1896          * the amount we loaded for the transfer.
1897          *
1898          * We do this even for DMA, as the transfer may have incremented
1899          * past the end of the buffer (DMA transfers are always 32bit
1900          * aligned).
1901          */
1902
1903         size_left = DXEPTSIZ_XFERSIZE_GET(epsize);
1904
1905         size_done = hs_ep->size_loaded - size_left;
1906         size_done += hs_ep->last_load;
1907
1908         if (hs_req->req.actual != size_done)
1909                 dev_dbg(hsotg->dev, "%s: adjusting size done %d => %d\n",
1910                         __func__, hs_req->req.actual, size_done);
1911
1912         hs_req->req.actual = size_done;
1913         dev_dbg(hsotg->dev, "req->length:%d req->actual:%d req->zero:%d\n",
1914                 hs_req->req.length, hs_req->req.actual, hs_req->req.zero);
1915
1916         if (!size_left && hs_req->req.actual < hs_req->req.length) {
1917                 dev_dbg(hsotg->dev, "%s trying more for req...\n", __func__);
1918                 dwc2_hsotg_start_req(hsotg, hs_ep, hs_req, true);
1919                 return;
1920         }
1921
1922         /* Zlp for all endpoints, for ep0 only in DATA IN stage */
1923         if (hs_ep->send_zlp) {
1924                 dwc2_hsotg_program_zlp(hsotg, hs_ep);
1925                 hs_ep->send_zlp = 0;
1926                 /* transfer will be completed on next complete interrupt */
1927                 return;
1928         }
1929
1930         if (hs_ep->index == 0 && hsotg->ep0_state == DWC2_EP0_DATA_IN) {
1931                 /* Move to STATUS OUT */
1932                 dwc2_hsotg_ep0_zlp(hsotg, false);
1933                 return;
1934         }
1935
1936         dwc2_hsotg_complete_request(hsotg, hs_ep, hs_req, 0);
1937 }
1938
1939 /**
1940  * dwc2_hsotg_epint - handle an in/out endpoint interrupt
1941  * @hsotg: The driver state
1942  * @idx: The index for the endpoint (0..15)
1943  * @dir_in: Set if this is an IN endpoint
1944  *
1945  * Process and clear any interrupt pending for an individual endpoint
1946  */
1947 static void dwc2_hsotg_epint(struct dwc2_hsotg *hsotg, unsigned int idx,
1948                             int dir_in)
1949 {
1950         struct dwc2_hsotg_ep *hs_ep = index_to_ep(hsotg, idx, dir_in);
1951         u32 epint_reg = dir_in ? DIEPINT(idx) : DOEPINT(idx);
1952         u32 epctl_reg = dir_in ? DIEPCTL(idx) : DOEPCTL(idx);
1953         u32 epsiz_reg = dir_in ? DIEPTSIZ(idx) : DOEPTSIZ(idx);
1954         u32 ints;
1955         u32 ctrl;
1956
1957         ints = dwc2_readl(hsotg->regs + epint_reg);
1958         ctrl = dwc2_readl(hsotg->regs + epctl_reg);
1959
1960         /* Clear endpoint interrupts */
1961         dwc2_writel(ints, hsotg->regs + epint_reg);
1962
1963         if (!hs_ep) {
1964                 dev_err(hsotg->dev, "%s:Interrupt for unconfigured ep%d(%s)\n",
1965                                         __func__, idx, dir_in ? "in" : "out");
1966                 return;
1967         }
1968
1969         dev_dbg(hsotg->dev, "%s: ep%d(%s) DxEPINT=0x%08x\n",
1970                 __func__, idx, dir_in ? "in" : "out", ints);
1971
1972         /* Don't process XferCompl interrupt if it is a setup packet */
1973         if (idx == 0 && (ints & (DXEPINT_SETUP | DXEPINT_SETUP_RCVD)))
1974                 ints &= ~DXEPINT_XFERCOMPL;
1975
1976         if (ints & DXEPINT_XFERCOMPL) {
1977                 hs_ep->has_correct_parity = 1;
1978                 if (hs_ep->isochronous && hs_ep->interval == 1)
1979                         dwc2_hsotg_change_ep_iso_parity(hsotg, epctl_reg);
1980
1981                 dev_dbg(hsotg->dev,
1982                         "%s: XferCompl: DxEPCTL=0x%08x, DXEPTSIZ=%08x\n",
1983                         __func__, dwc2_readl(hsotg->regs + epctl_reg),
1984                         dwc2_readl(hsotg->regs + epsiz_reg));
1985
1986                 /*
1987                  * we get OutDone from the FIFO, so we only need to look
1988                  * at completing IN requests here
1989                  */
1990                 if (dir_in) {
1991                         dwc2_hsotg_complete_in(hsotg, hs_ep);
1992
1993                         if (idx == 0 && !hs_ep->req)
1994                                 dwc2_hsotg_enqueue_setup(hsotg);
1995                 } else if (using_dma(hsotg)) {
1996                         /*
1997                          * We're using DMA, we need to fire an OutDone here
1998                          * as we ignore the RXFIFO.
1999                          */
2000
2001                         dwc2_hsotg_handle_outdone(hsotg, idx);
2002                 }
2003         }
2004
2005         if (ints & DXEPINT_EPDISBLD) {
2006                 dev_dbg(hsotg->dev, "%s: EPDisbld\n", __func__);
2007
2008                 if (dir_in) {
2009                         int epctl = dwc2_readl(hsotg->regs + epctl_reg);
2010
2011                         dwc2_hsotg_txfifo_flush(hsotg, hs_ep->fifo_index);
2012
2013                         if ((epctl & DXEPCTL_STALL) &&
2014                                 (epctl & DXEPCTL_EPTYPE_BULK)) {
2015                                 int dctl = dwc2_readl(hsotg->regs + DCTL);
2016
2017                                 dctl |= DCTL_CGNPINNAK;
2018                                 dwc2_writel(dctl, hsotg->regs + DCTL);
2019                         }
2020                 }
2021         }
2022
2023         if (ints & DXEPINT_AHBERR)
2024                 dev_dbg(hsotg->dev, "%s: AHBErr\n", __func__);
2025
2026         if (ints & DXEPINT_SETUP) {  /* Setup or Timeout */
2027                 dev_dbg(hsotg->dev, "%s: Setup/Timeout\n",  __func__);
2028
2029                 if (using_dma(hsotg) && idx == 0) {
2030                         /*
2031                          * this is the notification we've received a
2032                          * setup packet. In non-DMA mode we'd get this
2033                          * from the RXFIFO, instead we need to process
2034                          * the setup here.
2035                          */
2036
2037                         if (dir_in)
2038                                 WARN_ON_ONCE(1);
2039                         else
2040                                 dwc2_hsotg_handle_outdone(hsotg, 0);
2041                 }
2042         }
2043
2044         if (ints & DXEPINT_BACK2BACKSETUP)
2045                 dev_dbg(hsotg->dev, "%s: B2BSetup/INEPNakEff\n", __func__);
2046
2047         if (dir_in && !hs_ep->isochronous) {
2048                 /* not sure if this is important, but we'll clear it anyway */
2049                 if (ints & DIEPMSK_INTKNTXFEMPMSK) {
2050                         dev_dbg(hsotg->dev, "%s: ep%d: INTknTXFEmpMsk\n",
2051                                 __func__, idx);
2052                 }
2053
2054                 /* this probably means something bad is happening */
2055                 if (ints & DIEPMSK_INTKNEPMISMSK) {
2056                         dev_warn(hsotg->dev, "%s: ep%d: INTknEP\n",
2057                                  __func__, idx);
2058                 }
2059
2060                 /* FIFO has space or is empty (see GAHBCFG) */
2061                 if (hsotg->dedicated_fifos &&
2062                     ints & DIEPMSK_TXFIFOEMPTY) {
2063                         dev_dbg(hsotg->dev, "%s: ep%d: TxFIFOEmpty\n",
2064                                 __func__, idx);
2065                         if (!using_dma(hsotg))
2066                                 dwc2_hsotg_trytx(hsotg, hs_ep);
2067                 }
2068         }
2069 }
2070
2071 /**
2072  * dwc2_hsotg_irq_enumdone - Handle EnumDone interrupt (enumeration done)
2073  * @hsotg: The device state.
2074  *
2075  * Handle updating the device settings after the enumeration phase has
2076  * been completed.
2077  */
2078 static void dwc2_hsotg_irq_enumdone(struct dwc2_hsotg *hsotg)
2079 {
2080         u32 dsts = dwc2_readl(hsotg->regs + DSTS);
2081         int ep0_mps = 0, ep_mps = 8;
2082
2083         /*
2084          * This should signal the finish of the enumeration phase
2085          * of the USB handshaking, so we should now know what rate
2086          * we connected at.
2087          */
2088
2089         dev_dbg(hsotg->dev, "EnumDone (DSTS=0x%08x)\n", dsts);
2090
2091         /*
2092          * note, since we're limited by the size of transfer on EP0, and
2093          * it seems IN transfers must be a even number of packets we do
2094          * not advertise a 64byte MPS on EP0.
2095          */
2096
2097         /* catch both EnumSpd_FS and EnumSpd_FS48 */
2098         switch (dsts & DSTS_ENUMSPD_MASK) {
2099         case DSTS_ENUMSPD_FS:
2100         case DSTS_ENUMSPD_FS48:
2101                 hsotg->gadget.speed = USB_SPEED_FULL;
2102                 ep0_mps = EP0_MPS_LIMIT;
2103                 ep_mps = 1023;
2104                 break;
2105
2106         case DSTS_ENUMSPD_HS:
2107                 hsotg->gadget.speed = USB_SPEED_HIGH;
2108                 ep0_mps = EP0_MPS_LIMIT;
2109                 ep_mps = 1024;
2110                 break;
2111
2112         case DSTS_ENUMSPD_LS:
2113                 hsotg->gadget.speed = USB_SPEED_LOW;
2114                 /*
2115                  * note, we don't actually support LS in this driver at the
2116                  * moment, and the documentation seems to imply that it isn't
2117                  * supported by the PHYs on some of the devices.
2118                  */
2119                 break;
2120         }
2121         dev_info(hsotg->dev, "new device is %s\n",
2122                  usb_speed_string(hsotg->gadget.speed));
2123
2124         /*
2125          * we should now know the maximum packet size for an
2126          * endpoint, so set the endpoints to a default value.
2127          */
2128
2129         if (ep0_mps) {
2130                 int i;
2131                 /* Initialize ep0 for both in and out directions */
2132                 dwc2_hsotg_set_ep_maxpacket(hsotg, 0, ep0_mps, 1);
2133                 dwc2_hsotg_set_ep_maxpacket(hsotg, 0, ep0_mps, 0);
2134                 for (i = 1; i < hsotg->num_of_eps; i++) {
2135                         if (hsotg->eps_in[i])
2136                                 dwc2_hsotg_set_ep_maxpacket(hsotg, i, ep_mps, 1);
2137                         if (hsotg->eps_out[i])
2138                                 dwc2_hsotg_set_ep_maxpacket(hsotg, i, ep_mps, 0);
2139                 }
2140         }
2141
2142         /* ensure after enumeration our EP0 is active */
2143
2144         dwc2_hsotg_enqueue_setup(hsotg);
2145
2146         dev_dbg(hsotg->dev, "EP0: DIEPCTL0=0x%08x, DOEPCTL0=0x%08x\n",
2147                 dwc2_readl(hsotg->regs + DIEPCTL0),
2148                 dwc2_readl(hsotg->regs + DOEPCTL0));
2149 }
2150
2151 /**
2152  * kill_all_requests - remove all requests from the endpoint's queue
2153  * @hsotg: The device state.
2154  * @ep: The endpoint the requests may be on.
2155  * @result: The result code to use.
2156  *
2157  * Go through the requests on the given endpoint and mark them
2158  * completed with the given result code.
2159  */
2160 static void kill_all_requests(struct dwc2_hsotg *hsotg,
2161                               struct dwc2_hsotg_ep *ep,
2162                               int result)
2163 {
2164         struct dwc2_hsotg_req *req, *treq;
2165         unsigned size;
2166
2167         ep->req = NULL;
2168
2169         list_for_each_entry_safe(req, treq, &ep->queue, queue)
2170                 dwc2_hsotg_complete_request(hsotg, ep, req,
2171                                            result);
2172
2173         if (!hsotg->dedicated_fifos)
2174                 return;
2175         size = (dwc2_readl(hsotg->regs + DTXFSTS(ep->index)) & 0xffff) * 4;
2176         if (size < ep->fifo_size)
2177                 dwc2_hsotg_txfifo_flush(hsotg, ep->fifo_index);
2178 }
2179
2180 /**
2181  * dwc2_hsotg_disconnect - disconnect service
2182  * @hsotg: The device state.
2183  *
2184  * The device has been disconnected. Remove all current
2185  * transactions and signal the gadget driver that this
2186  * has happened.
2187  */
2188 void dwc2_hsotg_disconnect(struct dwc2_hsotg *hsotg)
2189 {
2190         unsigned ep;
2191
2192         if (!hsotg->connected)
2193                 return;
2194
2195         hsotg->connected = 0;
2196         hsotg->test_mode = 0;
2197
2198         for (ep = 0; ep < hsotg->num_of_eps; ep++) {
2199                 if (hsotg->eps_in[ep])
2200                         kill_all_requests(hsotg, hsotg->eps_in[ep],
2201                                                                 -ESHUTDOWN);
2202                 if (hsotg->eps_out[ep])
2203                         kill_all_requests(hsotg, hsotg->eps_out[ep],
2204                                                                 -ESHUTDOWN);
2205         }
2206
2207         call_gadget(hsotg, disconnect);
2208         hsotg->lx_state = DWC2_L3;
2209 }
2210
2211 /**
2212  * dwc2_hsotg_irq_fifoempty - TX FIFO empty interrupt handler
2213  * @hsotg: The device state:
2214  * @periodic: True if this is a periodic FIFO interrupt
2215  */
2216 static void dwc2_hsotg_irq_fifoempty(struct dwc2_hsotg *hsotg, bool periodic)
2217 {
2218         struct dwc2_hsotg_ep *ep;
2219         int epno, ret;
2220
2221         /* look through for any more data to transmit */
2222         for (epno = 0; epno < hsotg->num_of_eps; epno++) {
2223                 ep = index_to_ep(hsotg, epno, 1);
2224
2225                 if (!ep)
2226                         continue;
2227
2228                 if (!ep->dir_in)
2229                         continue;
2230
2231                 if ((periodic && !ep->periodic) ||
2232                     (!periodic && ep->periodic))
2233                         continue;
2234
2235                 ret = dwc2_hsotg_trytx(hsotg, ep);
2236                 if (ret < 0)
2237                         break;
2238         }
2239 }
2240
2241 /* IRQ flags which will trigger a retry around the IRQ loop */
2242 #define IRQ_RETRY_MASK (GINTSTS_NPTXFEMP | \
2243                         GINTSTS_PTXFEMP |  \
2244                         GINTSTS_RXFLVL)
2245
2246 /**
2247  * dwc2_hsotg_corereset - issue softreset to the core
2248  * @hsotg: The device state
2249  *
2250  * Issue a soft reset to the core, and await the core finishing it.
2251  */
2252 static int dwc2_hsotg_corereset(struct dwc2_hsotg *hsotg)
2253 {
2254         int timeout;
2255         u32 grstctl;
2256
2257         dev_dbg(hsotg->dev, "resetting core\n");
2258
2259         /* issue soft reset */
2260         dwc2_writel(GRSTCTL_CSFTRST, hsotg->regs + GRSTCTL);
2261
2262         timeout = 10000;
2263         do {
2264                 grstctl = dwc2_readl(hsotg->regs + GRSTCTL);
2265         } while ((grstctl & GRSTCTL_CSFTRST) && timeout-- > 0);
2266
2267         if (grstctl & GRSTCTL_CSFTRST) {
2268                 dev_err(hsotg->dev, "Failed to get CSftRst asserted\n");
2269                 return -EINVAL;
2270         }
2271
2272         timeout = 10000;
2273
2274         while (1) {
2275                 u32 grstctl = dwc2_readl(hsotg->regs + GRSTCTL);
2276
2277                 if (timeout-- < 0) {
2278                         dev_info(hsotg->dev,
2279                                  "%s: reset failed, GRSTCTL=%08x\n",
2280                                  __func__, grstctl);
2281                         return -ETIMEDOUT;
2282                 }
2283
2284                 if (!(grstctl & GRSTCTL_AHBIDLE))
2285                         continue;
2286
2287                 break;          /* reset done */
2288         }
2289
2290         dev_dbg(hsotg->dev, "reset successful\n");
2291         return 0;
2292 }
2293
2294 /**
2295  * dwc2_hsotg_core_init - issue softreset to the core
2296  * @hsotg: The device state
2297  *
2298  * Issue a soft reset to the core, and await the core finishing it.
2299  */
2300 void dwc2_hsotg_core_init_disconnected(struct dwc2_hsotg *hsotg,
2301                                                 bool is_usb_reset)
2302 {
2303         u32 intmsk;
2304         u32 val;
2305
2306         /* Kill any ep0 requests as controller will be reinitialized */
2307         kill_all_requests(hsotg, hsotg->eps_out[0], -ECONNRESET);
2308
2309         if (!is_usb_reset)
2310                 if (dwc2_hsotg_corereset(hsotg))
2311                         return;
2312
2313         /*
2314          * we must now enable ep0 ready for host detection and then
2315          * set configuration.
2316          */
2317
2318         /* set the PLL on, remove the HNP/SRP and set the PHY */
2319         val = (hsotg->phyif == GUSBCFG_PHYIF8) ? 9 : 5;
2320         dwc2_writel(hsotg->phyif | GUSBCFG_TOUTCAL(7) |
2321                (val << GUSBCFG_USBTRDTIM_SHIFT), hsotg->regs + GUSBCFG);
2322
2323         dwc2_hsotg_init_fifo(hsotg);
2324
2325         if (!is_usb_reset)
2326                 __orr32(hsotg->regs + DCTL, DCTL_SFTDISCON);
2327
2328         dwc2_writel(DCFG_EPMISCNT(1) | DCFG_DEVSPD_HS,  hsotg->regs + DCFG);
2329
2330         /* Clear any pending OTG interrupts */
2331         dwc2_writel(0xffffffff, hsotg->regs + GOTGINT);
2332
2333         /* Clear any pending interrupts */
2334         dwc2_writel(0xffffffff, hsotg->regs + GINTSTS);
2335         intmsk = GINTSTS_ERLYSUSP | GINTSTS_SESSREQINT |
2336                 GINTSTS_GOUTNAKEFF | GINTSTS_GINNAKEFF |
2337                 GINTSTS_USBRST | GINTSTS_RESETDET |
2338                 GINTSTS_ENUMDONE | GINTSTS_OTGINT |
2339                 GINTSTS_USBSUSP | GINTSTS_WKUPINT |
2340                 GINTSTS_INCOMPL_SOIN | GINTSTS_INCOMPL_SOOUT;
2341
2342         if (hsotg->core_params->external_id_pin_ctl <= 0)
2343                 intmsk |= GINTSTS_CONIDSTSCHNG;
2344
2345         dwc2_writel(intmsk, hsotg->regs + GINTMSK);
2346
2347         if (using_dma(hsotg))
2348                 dwc2_writel(GAHBCFG_GLBL_INTR_EN | GAHBCFG_DMA_EN |
2349                             (GAHBCFG_HBSTLEN_INCR4 << GAHBCFG_HBSTLEN_SHIFT),
2350                             hsotg->regs + GAHBCFG);
2351         else
2352                 dwc2_writel(((hsotg->dedicated_fifos) ?
2353                                                 (GAHBCFG_NP_TXF_EMP_LVL |
2354                                                  GAHBCFG_P_TXF_EMP_LVL) : 0) |
2355                             GAHBCFG_GLBL_INTR_EN, hsotg->regs + GAHBCFG);
2356
2357         /*
2358          * If INTknTXFEmpMsk is enabled, it's important to disable ep interrupts
2359          * when we have no data to transfer. Otherwise we get being flooded by
2360          * interrupts.
2361          */
2362
2363         dwc2_writel(((hsotg->dedicated_fifos && !using_dma(hsotg)) ?
2364                 DIEPMSK_TXFIFOEMPTY | DIEPMSK_INTKNTXFEMPMSK : 0) |
2365                 DIEPMSK_EPDISBLDMSK | DIEPMSK_XFERCOMPLMSK |
2366                 DIEPMSK_TIMEOUTMSK | DIEPMSK_AHBERRMSK |
2367                 DIEPMSK_INTKNEPMISMSK,
2368                 hsotg->regs + DIEPMSK);
2369
2370         /*
2371          * don't need XferCompl, we get that from RXFIFO in slave mode. In
2372          * DMA mode we may need this.
2373          */
2374         dwc2_writel((using_dma(hsotg) ? (DIEPMSK_XFERCOMPLMSK |
2375                                     DIEPMSK_TIMEOUTMSK) : 0) |
2376                 DOEPMSK_EPDISBLDMSK | DOEPMSK_AHBERRMSK |
2377                 DOEPMSK_SETUPMSK,
2378                 hsotg->regs + DOEPMSK);
2379
2380         dwc2_writel(0, hsotg->regs + DAINTMSK);
2381
2382         dev_dbg(hsotg->dev, "EP0: DIEPCTL0=0x%08x, DOEPCTL0=0x%08x\n",
2383                 dwc2_readl(hsotg->regs + DIEPCTL0),
2384                 dwc2_readl(hsotg->regs + DOEPCTL0));
2385
2386         /* enable in and out endpoint interrupts */
2387         dwc2_hsotg_en_gsint(hsotg, GINTSTS_OEPINT | GINTSTS_IEPINT);
2388
2389         /*
2390          * Enable the RXFIFO when in slave mode, as this is how we collect
2391          * the data. In DMA mode, we get events from the FIFO but also
2392          * things we cannot process, so do not use it.
2393          */
2394         if (!using_dma(hsotg))
2395                 dwc2_hsotg_en_gsint(hsotg, GINTSTS_RXFLVL);
2396
2397         /* Enable interrupts for EP0 in and out */
2398         dwc2_hsotg_ctrl_epint(hsotg, 0, 0, 1);
2399         dwc2_hsotg_ctrl_epint(hsotg, 0, 1, 1);
2400
2401         if (!is_usb_reset) {
2402                 __orr32(hsotg->regs + DCTL, DCTL_PWRONPRGDONE);
2403                 udelay(10);  /* see openiboot */
2404                 __bic32(hsotg->regs + DCTL, DCTL_PWRONPRGDONE);
2405         }
2406
2407         dev_dbg(hsotg->dev, "DCTL=0x%08x\n", dwc2_readl(hsotg->regs + DCTL));
2408
2409         /*
2410          * DxEPCTL_USBActEp says RO in manual, but seems to be set by
2411          * writing to the EPCTL register..
2412          */
2413
2414         /* set to read 1 8byte packet */
2415         dwc2_writel(DXEPTSIZ_MC(1) | DXEPTSIZ_PKTCNT(1) |
2416                DXEPTSIZ_XFERSIZE(8), hsotg->regs + DOEPTSIZ0);
2417
2418         dwc2_writel(dwc2_hsotg_ep0_mps(hsotg->eps_out[0]->ep.maxpacket) |
2419                DXEPCTL_CNAK | DXEPCTL_EPENA |
2420                DXEPCTL_USBACTEP,
2421                hsotg->regs + DOEPCTL0);
2422
2423         /* enable, but don't activate EP0in */
2424         dwc2_writel(dwc2_hsotg_ep0_mps(hsotg->eps_out[0]->ep.maxpacket) |
2425                DXEPCTL_USBACTEP, hsotg->regs + DIEPCTL0);
2426
2427         dwc2_hsotg_enqueue_setup(hsotg);
2428
2429         dev_dbg(hsotg->dev, "EP0: DIEPCTL0=0x%08x, DOEPCTL0=0x%08x\n",
2430                 dwc2_readl(hsotg->regs + DIEPCTL0),
2431                 dwc2_readl(hsotg->regs + DOEPCTL0));
2432
2433         /* clear global NAKs */
2434         val = DCTL_CGOUTNAK | DCTL_CGNPINNAK;
2435         if (!is_usb_reset)
2436                 val |= DCTL_SFTDISCON;
2437         __orr32(hsotg->regs + DCTL, val);
2438
2439         /* must be at-least 3ms to allow bus to see disconnect */
2440         mdelay(3);
2441
2442         hsotg->lx_state = DWC2_L0;
2443 }
2444
2445 static void dwc2_hsotg_core_disconnect(struct dwc2_hsotg *hsotg)
2446 {
2447         /* set the soft-disconnect bit */
2448         __orr32(hsotg->regs + DCTL, DCTL_SFTDISCON);
2449 }
2450
2451 void dwc2_hsotg_core_connect(struct dwc2_hsotg *hsotg)
2452 {
2453         /* remove the soft-disconnect and let's go */
2454         __bic32(hsotg->regs + DCTL, DCTL_SFTDISCON);
2455 }
2456
2457 /**
2458  * dwc2_hsotg_irq - handle device interrupt
2459  * @irq: The IRQ number triggered
2460  * @pw: The pw value when registered the handler.
2461  */
2462 static irqreturn_t dwc2_hsotg_irq(int irq, void *pw)
2463 {
2464         struct dwc2_hsotg *hsotg = pw;
2465         int retry_count = 8;
2466         u32 gintsts;
2467         u32 gintmsk;
2468
2469         spin_lock(&hsotg->lock);
2470 irq_retry:
2471         gintsts = dwc2_readl(hsotg->regs + GINTSTS);
2472         gintmsk = dwc2_readl(hsotg->regs + GINTMSK);
2473
2474         dev_dbg(hsotg->dev, "%s: %08x %08x (%08x) retry %d\n",
2475                 __func__, gintsts, gintsts & gintmsk, gintmsk, retry_count);
2476
2477         gintsts &= gintmsk;
2478
2479         if (gintsts & GINTSTS_RESETDET) {
2480                 dev_dbg(hsotg->dev, "%s: USBRstDet\n", __func__);
2481
2482                 dwc2_writel(GINTSTS_RESETDET, hsotg->regs + GINTSTS);
2483
2484                 /* This event must be used only if controller is suspended */
2485                 if (hsotg->lx_state == DWC2_L2) {
2486                         dwc2_exit_hibernation(hsotg, true);
2487                         hsotg->lx_state = DWC2_L0;
2488                 }
2489         }
2490
2491         if (gintsts & (GINTSTS_USBRST | GINTSTS_RESETDET)) {
2492
2493                 u32 usb_status = dwc2_readl(hsotg->regs + GOTGCTL);
2494                 u32 connected = hsotg->connected;
2495
2496                 dev_dbg(hsotg->dev, "%s: USBRst\n", __func__);
2497                 dev_dbg(hsotg->dev, "GNPTXSTS=%08x\n",
2498                         dwc2_readl(hsotg->regs + GNPTXSTS));
2499
2500                 dwc2_writel(GINTSTS_USBRST, hsotg->regs + GINTSTS);
2501
2502                 /* Report disconnection if it is not already done. */
2503                 dwc2_hsotg_disconnect(hsotg);
2504
2505                 if (usb_status & GOTGCTL_BSESVLD && connected)
2506                         dwc2_hsotg_core_init_disconnected(hsotg, true);
2507         }
2508
2509         if (gintsts & GINTSTS_ENUMDONE) {
2510                 dwc2_writel(GINTSTS_ENUMDONE, hsotg->regs + GINTSTS);
2511
2512                 dwc2_hsotg_irq_enumdone(hsotg);
2513         }
2514
2515         if (gintsts & (GINTSTS_OEPINT | GINTSTS_IEPINT)) {
2516                 u32 daint = dwc2_readl(hsotg->regs + DAINT);
2517                 u32 daintmsk = dwc2_readl(hsotg->regs + DAINTMSK);
2518                 u32 daint_out, daint_in;
2519                 int ep;
2520
2521                 daint &= daintmsk;
2522                 daint_out = daint >> DAINT_OUTEP_SHIFT;
2523                 daint_in = daint & ~(daint_out << DAINT_OUTEP_SHIFT);
2524
2525                 dev_dbg(hsotg->dev, "%s: daint=%08x\n", __func__, daint);
2526
2527                 for (ep = 0; ep < hsotg->num_of_eps && daint_out;
2528                                                 ep++, daint_out >>= 1) {
2529                         if (daint_out & 1)
2530                                 dwc2_hsotg_epint(hsotg, ep, 0);
2531                 }
2532
2533                 for (ep = 0; ep < hsotg->num_of_eps  && daint_in;
2534                                                 ep++, daint_in >>= 1) {
2535                         if (daint_in & 1)
2536                                 dwc2_hsotg_epint(hsotg, ep, 1);
2537                 }
2538         }
2539
2540         /* check both FIFOs */
2541
2542         if (gintsts & GINTSTS_NPTXFEMP) {
2543                 dev_dbg(hsotg->dev, "NPTxFEmp\n");
2544
2545                 /*
2546                  * Disable the interrupt to stop it happening again
2547                  * unless one of these endpoint routines decides that
2548                  * it needs re-enabling
2549                  */
2550
2551                 dwc2_hsotg_disable_gsint(hsotg, GINTSTS_NPTXFEMP);
2552                 dwc2_hsotg_irq_fifoempty(hsotg, false);
2553         }
2554
2555         if (gintsts & GINTSTS_PTXFEMP) {
2556                 dev_dbg(hsotg->dev, "PTxFEmp\n");
2557
2558                 /* See note in GINTSTS_NPTxFEmp */
2559
2560                 dwc2_hsotg_disable_gsint(hsotg, GINTSTS_PTXFEMP);
2561                 dwc2_hsotg_irq_fifoempty(hsotg, true);
2562         }
2563
2564         if (gintsts & GINTSTS_RXFLVL) {
2565                 /*
2566                  * note, since GINTSTS_RxFLvl doubles as FIFO-not-empty,
2567                  * we need to retry dwc2_hsotg_handle_rx if this is still
2568                  * set.
2569                  */
2570
2571                 dwc2_hsotg_handle_rx(hsotg);
2572         }
2573
2574         if (gintsts & GINTSTS_ERLYSUSP) {
2575                 dev_dbg(hsotg->dev, "GINTSTS_ErlySusp\n");
2576                 dwc2_writel(GINTSTS_ERLYSUSP, hsotg->regs + GINTSTS);
2577         }
2578
2579         /*
2580          * these next two seem to crop-up occasionally causing the core
2581          * to shutdown the USB transfer, so try clearing them and logging
2582          * the occurrence.
2583          */
2584
2585         if (gintsts & GINTSTS_GOUTNAKEFF) {
2586                 dev_info(hsotg->dev, "GOUTNakEff triggered\n");
2587
2588                 dwc2_writel(DCTL_CGOUTNAK, hsotg->regs + DCTL);
2589
2590                 dwc2_hsotg_dump(hsotg);
2591         }
2592
2593         if (gintsts & GINTSTS_GINNAKEFF) {
2594                 dev_info(hsotg->dev, "GINNakEff triggered\n");
2595
2596                 dwc2_writel(DCTL_CGNPINNAK, hsotg->regs + DCTL);
2597
2598                 dwc2_hsotg_dump(hsotg);
2599         }
2600
2601         if (gintsts & GINTSTS_INCOMPL_SOIN) {
2602                 u32 idx, epctl_reg;
2603                 struct dwc2_hsotg_ep *hs_ep;
2604
2605                 dev_dbg(hsotg->dev, "%s: GINTSTS_INCOMPL_SOIN\n", __func__);
2606                 for (idx = 1; idx < hsotg->num_of_eps; idx++) {
2607                         hs_ep = hsotg->eps_in[idx];
2608
2609                         if (!hs_ep->isochronous || hs_ep->has_correct_parity)
2610                                 continue;
2611
2612                         epctl_reg = DIEPCTL(idx);
2613                         dwc2_hsotg_change_ep_iso_parity(hsotg, epctl_reg);
2614                 }
2615                 dwc2_writel(GINTSTS_INCOMPL_SOIN, hsotg->regs + GINTSTS);
2616         }
2617
2618         if (gintsts & GINTSTS_INCOMPL_SOOUT) {
2619                 u32 idx, epctl_reg;
2620                 struct dwc2_hsotg_ep *hs_ep;
2621
2622                 dev_dbg(hsotg->dev, "%s: GINTSTS_INCOMPL_SOOUT\n", __func__);
2623                 for (idx = 1; idx < hsotg->num_of_eps; idx++) {
2624                         hs_ep = hsotg->eps_out[idx];
2625
2626                         if (!hs_ep->isochronous || hs_ep->has_correct_parity)
2627                                 continue;
2628
2629                         epctl_reg = DOEPCTL(idx);
2630                         dwc2_hsotg_change_ep_iso_parity(hsotg, epctl_reg);
2631                 }
2632                 dwc2_writel(GINTSTS_INCOMPL_SOOUT, hsotg->regs + GINTSTS);
2633         }
2634
2635         /*
2636          * if we've had fifo events, we should try and go around the
2637          * loop again to see if there's any point in returning yet.
2638          */
2639
2640         if (gintsts & IRQ_RETRY_MASK && --retry_count > 0)
2641                         goto irq_retry;
2642
2643         spin_unlock(&hsotg->lock);
2644
2645         return IRQ_HANDLED;
2646 }
2647
2648 /**
2649  * dwc2_hsotg_ep_enable - enable the given endpoint
2650  * @ep: The USB endpint to configure
2651  * @desc: The USB endpoint descriptor to configure with.
2652  *
2653  * This is called from the USB gadget code's usb_ep_enable().
2654  */
2655 static int dwc2_hsotg_ep_enable(struct usb_ep *ep,
2656                                const struct usb_endpoint_descriptor *desc)
2657 {
2658         struct dwc2_hsotg_ep *hs_ep = our_ep(ep);
2659         struct dwc2_hsotg *hsotg = hs_ep->parent;
2660         unsigned long flags;
2661         unsigned int index = hs_ep->index;
2662         u32 epctrl_reg;
2663         u32 epctrl;
2664         u32 mps;
2665         unsigned int dir_in;
2666         unsigned int i, val, size;
2667         int ret = 0;
2668
2669         dev_dbg(hsotg->dev,
2670                 "%s: ep %s: a 0x%02x, attr 0x%02x, mps 0x%04x, intr %d\n",
2671                 __func__, ep->name, desc->bEndpointAddress, desc->bmAttributes,
2672                 desc->wMaxPacketSize, desc->bInterval);
2673
2674         /* not to be called for EP0 */
2675         WARN_ON(index == 0);
2676
2677         dir_in = (desc->bEndpointAddress & USB_ENDPOINT_DIR_MASK) ? 1 : 0;
2678         if (dir_in != hs_ep->dir_in) {
2679                 dev_err(hsotg->dev, "%s: direction mismatch!\n", __func__);
2680                 return -EINVAL;
2681         }
2682
2683         mps = usb_endpoint_maxp(desc);
2684
2685         /* note, we handle this here instead of dwc2_hsotg_set_ep_maxpacket */
2686
2687         epctrl_reg = dir_in ? DIEPCTL(index) : DOEPCTL(index);
2688         epctrl = dwc2_readl(hsotg->regs + epctrl_reg);
2689
2690         dev_dbg(hsotg->dev, "%s: read DxEPCTL=0x%08x from 0x%08x\n",
2691                 __func__, epctrl, epctrl_reg);
2692
2693         spin_lock_irqsave(&hsotg->lock, flags);
2694
2695         epctrl &= ~(DXEPCTL_EPTYPE_MASK | DXEPCTL_MPS_MASK);
2696         epctrl |= DXEPCTL_MPS(mps);
2697
2698         /*
2699          * mark the endpoint as active, otherwise the core may ignore
2700          * transactions entirely for this endpoint
2701          */
2702         epctrl |= DXEPCTL_USBACTEP;
2703
2704         /*
2705          * set the NAK status on the endpoint, otherwise we might try and
2706          * do something with data that we've yet got a request to process
2707          * since the RXFIFO will take data for an endpoint even if the
2708          * size register hasn't been set.
2709          */
2710
2711         epctrl |= DXEPCTL_SNAK;
2712
2713         /* update the endpoint state */
2714         dwc2_hsotg_set_ep_maxpacket(hsotg, hs_ep->index, mps, dir_in);
2715
2716         /* default, set to non-periodic */
2717         hs_ep->isochronous = 0;
2718         hs_ep->periodic = 0;
2719         hs_ep->halted = 0;
2720         hs_ep->interval = desc->bInterval;
2721         hs_ep->has_correct_parity = 0;
2722
2723         if (hs_ep->interval > 1 && hs_ep->mc > 1)
2724                 dev_err(hsotg->dev, "MC > 1 when interval is not 1\n");
2725
2726         switch (desc->bmAttributes & USB_ENDPOINT_XFERTYPE_MASK) {
2727         case USB_ENDPOINT_XFER_ISOC:
2728                 epctrl |= DXEPCTL_EPTYPE_ISO;
2729                 epctrl |= DXEPCTL_SETEVENFR;
2730                 hs_ep->isochronous = 1;
2731                 if (dir_in)
2732                         hs_ep->periodic = 1;
2733                 break;
2734
2735         case USB_ENDPOINT_XFER_BULK:
2736                 epctrl |= DXEPCTL_EPTYPE_BULK;
2737                 break;
2738
2739         case USB_ENDPOINT_XFER_INT:
2740                 if (dir_in)
2741                         hs_ep->periodic = 1;
2742
2743                 epctrl |= DXEPCTL_EPTYPE_INTERRUPT;
2744                 break;
2745
2746         case USB_ENDPOINT_XFER_CONTROL:
2747                 epctrl |= DXEPCTL_EPTYPE_CONTROL;
2748                 break;
2749         }
2750
2751         /* If fifo is already allocated for this ep */
2752         if (hs_ep->fifo_index) {
2753                 size =  hs_ep->ep.maxpacket * hs_ep->mc;
2754                 /* If bigger fifo is required deallocate current one */
2755                 if (size > hs_ep->fifo_size) {
2756                         hsotg->fifo_map &= ~(1 << hs_ep->fifo_index);
2757                         hs_ep->fifo_index = 0;
2758                         hs_ep->fifo_size = 0;
2759                 }
2760         }
2761
2762         /*
2763          * if the hardware has dedicated fifos, we must give each IN EP
2764          * a unique tx-fifo even if it is non-periodic.
2765          */
2766         if (dir_in && hsotg->dedicated_fifos && !hs_ep->fifo_index) {
2767                 u32 fifo_index = 0;
2768                 u32 fifo_size = UINT_MAX;
2769                 size = hs_ep->ep.maxpacket*hs_ep->mc;
2770                 for (i = 1; i < hsotg->num_of_eps; ++i) {
2771                         if (hsotg->fifo_map & (1<<i))
2772                                 continue;
2773                         val = dwc2_readl(hsotg->regs + DPTXFSIZN(i));
2774                         val = (val >> FIFOSIZE_DEPTH_SHIFT)*4;
2775                         if (val < size)
2776                                 continue;
2777                         /* Search for smallest acceptable fifo */
2778                         if (val < fifo_size) {
2779                                 fifo_size = val;
2780                                 fifo_index = i;
2781                         }
2782                 }
2783                 if (!fifo_index) {
2784                         dev_err(hsotg->dev,
2785                                 "%s: No suitable fifo found\n", __func__);
2786                         ret = -ENOMEM;
2787                         goto error;
2788                 }
2789                 hsotg->fifo_map |= 1 << fifo_index;
2790                 epctrl |= DXEPCTL_TXFNUM(fifo_index);
2791                 hs_ep->fifo_index = fifo_index;
2792                 hs_ep->fifo_size = fifo_size;
2793         }
2794
2795         /* for non control endpoints, set PID to D0 */
2796         if (index)
2797                 epctrl |= DXEPCTL_SETD0PID;
2798
2799         dev_dbg(hsotg->dev, "%s: write DxEPCTL=0x%08x\n",
2800                 __func__, epctrl);
2801
2802         dwc2_writel(epctrl, hsotg->regs + epctrl_reg);
2803         dev_dbg(hsotg->dev, "%s: read DxEPCTL=0x%08x\n",
2804                 __func__, dwc2_readl(hsotg->regs + epctrl_reg));
2805
2806         /* enable the endpoint interrupt */
2807         dwc2_hsotg_ctrl_epint(hsotg, index, dir_in, 1);
2808
2809 error:
2810         spin_unlock_irqrestore(&hsotg->lock, flags);
2811         return ret;
2812 }
2813
2814 /**
2815  * dwc2_hsotg_ep_disable - disable given endpoint
2816  * @ep: The endpoint to disable.
2817  */
2818 static int dwc2_hsotg_ep_disable(struct usb_ep *ep)
2819 {
2820         struct dwc2_hsotg_ep *hs_ep = our_ep(ep);
2821         struct dwc2_hsotg *hsotg = hs_ep->parent;
2822         int dir_in = hs_ep->dir_in;
2823         int index = hs_ep->index;
2824         unsigned long flags;
2825         u32 epctrl_reg;
2826         u32 ctrl;
2827
2828         dev_dbg(hsotg->dev, "%s(ep %p)\n", __func__, ep);
2829
2830         if (ep == &hsotg->eps_out[0]->ep) {
2831                 dev_err(hsotg->dev, "%s: called for ep0\n", __func__);
2832                 return -EINVAL;
2833         }
2834
2835         epctrl_reg = dir_in ? DIEPCTL(index) : DOEPCTL(index);
2836
2837         spin_lock_irqsave(&hsotg->lock, flags);
2838
2839         hsotg->fifo_map &= ~(1<<hs_ep->fifo_index);
2840         hs_ep->fifo_index = 0;
2841         hs_ep->fifo_size = 0;
2842
2843         ctrl = dwc2_readl(hsotg->regs + epctrl_reg);
2844         ctrl &= ~DXEPCTL_EPENA;
2845         ctrl &= ~DXEPCTL_USBACTEP;
2846         ctrl |= DXEPCTL_SNAK;
2847
2848         dev_dbg(hsotg->dev, "%s: DxEPCTL=0x%08x\n", __func__, ctrl);
2849         dwc2_writel(ctrl, hsotg->regs + epctrl_reg);
2850
2851         /* disable endpoint interrupts */
2852         dwc2_hsotg_ctrl_epint(hsotg, hs_ep->index, hs_ep->dir_in, 0);
2853
2854         /* terminate all requests with shutdown */
2855         kill_all_requests(hsotg, hs_ep, -ESHUTDOWN);
2856
2857         spin_unlock_irqrestore(&hsotg->lock, flags);
2858         return 0;
2859 }
2860
2861 /**
2862  * on_list - check request is on the given endpoint
2863  * @ep: The endpoint to check.
2864  * @test: The request to test if it is on the endpoint.
2865  */
2866 static bool on_list(struct dwc2_hsotg_ep *ep, struct dwc2_hsotg_req *test)
2867 {
2868         struct dwc2_hsotg_req *req, *treq;
2869
2870         list_for_each_entry_safe(req, treq, &ep->queue, queue) {
2871                 if (req == test)
2872                         return true;
2873         }
2874
2875         return false;
2876 }
2877
2878 static int dwc2_hsotg_wait_bit_set(struct dwc2_hsotg *hs_otg, u32 reg,
2879                                                         u32 bit, u32 timeout)
2880 {
2881         u32 i;
2882
2883         for (i = 0; i < timeout; i++) {
2884                 if (dwc2_readl(hs_otg->regs + reg) & bit)
2885                         return 0;
2886                 udelay(1);
2887         }
2888
2889         return -ETIMEDOUT;
2890 }
2891
2892 static void dwc2_hsotg_ep_stop_xfr(struct dwc2_hsotg *hsotg,
2893                                                 struct dwc2_hsotg_ep *hs_ep)
2894 {
2895         u32 epctrl_reg;
2896         u32 epint_reg;
2897
2898         epctrl_reg = hs_ep->dir_in ? DIEPCTL(hs_ep->index) :
2899                 DOEPCTL(hs_ep->index);
2900         epint_reg = hs_ep->dir_in ? DIEPINT(hs_ep->index) :
2901                 DOEPINT(hs_ep->index);
2902
2903         dev_dbg(hsotg->dev, "%s: stopping transfer on %s\n", __func__,
2904                         hs_ep->name);
2905         if (hs_ep->dir_in) {
2906                 __orr32(hsotg->regs + epctrl_reg, DXEPCTL_SNAK);
2907                 /* Wait for Nak effect */
2908                 if (dwc2_hsotg_wait_bit_set(hsotg, epint_reg,
2909                                                 DXEPINT_INEPNAKEFF, 100))
2910                         dev_warn(hsotg->dev,
2911                                 "%s: timeout DIEPINT.NAKEFF\n", __func__);
2912         } else {
2913                 /* Clear any pending nak effect interrupt */
2914                 dwc2_writel(GINTSTS_GINNAKEFF, hsotg->regs + GINTSTS);
2915
2916                 __orr32(hsotg->regs + DCTL, DCTL_SGNPINNAK);
2917
2918                 /* Wait for global nak to take effect */
2919                 if (dwc2_hsotg_wait_bit_set(hsotg, GINTSTS,
2920                                                 GINTSTS_GINNAKEFF, 100))
2921                         dev_warn(hsotg->dev,
2922                                 "%s: timeout GINTSTS.GINNAKEFF\n", __func__);
2923         }
2924
2925         /* Disable ep */
2926         __orr32(hsotg->regs + epctrl_reg, DXEPCTL_EPDIS | DXEPCTL_SNAK);
2927
2928         /* Wait for ep to be disabled */
2929         if (dwc2_hsotg_wait_bit_set(hsotg, epint_reg, DXEPINT_EPDISBLD, 100))
2930                 dev_warn(hsotg->dev,
2931                         "%s: timeout DOEPCTL.EPDisable\n", __func__);
2932
2933         if (hs_ep->dir_in) {
2934                 if (hsotg->dedicated_fifos) {
2935                         dwc2_writel(GRSTCTL_TXFNUM(hs_ep->fifo_index) |
2936                                 GRSTCTL_TXFFLSH, hsotg->regs + GRSTCTL);
2937                         /* Wait for fifo flush */
2938                         if (dwc2_hsotg_wait_bit_set(hsotg, GRSTCTL,
2939                                                         GRSTCTL_TXFFLSH, 100))
2940                                 dev_warn(hsotg->dev,
2941                                         "%s: timeout flushing fifos\n",
2942                                         __func__);
2943                 }
2944                 /* TODO: Flush shared tx fifo */
2945         } else {
2946                 /* Remove global NAKs */
2947                 __bic32(hsotg->regs + DCTL, DCTL_SGNPINNAK);
2948         }
2949 }
2950
2951 /**
2952  * dwc2_hsotg_ep_dequeue - dequeue given endpoint
2953  * @ep: The endpoint to dequeue.
2954  * @req: The request to be removed from a queue.
2955  */
2956 static int dwc2_hsotg_ep_dequeue(struct usb_ep *ep, struct usb_request *req)
2957 {
2958         struct dwc2_hsotg_req *hs_req = our_req(req);
2959         struct dwc2_hsotg_ep *hs_ep = our_ep(ep);
2960         struct dwc2_hsotg *hs = hs_ep->parent;
2961         unsigned long flags;
2962
2963         dev_dbg(hs->dev, "ep_dequeue(%p,%p)\n", ep, req);
2964
2965         spin_lock_irqsave(&hs->lock, flags);
2966
2967         if (!on_list(hs_ep, hs_req)) {
2968                 spin_unlock_irqrestore(&hs->lock, flags);
2969                 return -EINVAL;
2970         }
2971
2972         /* Dequeue already started request */
2973         if (req == &hs_ep->req->req)
2974                 dwc2_hsotg_ep_stop_xfr(hs, hs_ep);
2975
2976         dwc2_hsotg_complete_request(hs, hs_ep, hs_req, -ECONNRESET);
2977         spin_unlock_irqrestore(&hs->lock, flags);
2978
2979         return 0;
2980 }
2981
2982 /**
2983  * dwc2_hsotg_ep_sethalt - set halt on a given endpoint
2984  * @ep: The endpoint to set halt.
2985  * @value: Set or unset the halt.
2986  */
2987 static int dwc2_hsotg_ep_sethalt(struct usb_ep *ep, int value)
2988 {
2989         struct dwc2_hsotg_ep *hs_ep = our_ep(ep);
2990         struct dwc2_hsotg *hs = hs_ep->parent;
2991         int index = hs_ep->index;
2992         u32 epreg;
2993         u32 epctl;
2994         u32 xfertype;
2995
2996         dev_info(hs->dev, "%s(ep %p %s, %d)\n", __func__, ep, ep->name, value);
2997
2998         if (index == 0) {
2999                 if (value)
3000                         dwc2_hsotg_stall_ep0(hs);
3001                 else
3002                         dev_warn(hs->dev,
3003                                  "%s: can't clear halt on ep0\n", __func__);
3004                 return 0;
3005         }
3006
3007         if (hs_ep->dir_in) {
3008                 epreg = DIEPCTL(index);
3009                 epctl = dwc2_readl(hs->regs + epreg);
3010
3011                 if (value) {
3012                         epctl |= DXEPCTL_STALL | DXEPCTL_SNAK;
3013                         if (epctl & DXEPCTL_EPENA)
3014                                 epctl |= DXEPCTL_EPDIS;
3015                 } else {
3016                         epctl &= ~DXEPCTL_STALL;
3017                         xfertype = epctl & DXEPCTL_EPTYPE_MASK;
3018                         if (xfertype == DXEPCTL_EPTYPE_BULK ||
3019                                 xfertype == DXEPCTL_EPTYPE_INTERRUPT)
3020                                         epctl |= DXEPCTL_SETD0PID;
3021                 }
3022                 dwc2_writel(epctl, hs->regs + epreg);
3023         } else {
3024
3025                 epreg = DOEPCTL(index);
3026                 epctl = dwc2_readl(hs->regs + epreg);
3027
3028                 if (value)
3029                         epctl |= DXEPCTL_STALL;
3030                 else {
3031                         epctl &= ~DXEPCTL_STALL;
3032                         xfertype = epctl & DXEPCTL_EPTYPE_MASK;
3033                         if (xfertype == DXEPCTL_EPTYPE_BULK ||
3034                                 xfertype == DXEPCTL_EPTYPE_INTERRUPT)
3035                                         epctl |= DXEPCTL_SETD0PID;
3036                 }
3037                 dwc2_writel(epctl, hs->regs + epreg);
3038         }
3039
3040         hs_ep->halted = value;
3041
3042         return 0;
3043 }
3044
3045 /**
3046  * dwc2_hsotg_ep_sethalt_lock - set halt on a given endpoint with lock held
3047  * @ep: The endpoint to set halt.
3048  * @value: Set or unset the halt.
3049  */
3050 static int dwc2_hsotg_ep_sethalt_lock(struct usb_ep *ep, int value)
3051 {
3052         struct dwc2_hsotg_ep *hs_ep = our_ep(ep);
3053         struct dwc2_hsotg *hs = hs_ep->parent;
3054         unsigned long flags = 0;
3055         int ret = 0;
3056
3057         spin_lock_irqsave(&hs->lock, flags);
3058         ret = dwc2_hsotg_ep_sethalt(ep, value);
3059         spin_unlock_irqrestore(&hs->lock, flags);
3060
3061         return ret;
3062 }
3063
3064 static struct usb_ep_ops dwc2_hsotg_ep_ops = {
3065         .enable         = dwc2_hsotg_ep_enable,
3066         .disable        = dwc2_hsotg_ep_disable,
3067         .alloc_request  = dwc2_hsotg_ep_alloc_request,
3068         .free_request   = dwc2_hsotg_ep_free_request,
3069         .queue          = dwc2_hsotg_ep_queue_lock,
3070         .dequeue        = dwc2_hsotg_ep_dequeue,
3071         .set_halt       = dwc2_hsotg_ep_sethalt_lock,
3072         /* note, don't believe we have any call for the fifo routines */
3073 };
3074
3075 /**
3076  * dwc2_hsotg_init - initalize the usb core
3077  * @hsotg: The driver state
3078  */
3079 static void dwc2_hsotg_init(struct dwc2_hsotg *hsotg)
3080 {
3081         u32 trdtim;
3082         /* unmask subset of endpoint interrupts */
3083
3084         dwc2_writel(DIEPMSK_TIMEOUTMSK | DIEPMSK_AHBERRMSK |
3085                     DIEPMSK_EPDISBLDMSK | DIEPMSK_XFERCOMPLMSK,
3086                     hsotg->regs + DIEPMSK);
3087
3088         dwc2_writel(DOEPMSK_SETUPMSK | DOEPMSK_AHBERRMSK |
3089                     DOEPMSK_EPDISBLDMSK | DOEPMSK_XFERCOMPLMSK,
3090                     hsotg->regs + DOEPMSK);
3091
3092         dwc2_writel(0, hsotg->regs + DAINTMSK);
3093
3094         /* Be in disconnected state until gadget is registered */
3095         __orr32(hsotg->regs + DCTL, DCTL_SFTDISCON);
3096
3097         /* setup fifos */
3098
3099         dev_dbg(hsotg->dev, "GRXFSIZ=0x%08x, GNPTXFSIZ=0x%08x\n",
3100                 dwc2_readl(hsotg->regs + GRXFSIZ),
3101                 dwc2_readl(hsotg->regs + GNPTXFSIZ));
3102
3103         dwc2_hsotg_init_fifo(hsotg);
3104
3105         /* set the PLL on, remove the HNP/SRP and set the PHY */
3106         trdtim = (hsotg->phyif == GUSBCFG_PHYIF8) ? 9 : 5;
3107         dwc2_writel(hsotg->phyif | GUSBCFG_TOUTCAL(7) |
3108                 (trdtim << GUSBCFG_USBTRDTIM_SHIFT),
3109                 hsotg->regs + GUSBCFG);
3110
3111         if (using_dma(hsotg))
3112                 __orr32(hsotg->regs + GAHBCFG, GAHBCFG_DMA_EN);
3113 }
3114
3115 /**
3116  * dwc2_hsotg_udc_start - prepare the udc for work
3117  * @gadget: The usb gadget state
3118  * @driver: The usb gadget driver
3119  *
3120  * Perform initialization to prepare udc device and driver
3121  * to work.
3122  */
3123 static int dwc2_hsotg_udc_start(struct usb_gadget *gadget,
3124                            struct usb_gadget_driver *driver)
3125 {
3126         struct dwc2_hsotg *hsotg = to_hsotg(gadget);
3127         unsigned long flags;
3128         int ret;
3129
3130         if (!hsotg) {
3131                 pr_err("%s: called with no device\n", __func__);
3132                 return -ENODEV;
3133         }
3134
3135         if (!driver) {
3136                 dev_err(hsotg->dev, "%s: no driver\n", __func__);
3137                 return -EINVAL;
3138         }
3139
3140         if (driver->max_speed < USB_SPEED_FULL)
3141                 dev_err(hsotg->dev, "%s: bad speed\n", __func__);
3142
3143         if (!driver->setup) {
3144                 dev_err(hsotg->dev, "%s: missing entry points\n", __func__);
3145                 return -EINVAL;
3146         }
3147
3148         WARN_ON(hsotg->driver);
3149
3150         driver->driver.bus = NULL;
3151         hsotg->driver = driver;
3152         hsotg->gadget.dev.of_node = hsotg->dev->of_node;
3153         hsotg->gadget.speed = USB_SPEED_UNKNOWN;
3154
3155         if (hsotg->dr_mode == USB_DR_MODE_PERIPHERAL) {
3156                 ret = dwc2_lowlevel_hw_enable(hsotg);
3157                 if (ret)
3158                         goto err;
3159         }
3160
3161         if (!IS_ERR_OR_NULL(hsotg->uphy))
3162                 otg_set_peripheral(hsotg->uphy->otg, &hsotg->gadget);
3163
3164         spin_lock_irqsave(&hsotg->lock, flags);
3165         dwc2_hsotg_init(hsotg);
3166         dwc2_hsotg_core_init_disconnected(hsotg, false);
3167         hsotg->enabled = 0;
3168         spin_unlock_irqrestore(&hsotg->lock, flags);
3169
3170         dev_info(hsotg->dev, "bound driver %s\n", driver->driver.name);
3171
3172         return 0;
3173
3174 err:
3175         hsotg->driver = NULL;
3176         return ret;
3177 }
3178
3179 /**
3180  * dwc2_hsotg_udc_stop - stop the udc
3181  * @gadget: The usb gadget state
3182  * @driver: The usb gadget driver
3183  *
3184  * Stop udc hw block and stay tunned for future transmissions
3185  */
3186 static int dwc2_hsotg_udc_stop(struct usb_gadget *gadget)
3187 {
3188         struct dwc2_hsotg *hsotg = to_hsotg(gadget);
3189         unsigned long flags = 0;
3190         int ep;
3191
3192         if (!hsotg)
3193                 return -ENODEV;
3194
3195         /* all endpoints should be shutdown */
3196         for (ep = 1; ep < hsotg->num_of_eps; ep++) {
3197                 if (hsotg->eps_in[ep])
3198                         dwc2_hsotg_ep_disable(&hsotg->eps_in[ep]->ep);
3199                 if (hsotg->eps_out[ep])
3200                         dwc2_hsotg_ep_disable(&hsotg->eps_out[ep]->ep);
3201         }
3202
3203         spin_lock_irqsave(&hsotg->lock, flags);
3204
3205         hsotg->driver = NULL;
3206         hsotg->gadget.speed = USB_SPEED_UNKNOWN;
3207         hsotg->enabled = 0;
3208
3209         spin_unlock_irqrestore(&hsotg->lock, flags);
3210
3211         if (!IS_ERR_OR_NULL(hsotg->uphy))
3212                 otg_set_peripheral(hsotg->uphy->otg, NULL);
3213
3214         if (hsotg->dr_mode == USB_DR_MODE_PERIPHERAL)
3215                 dwc2_lowlevel_hw_disable(hsotg);
3216
3217         return 0;
3218 }
3219
3220 /**
3221  * dwc2_hsotg_gadget_getframe - read the frame number
3222  * @gadget: The usb gadget state
3223  *
3224  * Read the {micro} frame number
3225  */
3226 static int dwc2_hsotg_gadget_getframe(struct usb_gadget *gadget)
3227 {
3228         return dwc2_hsotg_read_frameno(to_hsotg(gadget));
3229 }
3230
3231 /**
3232  * dwc2_hsotg_pullup - connect/disconnect the USB PHY
3233  * @gadget: The usb gadget state
3234  * @is_on: Current state of the USB PHY
3235  *
3236  * Connect/Disconnect the USB PHY pullup
3237  */
3238 static int dwc2_hsotg_pullup(struct usb_gadget *gadget, int is_on)
3239 {
3240         struct dwc2_hsotg *hsotg = to_hsotg(gadget);
3241         unsigned long flags = 0;
3242
3243         dev_dbg(hsotg->dev, "%s: is_on: %d op_state: %d\n", __func__, is_on,
3244                         hsotg->op_state);
3245
3246         /* Don't modify pullup state while in host mode */
3247         if (hsotg->op_state != OTG_STATE_B_PERIPHERAL) {
3248                 hsotg->enabled = is_on;
3249                 return 0;
3250         }
3251
3252         spin_lock_irqsave(&hsotg->lock, flags);
3253         if (is_on) {
3254                 hsotg->enabled = 1;
3255                 dwc2_hsotg_core_init_disconnected(hsotg, false);
3256                 dwc2_hsotg_core_connect(hsotg);
3257         } else {
3258                 dwc2_hsotg_core_disconnect(hsotg);
3259                 dwc2_hsotg_disconnect(hsotg);
3260                 hsotg->enabled = 0;
3261         }
3262
3263         hsotg->gadget.speed = USB_SPEED_UNKNOWN;
3264         spin_unlock_irqrestore(&hsotg->lock, flags);
3265
3266         return 0;
3267 }
3268
3269 static int dwc2_hsotg_vbus_session(struct usb_gadget *gadget, int is_active)
3270 {
3271         struct dwc2_hsotg *hsotg = to_hsotg(gadget);
3272         unsigned long flags;
3273
3274         dev_dbg(hsotg->dev, "%s: is_active: %d\n", __func__, is_active);
3275         spin_lock_irqsave(&hsotg->lock, flags);
3276
3277         /*
3278          * If controller is hibernated, it must exit from hibernation
3279          * before being initialized / de-initialized
3280          */
3281         if (hsotg->lx_state == DWC2_L2)
3282                 dwc2_exit_hibernation(hsotg, false);
3283
3284         if (is_active) {
3285                 hsotg->op_state = OTG_STATE_B_PERIPHERAL;
3286
3287                 dwc2_hsotg_core_init_disconnected(hsotg, false);
3288                 if (hsotg->enabled)
3289                         dwc2_hsotg_core_connect(hsotg);
3290         } else {
3291                 dwc2_hsotg_core_disconnect(hsotg);
3292                 dwc2_hsotg_disconnect(hsotg);
3293         }
3294
3295         spin_unlock_irqrestore(&hsotg->lock, flags);
3296         return 0;
3297 }
3298
3299 /**
3300  * dwc2_hsotg_vbus_draw - report bMaxPower field
3301  * @gadget: The usb gadget state
3302  * @mA: Amount of current
3303  *
3304  * Report how much power the device may consume to the phy.
3305  */
3306 static int dwc2_hsotg_vbus_draw(struct usb_gadget *gadget, unsigned mA)
3307 {
3308         struct dwc2_hsotg *hsotg = to_hsotg(gadget);
3309
3310         if (IS_ERR_OR_NULL(hsotg->uphy))
3311                 return -ENOTSUPP;
3312         return usb_phy_set_power(hsotg->uphy, mA);
3313 }
3314
3315 static const struct usb_gadget_ops dwc2_hsotg_gadget_ops = {
3316         .get_frame      = dwc2_hsotg_gadget_getframe,
3317         .udc_start              = dwc2_hsotg_udc_start,
3318         .udc_stop               = dwc2_hsotg_udc_stop,
3319         .pullup                 = dwc2_hsotg_pullup,
3320         .vbus_session           = dwc2_hsotg_vbus_session,
3321         .vbus_draw              = dwc2_hsotg_vbus_draw,
3322 };
3323
3324 /**
3325  * dwc2_hsotg_initep - initialise a single endpoint
3326  * @hsotg: The device state.
3327  * @hs_ep: The endpoint to be initialised.
3328  * @epnum: The endpoint number
3329  *
3330  * Initialise the given endpoint (as part of the probe and device state
3331  * creation) to give to the gadget driver. Setup the endpoint name, any
3332  * direction information and other state that may be required.
3333  */
3334 static void dwc2_hsotg_initep(struct dwc2_hsotg *hsotg,
3335                                        struct dwc2_hsotg_ep *hs_ep,
3336                                        int epnum,
3337                                        bool dir_in)
3338 {
3339         char *dir;
3340
3341         if (epnum == 0)
3342                 dir = "";
3343         else if (dir_in)
3344                 dir = "in";
3345         else
3346                 dir = "out";
3347
3348         hs_ep->dir_in = dir_in;
3349         hs_ep->index = epnum;
3350
3351         snprintf(hs_ep->name, sizeof(hs_ep->name), "ep%d%s", epnum, dir);
3352
3353         INIT_LIST_HEAD(&hs_ep->queue);
3354         INIT_LIST_HEAD(&hs_ep->ep.ep_list);
3355
3356         /* add to the list of endpoints known by the gadget driver */
3357         if (epnum)
3358                 list_add_tail(&hs_ep->ep.ep_list, &hsotg->gadget.ep_list);
3359
3360         hs_ep->parent = hsotg;
3361         hs_ep->ep.name = hs_ep->name;
3362         usb_ep_set_maxpacket_limit(&hs_ep->ep, epnum ? 1024 : EP0_MPS_LIMIT);
3363         hs_ep->ep.ops = &dwc2_hsotg_ep_ops;
3364
3365         if (epnum == 0) {
3366                 hs_ep->ep.caps.type_control = true;
3367         } else {
3368                 hs_ep->ep.caps.type_iso = true;
3369                 hs_ep->ep.caps.type_bulk = true;
3370                 hs_ep->ep.caps.type_int = true;
3371         }
3372
3373         if (dir_in)
3374                 hs_ep->ep.caps.dir_in = true;
3375         else
3376                 hs_ep->ep.caps.dir_out = true;
3377
3378         /*
3379          * if we're using dma, we need to set the next-endpoint pointer
3380          * to be something valid.
3381          */
3382
3383         if (using_dma(hsotg)) {
3384                 u32 next = DXEPCTL_NEXTEP((epnum + 1) % 15);
3385                 if (dir_in)
3386                         dwc2_writel(next, hsotg->regs + DIEPCTL(epnum));
3387                 else
3388                         dwc2_writel(next, hsotg->regs + DOEPCTL(epnum));
3389         }
3390 }
3391
3392 /**
3393  * dwc2_hsotg_hw_cfg - read HW configuration registers
3394  * @param: The device state
3395  *
3396  * Read the USB core HW configuration registers
3397  */
3398 static int dwc2_hsotg_hw_cfg(struct dwc2_hsotg *hsotg)
3399 {
3400         u32 cfg;
3401         u32 ep_type;
3402         u32 i;
3403
3404         /* check hardware configuration */
3405
3406         cfg = dwc2_readl(hsotg->regs + GHWCFG2);
3407         hsotg->num_of_eps = (cfg >> GHWCFG2_NUM_DEV_EP_SHIFT) & 0xF;
3408         /* Add ep0 */
3409         hsotg->num_of_eps++;
3410
3411         hsotg->eps_in[0] = devm_kzalloc(hsotg->dev, sizeof(struct dwc2_hsotg_ep),
3412                                                                 GFP_KERNEL);
3413         if (!hsotg->eps_in[0])
3414                 return -ENOMEM;
3415         /* Same dwc2_hsotg_ep is used in both directions for ep0 */
3416         hsotg->eps_out[0] = hsotg->eps_in[0];
3417
3418         cfg = dwc2_readl(hsotg->regs + GHWCFG1);
3419         for (i = 1, cfg >>= 2; i < hsotg->num_of_eps; i++, cfg >>= 2) {
3420                 ep_type = cfg & 3;
3421                 /* Direction in or both */
3422                 if (!(ep_type & 2)) {
3423                         hsotg->eps_in[i] = devm_kzalloc(hsotg->dev,
3424                                 sizeof(struct dwc2_hsotg_ep), GFP_KERNEL);
3425                         if (!hsotg->eps_in[i])
3426                                 return -ENOMEM;
3427                 }
3428                 /* Direction out or both */
3429                 if (!(ep_type & 1)) {
3430                         hsotg->eps_out[i] = devm_kzalloc(hsotg->dev,
3431                                 sizeof(struct dwc2_hsotg_ep), GFP_KERNEL);
3432                         if (!hsotg->eps_out[i])
3433                                 return -ENOMEM;
3434                 }
3435         }
3436
3437         cfg = dwc2_readl(hsotg->regs + GHWCFG3);
3438         hsotg->fifo_mem = (cfg >> GHWCFG3_DFIFO_DEPTH_SHIFT);
3439
3440         cfg = dwc2_readl(hsotg->regs + GHWCFG4);
3441         hsotg->dedicated_fifos = (cfg >> GHWCFG4_DED_FIFO_SHIFT) & 1;
3442
3443         dev_info(hsotg->dev, "EPs: %d, %s fifos, %d entries in SPRAM\n",
3444                  hsotg->num_of_eps,
3445                  hsotg->dedicated_fifos ? "dedicated" : "shared",
3446                  hsotg->fifo_mem);
3447         return 0;
3448 }
3449
3450 /**
3451  * dwc2_hsotg_dump - dump state of the udc
3452  * @param: The device state
3453  */
3454 static void dwc2_hsotg_dump(struct dwc2_hsotg *hsotg)
3455 {
3456 #ifdef DEBUG
3457         struct device *dev = hsotg->dev;
3458         void __iomem *regs = hsotg->regs;
3459         u32 val;
3460         int idx;
3461
3462         dev_info(dev, "DCFG=0x%08x, DCTL=0x%08x, DIEPMSK=%08x\n",
3463                  dwc2_readl(regs + DCFG), dwc2_readl(regs + DCTL),
3464                  dwc2_readl(regs + DIEPMSK));
3465
3466         dev_info(dev, "GAHBCFG=0x%08x, GHWCFG1=0x%08x\n",
3467                  dwc2_readl(regs + GAHBCFG), dwc2_readl(regs + GHWCFG1));
3468
3469         dev_info(dev, "GRXFSIZ=0x%08x, GNPTXFSIZ=0x%08x\n",
3470                  dwc2_readl(regs + GRXFSIZ), dwc2_readl(regs + GNPTXFSIZ));
3471
3472         /* show periodic fifo settings */
3473
3474         for (idx = 1; idx < hsotg->num_of_eps; idx++) {
3475                 val = dwc2_readl(regs + DPTXFSIZN(idx));
3476                 dev_info(dev, "DPTx[%d] FSize=%d, StAddr=0x%08x\n", idx,
3477                          val >> FIFOSIZE_DEPTH_SHIFT,
3478                          val & FIFOSIZE_STARTADDR_MASK);
3479         }
3480
3481         for (idx = 0; idx < hsotg->num_of_eps; idx++) {
3482                 dev_info(dev,
3483                          "ep%d-in: EPCTL=0x%08x, SIZ=0x%08x, DMA=0x%08x\n", idx,
3484                          dwc2_readl(regs + DIEPCTL(idx)),
3485                          dwc2_readl(regs + DIEPTSIZ(idx)),
3486                          dwc2_readl(regs + DIEPDMA(idx)));
3487
3488                 val = dwc2_readl(regs + DOEPCTL(idx));
3489                 dev_info(dev,
3490                          "ep%d-out: EPCTL=0x%08x, SIZ=0x%08x, DMA=0x%08x\n",
3491                          idx, dwc2_readl(regs + DOEPCTL(idx)),
3492                          dwc2_readl(regs + DOEPTSIZ(idx)),
3493                          dwc2_readl(regs + DOEPDMA(idx)));
3494
3495         }
3496
3497         dev_info(dev, "DVBUSDIS=0x%08x, DVBUSPULSE=%08x\n",
3498                  dwc2_readl(regs + DVBUSDIS), dwc2_readl(regs + DVBUSPULSE));
3499 #endif
3500 }
3501
3502 #ifdef CONFIG_OF
3503 static void dwc2_hsotg_of_probe(struct dwc2_hsotg *hsotg)
3504 {
3505         struct device_node *np = hsotg->dev->of_node;
3506         u32 len = 0;
3507         u32 i = 0;
3508
3509         /* Enable dma if requested in device tree */
3510         hsotg->g_using_dma = of_property_read_bool(np, "g-use-dma");
3511
3512         /*
3513         * Register TX periodic fifo size per endpoint.
3514         * EP0 is excluded since it has no fifo configuration.
3515         */
3516         if (!of_find_property(np, "g-tx-fifo-size", &len))
3517                 goto rx_fifo;
3518
3519         len /= sizeof(u32);
3520
3521         /* Read tx fifo sizes other than ep0 */
3522         if (of_property_read_u32_array(np, "g-tx-fifo-size",
3523                                                 &hsotg->g_tx_fifo_sz[1], len))
3524                 goto rx_fifo;
3525
3526         /* Add ep0 */
3527         len++;
3528
3529         /* Make remaining TX fifos unavailable */
3530         if (len < MAX_EPS_CHANNELS) {
3531                 for (i = len; i < MAX_EPS_CHANNELS; i++)
3532                         hsotg->g_tx_fifo_sz[i] = 0;
3533         }
3534
3535 rx_fifo:
3536         /* Register RX fifo size */
3537         of_property_read_u32(np, "g-rx-fifo-size", &hsotg->g_rx_fifo_sz);
3538
3539         /* Register NPTX fifo size */
3540         of_property_read_u32(np, "g-np-tx-fifo-size",
3541                                                 &hsotg->g_np_g_tx_fifo_sz);
3542 }
3543 #else
3544 static inline void dwc2_hsotg_of_probe(struct dwc2_hsotg *hsotg) { }
3545 #endif
3546
3547 /**
3548  * dwc2_gadget_init - init function for gadget
3549  * @dwc2: The data structure for the DWC2 driver.
3550  * @irq: The IRQ number for the controller.
3551  */
3552 int dwc2_gadget_init(struct dwc2_hsotg *hsotg, int irq)
3553 {
3554         struct device *dev = hsotg->dev;
3555         int epnum;
3556         int ret;
3557         int i;
3558         u32 p_tx_fifo[] = DWC2_G_P_LEGACY_TX_FIFO_SIZE;
3559
3560         /* Initialize to legacy fifo configuration values */
3561         hsotg->g_rx_fifo_sz = 2048;
3562         hsotg->g_np_g_tx_fifo_sz = 1024;
3563         memcpy(&hsotg->g_tx_fifo_sz[1], p_tx_fifo, sizeof(p_tx_fifo));
3564         /* Device tree specific probe */
3565         dwc2_hsotg_of_probe(hsotg);
3566         /* Dump fifo information */
3567         dev_dbg(dev, "NonPeriodic TXFIFO size: %d\n",
3568                                                 hsotg->g_np_g_tx_fifo_sz);
3569         dev_dbg(dev, "RXFIFO size: %d\n", hsotg->g_rx_fifo_sz);
3570         for (i = 0; i < MAX_EPS_CHANNELS; i++)
3571                 dev_dbg(dev, "Periodic TXFIFO%2d size: %d\n", i,
3572                                                 hsotg->g_tx_fifo_sz[i]);
3573
3574         hsotg->gadget.max_speed = USB_SPEED_HIGH;
3575         hsotg->gadget.ops = &dwc2_hsotg_gadget_ops;
3576         hsotg->gadget.name = dev_name(dev);
3577         if (hsotg->dr_mode == USB_DR_MODE_OTG)
3578                 hsotg->gadget.is_otg = 1;
3579         else if (hsotg->dr_mode == USB_DR_MODE_PERIPHERAL)
3580                 hsotg->op_state = OTG_STATE_B_PERIPHERAL;
3581
3582         /*
3583          * Force Device mode before initialization.
3584          * This allows correctly configuring fifo for device mode.
3585          */
3586         __bic32(hsotg->regs + GUSBCFG, GUSBCFG_FORCEHOSTMODE);
3587         __orr32(hsotg->regs + GUSBCFG, GUSBCFG_FORCEDEVMODE);
3588
3589         /*
3590          * According to Synopsys databook, this sleep is needed for the force
3591          * device mode to take effect.
3592          */
3593         msleep(25);
3594
3595         dwc2_hsotg_corereset(hsotg);
3596         ret = dwc2_hsotg_hw_cfg(hsotg);
3597         if (ret) {
3598                 dev_err(hsotg->dev, "Hardware configuration failed: %d\n", ret);
3599                 return ret;
3600         }
3601
3602         dwc2_hsotg_init(hsotg);
3603
3604         /* Switch back to default configuration */
3605         __bic32(hsotg->regs + GUSBCFG, GUSBCFG_FORCEDEVMODE);
3606
3607         hsotg->ctrl_buff = devm_kzalloc(hsotg->dev,
3608                         DWC2_CTRL_BUFF_SIZE, GFP_KERNEL);
3609         if (!hsotg->ctrl_buff) {
3610                 dev_err(dev, "failed to allocate ctrl request buff\n");
3611                 return -ENOMEM;
3612         }
3613
3614         hsotg->ep0_buff = devm_kzalloc(hsotg->dev,
3615                         DWC2_CTRL_BUFF_SIZE, GFP_KERNEL);
3616         if (!hsotg->ep0_buff) {
3617                 dev_err(dev, "failed to allocate ctrl reply buff\n");
3618                 return -ENOMEM;
3619         }
3620
3621         ret = devm_request_irq(hsotg->dev, irq, dwc2_hsotg_irq, IRQF_SHARED,
3622                                 dev_name(hsotg->dev), hsotg);
3623         if (ret < 0) {
3624                 dev_err(dev, "cannot claim IRQ for gadget\n");
3625                 return ret;
3626         }
3627
3628         /* hsotg->num_of_eps holds number of EPs other than ep0 */
3629
3630         if (hsotg->num_of_eps == 0) {
3631                 dev_err(dev, "wrong number of EPs (zero)\n");
3632                 return -EINVAL;
3633         }
3634
3635         /* setup endpoint information */
3636
3637         INIT_LIST_HEAD(&hsotg->gadget.ep_list);
3638         hsotg->gadget.ep0 = &hsotg->eps_out[0]->ep;
3639
3640         /* allocate EP0 request */
3641
3642         hsotg->ctrl_req = dwc2_hsotg_ep_alloc_request(&hsotg->eps_out[0]->ep,
3643                                                      GFP_KERNEL);
3644         if (!hsotg->ctrl_req) {
3645                 dev_err(dev, "failed to allocate ctrl req\n");
3646                 return -ENOMEM;
3647         }
3648
3649         /* initialise the endpoints now the core has been initialised */
3650         for (epnum = 0; epnum < hsotg->num_of_eps; epnum++) {
3651                 if (hsotg->eps_in[epnum])
3652                         dwc2_hsotg_initep(hsotg, hsotg->eps_in[epnum],
3653                                                                 epnum, 1);
3654                 if (hsotg->eps_out[epnum])
3655                         dwc2_hsotg_initep(hsotg, hsotg->eps_out[epnum],
3656                                                                 epnum, 0);
3657         }
3658
3659         ret = usb_add_gadget_udc(dev, &hsotg->gadget);
3660         if (ret)
3661                 return ret;
3662
3663         dwc2_hsotg_dump(hsotg);
3664
3665         return 0;
3666 }
3667
3668 /**
3669  * dwc2_hsotg_remove - remove function for hsotg driver
3670  * @pdev: The platform information for the driver
3671  */
3672 int dwc2_hsotg_remove(struct dwc2_hsotg *hsotg)
3673 {
3674         usb_del_gadget_udc(&hsotg->gadget);
3675
3676         return 0;
3677 }
3678
3679 int dwc2_hsotg_suspend(struct dwc2_hsotg *hsotg)
3680 {
3681         unsigned long flags;
3682
3683         if (hsotg->lx_state != DWC2_L0)
3684                 return 0;
3685
3686         if (hsotg->driver) {
3687                 int ep;
3688
3689                 dev_info(hsotg->dev, "suspending usb gadget %s\n",
3690                          hsotg->driver->driver.name);
3691
3692                 spin_lock_irqsave(&hsotg->lock, flags);
3693                 if (hsotg->enabled)
3694                         dwc2_hsotg_core_disconnect(hsotg);
3695                 dwc2_hsotg_disconnect(hsotg);
3696                 hsotg->gadget.speed = USB_SPEED_UNKNOWN;
3697                 spin_unlock_irqrestore(&hsotg->lock, flags);
3698
3699                 for (ep = 0; ep < hsotg->num_of_eps; ep++) {
3700                         if (hsotg->eps_in[ep])
3701                                 dwc2_hsotg_ep_disable(&hsotg->eps_in[ep]->ep);
3702                         if (hsotg->eps_out[ep])
3703                                 dwc2_hsotg_ep_disable(&hsotg->eps_out[ep]->ep);
3704                 }
3705         }
3706
3707         return 0;
3708 }
3709
3710 int dwc2_hsotg_resume(struct dwc2_hsotg *hsotg)
3711 {
3712         unsigned long flags;
3713
3714         if (hsotg->lx_state == DWC2_L2)
3715                 return 0;
3716
3717         if (hsotg->driver) {
3718                 dev_info(hsotg->dev, "resuming usb gadget %s\n",
3719                          hsotg->driver->driver.name);
3720
3721                 spin_lock_irqsave(&hsotg->lock, flags);
3722                 dwc2_hsotg_core_init_disconnected(hsotg, false);
3723                 if (hsotg->enabled)
3724                         dwc2_hsotg_core_connect(hsotg);
3725                 spin_unlock_irqrestore(&hsotg->lock, flags);
3726         }
3727
3728         return 0;
3729 }