GNU Linux-libre 4.19.211-gnu1
[releases.git] / drivers / usb / gadget / udc / aspeed-vhub / epn.c
1 // SPDX-License-Identifier: GPL-2.0+
2 /*
3  * aspeed-vhub -- Driver for Aspeed SoC "vHub" USB gadget
4  *
5  * epn.c - Generic endpoints management
6  *
7  * Copyright 2017 IBM Corporation
8  *
9  * This program is free software; you can redistribute it and/or modify
10  * it under the terms of the GNU General Public License as published by
11  * the Free Software Foundation; either version 2 of the License, or
12  * (at your option) any later version.
13  */
14
15 #include <linux/kernel.h>
16 #include <linux/module.h>
17 #include <linux/platform_device.h>
18 #include <linux/delay.h>
19 #include <linux/ioport.h>
20 #include <linux/slab.h>
21 #include <linux/errno.h>
22 #include <linux/list.h>
23 #include <linux/interrupt.h>
24 #include <linux/proc_fs.h>
25 #include <linux/prefetch.h>
26 #include <linux/clk.h>
27 #include <linux/usb/gadget.h>
28 #include <linux/of.h>
29 #include <linux/of_gpio.h>
30 #include <linux/regmap.h>
31 #include <linux/dma-mapping.h>
32
33 #include "vhub.h"
34
35 #define EXTRA_CHECKS
36
37 #ifdef EXTRA_CHECKS
38 #define CHECK(ep, expr, fmt...)                                 \
39         do {                                                    \
40                 if (!(expr)) EPDBG(ep, "CHECK:" fmt);           \
41         } while(0)
42 #else
43 #define CHECK(ep, expr, fmt...) do { } while(0)
44 #endif
45
46 static void ast_vhub_epn_kick(struct ast_vhub_ep *ep, struct ast_vhub_req *req)
47 {
48         unsigned int act = req->req.actual;
49         unsigned int len = req->req.length;
50         unsigned int chunk;
51
52         /* There should be no DMA ongoing */
53         WARN_ON(req->active);
54
55         /* Calculate next chunk size */
56         chunk = len - act;
57         if (chunk > ep->ep.maxpacket)
58                 chunk = ep->ep.maxpacket;
59         else if ((chunk < ep->ep.maxpacket) || !req->req.zero)
60                 req->last_desc = 1;
61
62         EPVDBG(ep, "kick req %p act=%d/%d chunk=%d last=%d\n",
63                req, act, len, chunk, req->last_desc);
64
65         /* If DMA unavailable, using staging EP buffer */
66         if (!req->req.dma) {
67
68                 /* For IN transfers, copy data over first */
69                 if (ep->epn.is_in) {
70                         memcpy(ep->buf, req->req.buf + act, chunk);
71                         vhub_dma_workaround(ep->buf);
72                 }
73                 writel(ep->buf_dma, ep->epn.regs + AST_VHUB_EP_DESC_BASE);
74         } else {
75                 if (ep->epn.is_in)
76                         vhub_dma_workaround(req->req.buf);
77                 writel(req->req.dma + act, ep->epn.regs + AST_VHUB_EP_DESC_BASE);
78         }
79
80         /* Start DMA */
81         req->active = true;
82         writel(VHUB_EP_DMA_SET_TX_SIZE(chunk),
83                ep->epn.regs + AST_VHUB_EP_DESC_STATUS);
84         writel(VHUB_EP_DMA_SET_TX_SIZE(chunk) | VHUB_EP_DMA_SINGLE_KICK,
85                ep->epn.regs + AST_VHUB_EP_DESC_STATUS);
86 }
87
88 static void ast_vhub_epn_handle_ack(struct ast_vhub_ep *ep)
89 {
90         struct ast_vhub_req *req;
91         unsigned int len;
92         u32 stat;
93
94         /* Read EP status */
95         stat = readl(ep->epn.regs + AST_VHUB_EP_DESC_STATUS);
96
97         /* Grab current request if any */
98         req = list_first_entry_or_null(&ep->queue, struct ast_vhub_req, queue);
99
100         EPVDBG(ep, "ACK status=%08x is_in=%d, req=%p (active=%d)\n",
101                stat, ep->epn.is_in, req, req ? req->active : 0);
102
103         /* In absence of a request, bail out, must have been dequeued */
104         if (!req)
105                 return;
106
107         /*
108          * Request not active, move on to processing queue, active request
109          * was probably dequeued
110          */
111         if (!req->active)
112                 goto next_chunk;
113
114         /* Check if HW has moved on */
115         if (VHUB_EP_DMA_RPTR(stat) != 0) {
116                 EPDBG(ep, "DMA read pointer not 0 !\n");
117                 return;
118         }
119
120         /* No current DMA ongoing */
121         req->active = false;
122
123         /* Grab lenght out of HW */
124         len = VHUB_EP_DMA_TX_SIZE(stat);
125
126         /* If not using DMA, copy data out if needed */
127         if (!req->req.dma && !ep->epn.is_in && len)
128                 memcpy(req->req.buf + req->req.actual, ep->buf, len);
129
130         /* Adjust size */
131         req->req.actual += len;
132
133         /* Check for short packet */
134         if (len < ep->ep.maxpacket)
135                 req->last_desc = 1;
136
137         /* That's it ? complete the request and pick a new one */
138         if (req->last_desc >= 0) {
139                 ast_vhub_done(ep, req, 0);
140                 req = list_first_entry_or_null(&ep->queue, struct ast_vhub_req,
141                                                queue);
142
143                 /*
144                  * Due to lock dropping inside "done" the next request could
145                  * already be active, so check for that and bail if needed.
146                  */
147                 if (!req || req->active)
148                         return;
149         }
150
151  next_chunk:
152         ast_vhub_epn_kick(ep, req);
153 }
154
155 static inline unsigned int ast_vhub_count_free_descs(struct ast_vhub_ep *ep)
156 {
157         /*
158          * d_next == d_last means descriptor list empty to HW,
159          * thus we can only have AST_VHUB_DESCS_COUNT-1 descriptors
160          * in the list
161          */
162         return (ep->epn.d_last + AST_VHUB_DESCS_COUNT - ep->epn.d_next - 1) &
163                 (AST_VHUB_DESCS_COUNT - 1);
164 }
165
166 static void ast_vhub_epn_kick_desc(struct ast_vhub_ep *ep,
167                                    struct ast_vhub_req *req)
168 {
169         struct ast_vhub_desc *desc = NULL;
170         unsigned int act = req->act_count;
171         unsigned int len = req->req.length;
172         unsigned int chunk;
173
174         /* Mark request active if not already */
175         req->active = true;
176
177         /* If the request was already completely written, do nothing */
178         if (req->last_desc >= 0)
179                 return;
180
181         EPVDBG(ep, "kick act=%d/%d chunk_max=%d free_descs=%d\n",
182                act, len, ep->epn.chunk_max, ast_vhub_count_free_descs(ep));
183
184         /* While we can create descriptors */
185         while (ast_vhub_count_free_descs(ep) && req->last_desc < 0) {
186                 unsigned int d_num;
187
188                 /* Grab next free descriptor */
189                 d_num = ep->epn.d_next;
190                 desc = &ep->epn.descs[d_num];
191                 ep->epn.d_next = (d_num + 1) & (AST_VHUB_DESCS_COUNT - 1);
192
193                 /* Calculate next chunk size */
194                 chunk = len - act;
195                 if (chunk <= ep->epn.chunk_max) {
196                         /*
197                          * Is this the last packet ? Because of having up to 8
198                          * packets in a descriptor we can't just compare "chunk"
199                          * with ep.maxpacket. We have to see if it's a multiple
200                          * of it to know if we have to send a zero packet.
201                          * Sadly that involves a modulo which is a bit expensive
202                          * but probably still better than not doing it.
203                          */
204                         if (!chunk || !req->req.zero || (chunk % ep->ep.maxpacket) != 0)
205                                 req->last_desc = d_num;
206                 } else {
207                         chunk = ep->epn.chunk_max;
208                 }
209
210                 EPVDBG(ep, " chunk: act=%d/%d chunk=%d last=%d desc=%d free=%d\n",
211                        act, len, chunk, req->last_desc, d_num,
212                        ast_vhub_count_free_descs(ep));
213
214                 /* Populate descriptor */
215                 desc->w0 = cpu_to_le32(req->req.dma + act);
216
217                 /* Interrupt if end of request or no more descriptors */
218
219                 /*
220                  * TODO: Be smarter about it, if we don't have enough
221                  * descriptors request an interrupt before queue empty
222                  * or so in order to be able to populate more before
223                  * the HW runs out. This isn't a problem at the moment
224                  * as we use 256 descriptors and only put at most one
225                  * request in the ring.
226                  */
227                 desc->w1 = cpu_to_le32(VHUB_DSC1_IN_SET_LEN(chunk));
228                 if (req->last_desc >= 0 || !ast_vhub_count_free_descs(ep))
229                         desc->w1 |= cpu_to_le32(VHUB_DSC1_IN_INTERRUPT);
230
231                 /* Account packet */
232                 req->act_count = act = act + chunk;
233         }
234
235         if (likely(desc))
236                 vhub_dma_workaround(desc);
237
238         /* Tell HW about new descriptors */
239         writel(VHUB_EP_DMA_SET_CPU_WPTR(ep->epn.d_next),
240                ep->epn.regs + AST_VHUB_EP_DESC_STATUS);
241
242         EPVDBG(ep, "HW kicked, d_next=%d dstat=%08x\n",
243                ep->epn.d_next, readl(ep->epn.regs + AST_VHUB_EP_DESC_STATUS));
244 }
245
246 static void ast_vhub_epn_handle_ack_desc(struct ast_vhub_ep *ep)
247 {
248         struct ast_vhub_req *req;
249         unsigned int len, d_last;
250         u32 stat, stat1;
251
252         /* Read EP status, workaround HW race */
253         do {
254                 stat = readl(ep->epn.regs + AST_VHUB_EP_DESC_STATUS);
255                 stat1 = readl(ep->epn.regs + AST_VHUB_EP_DESC_STATUS);
256         } while(stat != stat1);
257
258         /* Extract RPTR */
259         d_last = VHUB_EP_DMA_RPTR(stat);
260
261         /* Grab current request if any */
262         req = list_first_entry_or_null(&ep->queue, struct ast_vhub_req, queue);
263
264         EPVDBG(ep, "ACK status=%08x is_in=%d ep->d_last=%d..%d\n",
265                stat, ep->epn.is_in, ep->epn.d_last, d_last);
266
267         /* Check all completed descriptors */
268         while (ep->epn.d_last != d_last) {
269                 struct ast_vhub_desc *desc;
270                 unsigned int d_num;
271                 bool is_last_desc;
272
273                 /* Grab next completed descriptor */
274                 d_num = ep->epn.d_last;
275                 desc = &ep->epn.descs[d_num];
276                 ep->epn.d_last = (d_num + 1) & (AST_VHUB_DESCS_COUNT - 1);
277
278                 /* Grab len out of descriptor */
279                 len = VHUB_DSC1_IN_LEN(le32_to_cpu(desc->w1));
280
281                 EPVDBG(ep, " desc %d len=%d req=%p (act=%d)\n",
282                        d_num, len, req, req ? req->active : 0);
283
284                 /* If no active request pending, move on */
285                 if (!req || !req->active)
286                         continue;
287
288                 /* Adjust size */
289                 req->req.actual += len;
290
291                 /* Is that the last chunk ? */
292                 is_last_desc = req->last_desc == d_num;
293                 CHECK(ep, is_last_desc == (len < ep->ep.maxpacket ||
294                                            (req->req.actual >= req->req.length &&
295                                             !req->req.zero)),
296                       "Last packet discrepancy: last_desc=%d len=%d r.act=%d "
297                       "r.len=%d r.zero=%d mp=%d\n",
298                       is_last_desc, len, req->req.actual, req->req.length,
299                       req->req.zero, ep->ep.maxpacket);
300
301                 if (is_last_desc) {
302                         /*
303                          * Because we can only have one request at a time
304                          * in our descriptor list in this implementation,
305                          * d_last and ep->d_last should now be equal
306                          */
307                         CHECK(ep, d_last == ep->epn.d_last,
308                               "DMA read ptr mismatch %d vs %d\n",
309                               d_last, ep->epn.d_last);
310
311                         /* Note: done will drop and re-acquire the lock */
312                         ast_vhub_done(ep, req, 0);
313                         req = list_first_entry_or_null(&ep->queue,
314                                                        struct ast_vhub_req,
315                                                        queue);
316                         break;
317                 }
318         }
319
320         /* More work ? */
321         if (req)
322                 ast_vhub_epn_kick_desc(ep, req);
323 }
324
325 void ast_vhub_epn_ack_irq(struct ast_vhub_ep *ep)
326 {
327         if (ep->epn.desc_mode)
328                 ast_vhub_epn_handle_ack_desc(ep);
329         else
330                 ast_vhub_epn_handle_ack(ep);
331 }
332
333 static int ast_vhub_epn_queue(struct usb_ep* u_ep, struct usb_request *u_req,
334                               gfp_t gfp_flags)
335 {
336         struct ast_vhub_req *req = to_ast_req(u_req);
337         struct ast_vhub_ep *ep = to_ast_ep(u_ep);
338         struct ast_vhub *vhub = ep->vhub;
339         unsigned long flags;
340         bool empty;
341         int rc;
342
343         /* Paranoid checks */
344         if (!u_req || !u_req->complete || !u_req->buf) {
345                 dev_warn(&vhub->pdev->dev, "Bogus EPn request ! u_req=%p\n", u_req);
346                 if (u_req) {
347                         dev_warn(&vhub->pdev->dev, "complete=%p internal=%d\n",
348                                  u_req->complete, req->internal);
349                 }
350                 return -EINVAL;
351         }
352
353         /* Endpoint enabled ? */
354         if (!ep->epn.enabled || !u_ep->desc || !ep->dev || !ep->d_idx ||
355             !ep->dev->enabled || ep->dev->suspended) {
356                 EPDBG(ep,"Enqueing request on wrong or disabled EP\n");
357                 return -ESHUTDOWN;
358         }
359
360         /* Map request for DMA if possible. For now, the rule for DMA is
361          * that:
362          *
363          *  * For single stage mode (no descriptors):
364          *
365          *   - The buffer is aligned to a 8 bytes boundary (HW requirement)
366          *   - For a OUT endpoint, the request size is a multiple of the EP
367          *     packet size (otherwise the controller will DMA past the end
368          *     of the buffer if the host is sending a too long packet).
369          *
370          *  * For descriptor mode (tx only for now), always.
371          *
372          * We could relax the latter by making the decision to use the bounce
373          * buffer based on the size of a given *segment* of the request rather
374          * than the whole request.
375          */
376         if (ep->epn.desc_mode ||
377             ((((unsigned long)u_req->buf & 7) == 0) &&
378              (ep->epn.is_in || !(u_req->length & (u_ep->maxpacket - 1))))) {
379                 rc = usb_gadget_map_request_by_dev(&vhub->pdev->dev, u_req,
380                                             ep->epn.is_in);
381                 if (rc) {
382                         dev_warn(&vhub->pdev->dev,
383                                  "Request mapping failure %d\n", rc);
384                         return rc;
385                 }
386         } else
387                 u_req->dma = 0;
388
389         EPVDBG(ep, "enqueue req @%p\n", req);
390         EPVDBG(ep, " l=%d dma=0x%x zero=%d noshort=%d noirq=%d is_in=%d\n",
391                u_req->length, (u32)u_req->dma, u_req->zero,
392                u_req->short_not_ok, u_req->no_interrupt,
393                ep->epn.is_in);
394
395         /* Initialize request progress fields */
396         u_req->status = -EINPROGRESS;
397         u_req->actual = 0;
398         req->act_count = 0;
399         req->active = false;
400         req->last_desc = -1;
401         spin_lock_irqsave(&vhub->lock, flags);
402         empty = list_empty(&ep->queue);
403
404         /* Add request to list and kick processing if empty */
405         list_add_tail(&req->queue, &ep->queue);
406         if (empty) {
407                 if (ep->epn.desc_mode)
408                         ast_vhub_epn_kick_desc(ep, req);
409                 else
410                         ast_vhub_epn_kick(ep, req);
411         }
412         spin_unlock_irqrestore(&vhub->lock, flags);
413
414         return 0;
415 }
416
417 static void ast_vhub_stop_active_req(struct ast_vhub_ep *ep,
418                                      bool restart_ep)
419 {
420         u32 state, reg, loops;
421
422         /* Stop DMA activity */
423         if (ep->epn.desc_mode)
424                 writel(VHUB_EP_DMA_CTRL_RESET, ep->epn.regs + AST_VHUB_EP_DMA_CTLSTAT);
425         else
426                 writel(0, ep->epn.regs + AST_VHUB_EP_DMA_CTLSTAT);
427
428         /* Wait for it to complete */
429         for (loops = 0; loops < 1000; loops++) {
430                 state = readl(ep->epn.regs + AST_VHUB_EP_DMA_CTLSTAT);
431                 state = VHUB_EP_DMA_PROC_STATUS(state);
432                 if (state == EP_DMA_PROC_RX_IDLE ||
433                     state == EP_DMA_PROC_TX_IDLE)
434                         break;
435                 udelay(1);
436         }
437         if (loops >= 1000)
438                 dev_warn(&ep->vhub->pdev->dev, "Timeout waiting for DMA\n");
439
440         /* If we don't have to restart the endpoint, that's it */
441         if (!restart_ep)
442                 return;
443
444         /* Restart the endpoint */
445         if (ep->epn.desc_mode) {
446                 /*
447                  * Take out descriptors by resetting the DMA read
448                  * pointer to be equal to the CPU write pointer.
449                  *
450                  * Note: If we ever support creating descriptors for
451                  * requests that aren't the head of the queue, we
452                  * may have to do something more complex here,
453                  * especially if the request being taken out is
454                  * not the current head descriptors.
455                  */
456                 reg = VHUB_EP_DMA_SET_RPTR(ep->epn.d_next) |
457                         VHUB_EP_DMA_SET_CPU_WPTR(ep->epn.d_next);
458                 writel(reg, ep->epn.regs + AST_VHUB_EP_DESC_STATUS);
459
460                 /* Then turn it back on */
461                 writel(ep->epn.dma_conf,
462                        ep->epn.regs + AST_VHUB_EP_DMA_CTLSTAT);
463         } else {
464                 /* Single mode: just turn it back on */
465                 writel(ep->epn.dma_conf,
466                        ep->epn.regs + AST_VHUB_EP_DMA_CTLSTAT);
467         }
468 }
469
470 static int ast_vhub_epn_dequeue(struct usb_ep* u_ep, struct usb_request *u_req)
471 {
472         struct ast_vhub_ep *ep = to_ast_ep(u_ep);
473         struct ast_vhub *vhub = ep->vhub;
474         struct ast_vhub_req *req;
475         unsigned long flags;
476         int rc = -EINVAL;
477
478         spin_lock_irqsave(&vhub->lock, flags);
479
480         /* Make sure it's actually queued on this endpoint */
481         list_for_each_entry (req, &ep->queue, queue) {
482                 if (&req->req == u_req)
483                         break;
484         }
485
486         if (&req->req == u_req) {
487                 EPVDBG(ep, "dequeue req @%p active=%d\n",
488                        req, req->active);
489                 if (req->active)
490                         ast_vhub_stop_active_req(ep, true);
491                 ast_vhub_done(ep, req, -ECONNRESET);
492                 rc = 0;
493         }
494
495         spin_unlock_irqrestore(&vhub->lock, flags);
496         return rc;
497 }
498
499 void ast_vhub_update_epn_stall(struct ast_vhub_ep *ep)
500 {
501         u32 reg;
502
503         if (WARN_ON(ep->d_idx == 0))
504                 return;
505         reg = readl(ep->epn.regs + AST_VHUB_EP_CONFIG);
506         if (ep->epn.stalled || ep->epn.wedged)
507                 reg |= VHUB_EP_CFG_STALL_CTRL;
508         else
509                 reg &= ~VHUB_EP_CFG_STALL_CTRL;
510         writel(reg, ep->epn.regs + AST_VHUB_EP_CONFIG);
511
512         if (!ep->epn.stalled && !ep->epn.wedged)
513                 writel(VHUB_EP_TOGGLE_SET_EPNUM(ep->epn.g_idx),
514                        ep->vhub->regs + AST_VHUB_EP_TOGGLE);
515 }
516
517 static int ast_vhub_set_halt_and_wedge(struct usb_ep* u_ep, bool halt,
518                                       bool wedge)
519 {
520         struct ast_vhub_ep *ep = to_ast_ep(u_ep);
521         struct ast_vhub *vhub = ep->vhub;
522         unsigned long flags;
523
524         EPDBG(ep, "Set halt (%d) & wedge (%d)\n", halt, wedge);
525
526         if (!u_ep || !u_ep->desc)
527                 return -EINVAL;
528         if (ep->d_idx == 0)
529                 return 0;
530         if (ep->epn.is_iso)
531                 return -EOPNOTSUPP;
532
533         spin_lock_irqsave(&vhub->lock, flags);
534
535         /* Fail with still-busy IN endpoints */
536         if (halt && ep->epn.is_in && !list_empty(&ep->queue)) {
537                 spin_unlock_irqrestore(&vhub->lock, flags);
538                 return -EAGAIN;
539         }
540         ep->epn.stalled = halt;
541         ep->epn.wedged = wedge;
542         ast_vhub_update_epn_stall(ep);
543
544         spin_unlock_irqrestore(&vhub->lock, flags);
545
546         return 0;
547 }
548
549 static int ast_vhub_epn_set_halt(struct usb_ep *u_ep, int value)
550 {
551         return ast_vhub_set_halt_and_wedge(u_ep, value != 0, false);
552 }
553
554 static int ast_vhub_epn_set_wedge(struct usb_ep *u_ep)
555 {
556         return ast_vhub_set_halt_and_wedge(u_ep, true, true);
557 }
558
559 static int ast_vhub_epn_disable(struct usb_ep* u_ep)
560 {
561         struct ast_vhub_ep *ep = to_ast_ep(u_ep);
562         struct ast_vhub *vhub = ep->vhub;
563         unsigned long flags;
564         u32 imask, ep_ier;
565
566         EPDBG(ep, "Disabling !\n");
567
568         spin_lock_irqsave(&vhub->lock, flags);
569
570         ep->epn.enabled = false;
571
572         /* Stop active DMA if any */
573         ast_vhub_stop_active_req(ep, false);
574
575         /* Disable endpoint */
576         writel(0, ep->epn.regs + AST_VHUB_EP_CONFIG);
577
578         /* Disable ACK interrupt */
579         imask = VHUB_EP_IRQ(ep->epn.g_idx);
580         ep_ier = readl(vhub->regs + AST_VHUB_EP_ACK_IER);
581         ep_ier &= ~imask;
582         writel(ep_ier, vhub->regs + AST_VHUB_EP_ACK_IER);
583         writel(imask, vhub->regs + AST_VHUB_EP_ACK_ISR);
584
585         /* Nuke all pending requests */
586         ast_vhub_nuke(ep, -ESHUTDOWN);
587
588         /* No more descriptor associated with request */
589         ep->ep.desc = NULL;
590
591         spin_unlock_irqrestore(&vhub->lock, flags);
592
593         return 0;
594 }
595
596 static int ast_vhub_epn_enable(struct usb_ep* u_ep,
597                                const struct usb_endpoint_descriptor *desc)
598 {
599         static const char *ep_type_string[] __maybe_unused = { "ctrl",
600                                                                "isoc",
601                                                                "bulk",
602                                                                "intr" };
603         struct ast_vhub_ep *ep = to_ast_ep(u_ep);
604         struct ast_vhub_dev *dev;
605         struct ast_vhub *vhub;
606         u16 maxpacket, type;
607         unsigned long flags;
608         u32 ep_conf, ep_ier, imask;
609
610         /* Check arguments */
611         if (!u_ep || !desc)
612                 return -EINVAL;
613
614         maxpacket = usb_endpoint_maxp(desc);
615         if (!ep->d_idx || !ep->dev ||
616             desc->bDescriptorType != USB_DT_ENDPOINT ||
617             maxpacket == 0 || maxpacket > ep->ep.maxpacket) {
618                 EPDBG(ep, "Invalid EP enable,d_idx=%d,dev=%p,type=%d,mp=%d/%d\n",
619                       ep->d_idx, ep->dev, desc->bDescriptorType,
620                       maxpacket, ep->ep.maxpacket);
621                 return -EINVAL;
622         }
623         if (ep->d_idx != usb_endpoint_num(desc)) {
624                 EPDBG(ep, "EP number mismatch !\n");
625                 return -EINVAL;
626         }
627
628         if (ep->epn.enabled) {
629                 EPDBG(ep, "Already enabled\n");
630                 return -EBUSY;
631         }
632         dev = ep->dev;
633         vhub = ep->vhub;
634
635         /* Check device state */
636         if (!dev->driver) {
637                 EPDBG(ep, "Bogus device state: driver=%p speed=%d\n",
638                        dev->driver, dev->gadget.speed);
639                 return -ESHUTDOWN;
640         }
641
642         /* Grab some info from the descriptor */
643         ep->epn.is_in = usb_endpoint_dir_in(desc);
644         ep->ep.maxpacket = maxpacket;
645         type = usb_endpoint_type(desc);
646         ep->epn.d_next = ep->epn.d_last = 0;
647         ep->epn.is_iso = false;
648         ep->epn.stalled = false;
649         ep->epn.wedged = false;
650
651         EPDBG(ep, "Enabling [%s] %s num %d maxpacket=%d\n",
652               ep->epn.is_in ? "in" : "out", ep_type_string[type],
653               usb_endpoint_num(desc), maxpacket);
654
655         /* Can we use DMA descriptor mode ? */
656         ep->epn.desc_mode = ep->epn.descs && ep->epn.is_in;
657         if (ep->epn.desc_mode)
658                 memset(ep->epn.descs, 0, 8 * AST_VHUB_DESCS_COUNT);
659
660         /*
661          * Large send function can send up to 8 packets from
662          * one descriptor with a limit of 4095 bytes.
663          */
664         ep->epn.chunk_max = ep->ep.maxpacket;
665         if (ep->epn.is_in) {
666                 ep->epn.chunk_max <<= 3;
667                 while (ep->epn.chunk_max > 4095)
668                         ep->epn.chunk_max -= ep->ep.maxpacket;
669         }
670
671         switch(type) {
672         case USB_ENDPOINT_XFER_CONTROL:
673                 EPDBG(ep, "Only one control endpoint\n");
674                 return -EINVAL;
675         case USB_ENDPOINT_XFER_INT:
676                 ep_conf = VHUB_EP_CFG_SET_TYPE(EP_TYPE_INT);
677                 break;
678         case USB_ENDPOINT_XFER_BULK:
679                 ep_conf = VHUB_EP_CFG_SET_TYPE(EP_TYPE_BULK);
680                 break;
681         case USB_ENDPOINT_XFER_ISOC:
682                 ep_conf = VHUB_EP_CFG_SET_TYPE(EP_TYPE_ISO);
683                 ep->epn.is_iso = true;
684                 break;
685         default:
686                 return -EINVAL;
687         }
688
689         /* Encode the rest of the EP config register */
690         if (maxpacket < 1024)
691                 ep_conf |= VHUB_EP_CFG_SET_MAX_PKT(maxpacket);
692         if (!ep->epn.is_in)
693                 ep_conf |= VHUB_EP_CFG_DIR_OUT;
694         ep_conf |= VHUB_EP_CFG_SET_EP_NUM(usb_endpoint_num(desc));
695         ep_conf |= VHUB_EP_CFG_ENABLE;
696         ep_conf |= VHUB_EP_CFG_SET_DEV(dev->index + 1);
697         EPVDBG(ep, "config=%08x\n", ep_conf);
698
699         spin_lock_irqsave(&vhub->lock, flags);
700
701         /* Disable HW and reset DMA */
702         writel(0, ep->epn.regs + AST_VHUB_EP_CONFIG);
703         writel(VHUB_EP_DMA_CTRL_RESET,
704                ep->epn.regs + AST_VHUB_EP_DMA_CTLSTAT);
705
706         /* Configure and enable */
707         writel(ep_conf, ep->epn.regs + AST_VHUB_EP_CONFIG);
708
709         if (ep->epn.desc_mode) {
710                 /* Clear DMA status, including the DMA read ptr */
711                 writel(0, ep->epn.regs + AST_VHUB_EP_DESC_STATUS);
712
713                 /* Set descriptor base */
714                 writel(ep->epn.descs_dma,
715                        ep->epn.regs + AST_VHUB_EP_DESC_BASE);
716
717                 /* Set base DMA config value */
718                 ep->epn.dma_conf = VHUB_EP_DMA_DESC_MODE;
719                 if (ep->epn.is_in)
720                         ep->epn.dma_conf |= VHUB_EP_DMA_IN_LONG_MODE;
721
722                 /* First reset and disable all operations */
723                 writel(ep->epn.dma_conf | VHUB_EP_DMA_CTRL_RESET,
724                        ep->epn.regs + AST_VHUB_EP_DMA_CTLSTAT);
725
726                 /* Enable descriptor mode */
727                 writel(ep->epn.dma_conf,
728                        ep->epn.regs + AST_VHUB_EP_DMA_CTLSTAT);
729         } else {
730                 /* Set base DMA config value */
731                 ep->epn.dma_conf = VHUB_EP_DMA_SINGLE_STAGE;
732
733                 /* Reset and switch to single stage mode */
734                 writel(ep->epn.dma_conf | VHUB_EP_DMA_CTRL_RESET,
735                        ep->epn.regs + AST_VHUB_EP_DMA_CTLSTAT);
736                 writel(ep->epn.dma_conf,
737                        ep->epn.regs + AST_VHUB_EP_DMA_CTLSTAT);
738                 writel(0, ep->epn.regs + AST_VHUB_EP_DESC_STATUS);
739         }
740
741         /* Cleanup data toggle just in case */
742         writel(VHUB_EP_TOGGLE_SET_EPNUM(ep->epn.g_idx),
743                vhub->regs + AST_VHUB_EP_TOGGLE);
744
745         /* Cleanup and enable ACK interrupt */
746         imask = VHUB_EP_IRQ(ep->epn.g_idx);
747         writel(imask, vhub->regs + AST_VHUB_EP_ACK_ISR);
748         ep_ier = readl(vhub->regs + AST_VHUB_EP_ACK_IER);
749         ep_ier |= imask;
750         writel(ep_ier, vhub->regs + AST_VHUB_EP_ACK_IER);
751
752         /* Woot, we are online ! */
753         ep->epn.enabled = true;
754
755         spin_unlock_irqrestore(&vhub->lock, flags);
756
757         return 0;
758 }
759
760 static void ast_vhub_epn_dispose(struct usb_ep *u_ep)
761 {
762         struct ast_vhub_ep *ep = to_ast_ep(u_ep);
763
764         if (WARN_ON(!ep->dev || !ep->d_idx))
765                 return;
766
767         EPDBG(ep, "Releasing endpoint\n");
768
769         /* Take it out of the EP list */
770         list_del_init(&ep->ep.ep_list);
771
772         /* Mark the address free in the device */
773         ep->dev->epns[ep->d_idx - 1] = NULL;
774
775         /* Free name & DMA buffers */
776         kfree(ep->ep.name);
777         ep->ep.name = NULL;
778         dma_free_coherent(&ep->vhub->pdev->dev,
779                           AST_VHUB_EPn_MAX_PACKET +
780                           8 * AST_VHUB_DESCS_COUNT,
781                           ep->buf, ep->buf_dma);
782         ep->buf = NULL;
783         ep->epn.descs = NULL;
784
785         /* Mark free */
786         ep->dev = NULL;
787 }
788
789 static const struct usb_ep_ops ast_vhub_epn_ops = {
790         .enable         = ast_vhub_epn_enable,
791         .disable        = ast_vhub_epn_disable,
792         .dispose        = ast_vhub_epn_dispose,
793         .queue          = ast_vhub_epn_queue,
794         .dequeue        = ast_vhub_epn_dequeue,
795         .set_halt       = ast_vhub_epn_set_halt,
796         .set_wedge      = ast_vhub_epn_set_wedge,
797         .alloc_request  = ast_vhub_alloc_request,
798         .free_request   = ast_vhub_free_request,
799 };
800
801 struct ast_vhub_ep *ast_vhub_alloc_epn(struct ast_vhub_dev *d, u8 addr)
802 {
803         struct ast_vhub *vhub = d->vhub;
804         struct ast_vhub_ep *ep;
805         unsigned long flags;
806         int i;
807
808         /* Find a free one (no device) */
809         spin_lock_irqsave(&vhub->lock, flags);
810         for (i = 0; i < AST_VHUB_NUM_GEN_EPs; i++)
811                 if (vhub->epns[i].dev == NULL)
812                         break;
813         if (i >= AST_VHUB_NUM_GEN_EPs) {
814                 spin_unlock_irqrestore(&vhub->lock, flags);
815                 return NULL;
816         }
817
818         /* Set it up */
819         ep = &vhub->epns[i];
820         ep->dev = d;
821         spin_unlock_irqrestore(&vhub->lock, flags);
822
823         DDBG(d, "Allocating gen EP %d for addr %d\n", i, addr);
824         INIT_LIST_HEAD(&ep->queue);
825         ep->d_idx = addr;
826         ep->vhub = vhub;
827         ep->ep.ops = &ast_vhub_epn_ops;
828         ep->ep.name = kasprintf(GFP_KERNEL, "ep%d", addr);
829         d->epns[addr-1] = ep;
830         ep->epn.g_idx = i;
831         ep->epn.regs = vhub->regs + 0x200 + (i * 0x10);
832
833         ep->buf = dma_alloc_coherent(&vhub->pdev->dev,
834                                      AST_VHUB_EPn_MAX_PACKET +
835                                      8 * AST_VHUB_DESCS_COUNT,
836                                      &ep->buf_dma, GFP_KERNEL);
837         if (!ep->buf) {
838                 kfree(ep->ep.name);
839                 ep->ep.name = NULL;
840                 return NULL;
841         }
842         ep->epn.descs = ep->buf + AST_VHUB_EPn_MAX_PACKET;
843         ep->epn.descs_dma = ep->buf_dma + AST_VHUB_EPn_MAX_PACKET;
844
845         usb_ep_set_maxpacket_limit(&ep->ep, AST_VHUB_EPn_MAX_PACKET);
846         list_add_tail(&ep->ep.ep_list, &d->gadget.ep_list);
847         ep->ep.caps.type_iso = true;
848         ep->ep.caps.type_bulk = true;
849         ep->ep.caps.type_int = true;
850         ep->ep.caps.dir_in = true;
851         ep->ep.caps.dir_out = true;
852
853         return ep;
854 }