This source file includes following definitions.
- ast_vhub_epn_kick
- ast_vhub_epn_handle_ack
- ast_vhub_count_free_descs
- ast_vhub_epn_kick_desc
- ast_vhub_epn_handle_ack_desc
- ast_vhub_epn_ack_irq
- ast_vhub_epn_queue
- ast_vhub_stop_active_req
- ast_vhub_epn_dequeue
- ast_vhub_update_epn_stall
- ast_vhub_set_halt_and_wedge
- ast_vhub_epn_set_halt
- ast_vhub_epn_set_wedge
- ast_vhub_epn_disable
- ast_vhub_epn_enable
- ast_vhub_epn_dispose
- ast_vhub_alloc_epn
1
2
3
4
5
6
7
8
9
10
11
12
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
53 WARN_ON(req->active);
54
55
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
66 if (!req->req.dma) {
67
68
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
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
95 stat = readl(ep->epn.regs + AST_VHUB_EP_DESC_STATUS);
96
97
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
104 if (!req)
105 return;
106
107
108
109
110
111 if (!req->active)
112 goto next_chunk;
113
114
115 if (VHUB_EP_DMA_RPTR(stat) != 0) {
116 EPDBG(ep, "DMA read pointer not 0 !\n");
117 return;
118 }
119
120
121 req->active = false;
122
123
124 len = VHUB_EP_DMA_TX_SIZE(stat);
125
126
127 if (!req->req.dma && !ep->epn.is_in && len)
128 memcpy(req->req.buf + req->req.actual, ep->buf, len);
129
130
131 req->req.actual += len;
132
133
134 if (len < ep->ep.maxpacket)
135 req->last_desc = 1;
136
137
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
145
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
159
160
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
175 req->active = true;
176
177
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
185 while (ast_vhub_count_free_descs(ep) && req->last_desc < 0) {
186 unsigned int d_num;
187
188
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
194 chunk = len - act;
195 if (chunk <= ep->epn.chunk_max) {
196
197
198
199
200
201
202
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
215 desc->w0 = cpu_to_le32(req->req.dma + act);
216
217
218
219
220
221
222
223
224
225
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
232 req->act_count = act = act + chunk;
233 }
234
235 if (likely(desc))
236 vhub_dma_workaround(desc);
237
238
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
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
259 d_last = VHUB_EP_DMA_RPTR(stat);
260
261
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
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
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
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
285 if (!req || !req->active)
286 continue;
287
288
289 req->req.actual += len;
290
291
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
304
305
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
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
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
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
354 if (!ep->epn.enabled || !u_ep->desc || !ep->dev || !ep->d_idx ||
355 !ep->dev->enabled) {
356 EPDBG(ep, "Enqueuing request on wrong or disabled EP\n");
357 return -ESHUTDOWN;
358 }
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
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(&ep->dev->gadget, 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
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
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
423 writel(0, ep->epn.regs + AST_VHUB_EP_DMA_CTLSTAT);
424
425
426 for (loops = 0; loops < 1000; loops++) {
427 state = readl(ep->epn.regs + AST_VHUB_EP_DMA_CTLSTAT);
428 state = VHUB_EP_DMA_PROC_STATUS(state);
429 if (state == EP_DMA_PROC_RX_IDLE ||
430 state == EP_DMA_PROC_TX_IDLE)
431 break;
432 udelay(1);
433 }
434 if (loops >= 1000)
435 dev_warn(&ep->vhub->pdev->dev, "Timeout waiting for DMA\n");
436
437
438 if (!restart_ep)
439 return;
440
441
442 if (ep->epn.desc_mode) {
443
444
445
446
447
448
449
450
451
452
453 reg = VHUB_EP_DMA_SET_RPTR(ep->epn.d_next) |
454 VHUB_EP_DMA_SET_CPU_WPTR(ep->epn.d_next);
455 writel(reg, ep->epn.regs + AST_VHUB_EP_DESC_STATUS);
456
457
458 writel(ep->epn.dma_conf,
459 ep->epn.regs + AST_VHUB_EP_DMA_CTLSTAT);
460 } else {
461
462 writel(ep->epn.dma_conf,
463 ep->epn.regs + AST_VHUB_EP_DMA_CTLSTAT);
464 }
465 }
466
467 static int ast_vhub_epn_dequeue(struct usb_ep* u_ep, struct usb_request *u_req)
468 {
469 struct ast_vhub_ep *ep = to_ast_ep(u_ep);
470 struct ast_vhub *vhub = ep->vhub;
471 struct ast_vhub_req *req;
472 unsigned long flags;
473 int rc = -EINVAL;
474
475 spin_lock_irqsave(&vhub->lock, flags);
476
477
478 list_for_each_entry (req, &ep->queue, queue) {
479 if (&req->req == u_req)
480 break;
481 }
482
483 if (&req->req == u_req) {
484 EPVDBG(ep, "dequeue req @%p active=%d\n",
485 req, req->active);
486 if (req->active)
487 ast_vhub_stop_active_req(ep, true);
488 ast_vhub_done(ep, req, -ECONNRESET);
489 rc = 0;
490 }
491
492 spin_unlock_irqrestore(&vhub->lock, flags);
493 return rc;
494 }
495
496 void ast_vhub_update_epn_stall(struct ast_vhub_ep *ep)
497 {
498 u32 reg;
499
500 if (WARN_ON(ep->d_idx == 0))
501 return;
502 reg = readl(ep->epn.regs + AST_VHUB_EP_CONFIG);
503 if (ep->epn.stalled || ep->epn.wedged)
504 reg |= VHUB_EP_CFG_STALL_CTRL;
505 else
506 reg &= ~VHUB_EP_CFG_STALL_CTRL;
507 writel(reg, ep->epn.regs + AST_VHUB_EP_CONFIG);
508
509 if (!ep->epn.stalled && !ep->epn.wedged)
510 writel(VHUB_EP_TOGGLE_SET_EPNUM(ep->epn.g_idx),
511 ep->vhub->regs + AST_VHUB_EP_TOGGLE);
512 }
513
514 static int ast_vhub_set_halt_and_wedge(struct usb_ep* u_ep, bool halt,
515 bool wedge)
516 {
517 struct ast_vhub_ep *ep = to_ast_ep(u_ep);
518 struct ast_vhub *vhub = ep->vhub;
519 unsigned long flags;
520
521 EPDBG(ep, "Set halt (%d) & wedge (%d)\n", halt, wedge);
522
523 if (!u_ep || !u_ep->desc)
524 return -EINVAL;
525 if (ep->d_idx == 0)
526 return 0;
527 if (ep->epn.is_iso)
528 return -EOPNOTSUPP;
529
530 spin_lock_irqsave(&vhub->lock, flags);
531
532
533 if (halt && ep->epn.is_in && !list_empty(&ep->queue)) {
534 spin_unlock_irqrestore(&vhub->lock, flags);
535 return -EAGAIN;
536 }
537 ep->epn.stalled = halt;
538 ep->epn.wedged = wedge;
539 ast_vhub_update_epn_stall(ep);
540
541 spin_unlock_irqrestore(&vhub->lock, flags);
542
543 return 0;
544 }
545
546 static int ast_vhub_epn_set_halt(struct usb_ep *u_ep, int value)
547 {
548 return ast_vhub_set_halt_and_wedge(u_ep, value != 0, false);
549 }
550
551 static int ast_vhub_epn_set_wedge(struct usb_ep *u_ep)
552 {
553 return ast_vhub_set_halt_and_wedge(u_ep, true, true);
554 }
555
556 static int ast_vhub_epn_disable(struct usb_ep* u_ep)
557 {
558 struct ast_vhub_ep *ep = to_ast_ep(u_ep);
559 struct ast_vhub *vhub = ep->vhub;
560 unsigned long flags;
561 u32 imask, ep_ier;
562
563 EPDBG(ep, "Disabling !\n");
564
565 spin_lock_irqsave(&vhub->lock, flags);
566
567 ep->epn.enabled = false;
568
569
570 ast_vhub_stop_active_req(ep, false);
571
572
573 writel(0, ep->epn.regs + AST_VHUB_EP_CONFIG);
574
575
576 imask = VHUB_EP_IRQ(ep->epn.g_idx);
577 ep_ier = readl(vhub->regs + AST_VHUB_EP_ACK_IER);
578 ep_ier &= ~imask;
579 writel(ep_ier, vhub->regs + AST_VHUB_EP_ACK_IER);
580 writel(imask, vhub->regs + AST_VHUB_EP_ACK_ISR);
581
582
583 ast_vhub_nuke(ep, -ESHUTDOWN);
584
585
586 ep->ep.desc = NULL;
587
588 spin_unlock_irqrestore(&vhub->lock, flags);
589
590 return 0;
591 }
592
593 static int ast_vhub_epn_enable(struct usb_ep* u_ep,
594 const struct usb_endpoint_descriptor *desc)
595 {
596 struct ast_vhub_ep *ep = to_ast_ep(u_ep);
597 struct ast_vhub_dev *dev;
598 struct ast_vhub *vhub;
599 u16 maxpacket, type;
600 unsigned long flags;
601 u32 ep_conf, ep_ier, imask;
602
603
604 if (!u_ep || !desc)
605 return -EINVAL;
606
607 maxpacket = usb_endpoint_maxp(desc);
608 if (!ep->d_idx || !ep->dev ||
609 desc->bDescriptorType != USB_DT_ENDPOINT ||
610 maxpacket == 0 || maxpacket > ep->ep.maxpacket) {
611 EPDBG(ep, "Invalid EP enable,d_idx=%d,dev=%p,type=%d,mp=%d/%d\n",
612 ep->d_idx, ep->dev, desc->bDescriptorType,
613 maxpacket, ep->ep.maxpacket);
614 return -EINVAL;
615 }
616 if (ep->d_idx != usb_endpoint_num(desc)) {
617 EPDBG(ep, "EP number mismatch !\n");
618 return -EINVAL;
619 }
620
621 if (ep->epn.enabled) {
622 EPDBG(ep, "Already enabled\n");
623 return -EBUSY;
624 }
625 dev = ep->dev;
626 vhub = ep->vhub;
627
628
629 if (!dev->driver) {
630 EPDBG(ep, "Bogus device state: driver=%p speed=%d\n",
631 dev->driver, dev->gadget.speed);
632 return -ESHUTDOWN;
633 }
634
635
636 ep->epn.is_in = usb_endpoint_dir_in(desc);
637 ep->ep.maxpacket = maxpacket;
638 type = usb_endpoint_type(desc);
639 ep->epn.d_next = ep->epn.d_last = 0;
640 ep->epn.is_iso = false;
641 ep->epn.stalled = false;
642 ep->epn.wedged = false;
643
644 EPDBG(ep, "Enabling [%s] %s num %d maxpacket=%d\n",
645 ep->epn.is_in ? "in" : "out", usb_ep_type_string(type),
646 usb_endpoint_num(desc), maxpacket);
647
648
649 ep->epn.desc_mode = ep->epn.descs && ep->epn.is_in;
650 if (ep->epn.desc_mode)
651 memset(ep->epn.descs, 0, 8 * AST_VHUB_DESCS_COUNT);
652
653
654
655
656
657 ep->epn.chunk_max = ep->ep.maxpacket;
658 if (ep->epn.is_in) {
659 ep->epn.chunk_max <<= 3;
660 while (ep->epn.chunk_max > 4095)
661 ep->epn.chunk_max -= ep->ep.maxpacket;
662 }
663
664 switch(type) {
665 case USB_ENDPOINT_XFER_CONTROL:
666 EPDBG(ep, "Only one control endpoint\n");
667 return -EINVAL;
668 case USB_ENDPOINT_XFER_INT:
669 ep_conf = VHUB_EP_CFG_SET_TYPE(EP_TYPE_INT);
670 break;
671 case USB_ENDPOINT_XFER_BULK:
672 ep_conf = VHUB_EP_CFG_SET_TYPE(EP_TYPE_BULK);
673 break;
674 case USB_ENDPOINT_XFER_ISOC:
675 ep_conf = VHUB_EP_CFG_SET_TYPE(EP_TYPE_ISO);
676 ep->epn.is_iso = true;
677 break;
678 default:
679 return -EINVAL;
680 }
681
682
683 if (maxpacket < 1024)
684 ep_conf |= VHUB_EP_CFG_SET_MAX_PKT(maxpacket);
685 if (!ep->epn.is_in)
686 ep_conf |= VHUB_EP_CFG_DIR_OUT;
687 ep_conf |= VHUB_EP_CFG_SET_EP_NUM(usb_endpoint_num(desc));
688 ep_conf |= VHUB_EP_CFG_ENABLE;
689 ep_conf |= VHUB_EP_CFG_SET_DEV(dev->index + 1);
690 EPVDBG(ep, "config=%08x\n", ep_conf);
691
692 spin_lock_irqsave(&vhub->lock, flags);
693
694
695 writel(0, ep->epn.regs + AST_VHUB_EP_CONFIG);
696 writel(VHUB_EP_DMA_CTRL_RESET,
697 ep->epn.regs + AST_VHUB_EP_DMA_CTLSTAT);
698
699
700 writel(ep_conf, ep->epn.regs + AST_VHUB_EP_CONFIG);
701
702 if (ep->epn.desc_mode) {
703
704 writel(0, ep->epn.regs + AST_VHUB_EP_DESC_STATUS);
705
706
707 writel(ep->epn.descs_dma,
708 ep->epn.regs + AST_VHUB_EP_DESC_BASE);
709
710
711 ep->epn.dma_conf = VHUB_EP_DMA_DESC_MODE;
712 if (ep->epn.is_in)
713 ep->epn.dma_conf |= VHUB_EP_DMA_IN_LONG_MODE;
714
715
716 writel(ep->epn.dma_conf | VHUB_EP_DMA_CTRL_RESET,
717 ep->epn.regs + AST_VHUB_EP_DMA_CTLSTAT);
718
719
720 writel(ep->epn.dma_conf,
721 ep->epn.regs + AST_VHUB_EP_DMA_CTLSTAT);
722 } else {
723
724 ep->epn.dma_conf = VHUB_EP_DMA_SINGLE_STAGE;
725
726
727 writel(ep->epn.dma_conf | VHUB_EP_DMA_CTRL_RESET,
728 ep->epn.regs + AST_VHUB_EP_DMA_CTLSTAT);
729 writel(ep->epn.dma_conf,
730 ep->epn.regs + AST_VHUB_EP_DMA_CTLSTAT);
731 writel(0, ep->epn.regs + AST_VHUB_EP_DESC_STATUS);
732 }
733
734
735 writel(VHUB_EP_TOGGLE_SET_EPNUM(ep->epn.g_idx),
736 vhub->regs + AST_VHUB_EP_TOGGLE);
737
738
739 imask = VHUB_EP_IRQ(ep->epn.g_idx);
740 writel(imask, vhub->regs + AST_VHUB_EP_ACK_ISR);
741 ep_ier = readl(vhub->regs + AST_VHUB_EP_ACK_IER);
742 ep_ier |= imask;
743 writel(ep_ier, vhub->regs + AST_VHUB_EP_ACK_IER);
744
745
746 ep->epn.enabled = true;
747
748 spin_unlock_irqrestore(&vhub->lock, flags);
749
750 return 0;
751 }
752
753 static void ast_vhub_epn_dispose(struct usb_ep *u_ep)
754 {
755 struct ast_vhub_ep *ep = to_ast_ep(u_ep);
756
757 if (WARN_ON(!ep->dev || !ep->d_idx))
758 return;
759
760 EPDBG(ep, "Releasing endpoint\n");
761
762
763 list_del_init(&ep->ep.ep_list);
764
765
766 ep->dev->epns[ep->d_idx - 1] = NULL;
767
768
769 kfree(ep->ep.name);
770 ep->ep.name = NULL;
771 dma_free_coherent(&ep->vhub->pdev->dev,
772 AST_VHUB_EPn_MAX_PACKET +
773 8 * AST_VHUB_DESCS_COUNT,
774 ep->buf, ep->buf_dma);
775 ep->buf = NULL;
776 ep->epn.descs = NULL;
777
778
779 ep->dev = NULL;
780 }
781
782 static const struct usb_ep_ops ast_vhub_epn_ops = {
783 .enable = ast_vhub_epn_enable,
784 .disable = ast_vhub_epn_disable,
785 .dispose = ast_vhub_epn_dispose,
786 .queue = ast_vhub_epn_queue,
787 .dequeue = ast_vhub_epn_dequeue,
788 .set_halt = ast_vhub_epn_set_halt,
789 .set_wedge = ast_vhub_epn_set_wedge,
790 .alloc_request = ast_vhub_alloc_request,
791 .free_request = ast_vhub_free_request,
792 };
793
794 struct ast_vhub_ep *ast_vhub_alloc_epn(struct ast_vhub_dev *d, u8 addr)
795 {
796 struct ast_vhub *vhub = d->vhub;
797 struct ast_vhub_ep *ep;
798 unsigned long flags;
799 int i;
800
801
802 spin_lock_irqsave(&vhub->lock, flags);
803 for (i = 0; i < AST_VHUB_NUM_GEN_EPs; i++)
804 if (vhub->epns[i].dev == NULL)
805 break;
806 if (i >= AST_VHUB_NUM_GEN_EPs) {
807 spin_unlock_irqrestore(&vhub->lock, flags);
808 return NULL;
809 }
810
811
812 ep = &vhub->epns[i];
813 ep->dev = d;
814 spin_unlock_irqrestore(&vhub->lock, flags);
815
816 DDBG(d, "Allocating gen EP %d for addr %d\n", i, addr);
817 INIT_LIST_HEAD(&ep->queue);
818 ep->d_idx = addr;
819 ep->vhub = vhub;
820 ep->ep.ops = &ast_vhub_epn_ops;
821 ep->ep.name = kasprintf(GFP_KERNEL, "ep%d", addr);
822 d->epns[addr-1] = ep;
823 ep->epn.g_idx = i;
824 ep->epn.regs = vhub->regs + 0x200 + (i * 0x10);
825
826 ep->buf = dma_alloc_coherent(&vhub->pdev->dev,
827 AST_VHUB_EPn_MAX_PACKET +
828 8 * AST_VHUB_DESCS_COUNT,
829 &ep->buf_dma, GFP_KERNEL);
830 if (!ep->buf) {
831 kfree(ep->ep.name);
832 ep->ep.name = NULL;
833 return NULL;
834 }
835 ep->epn.descs = ep->buf + AST_VHUB_EPn_MAX_PACKET;
836 ep->epn.descs_dma = ep->buf_dma + AST_VHUB_EPn_MAX_PACKET;
837
838 usb_ep_set_maxpacket_limit(&ep->ep, AST_VHUB_EPn_MAX_PACKET);
839 list_add_tail(&ep->ep.ep_list, &d->gadget.ep_list);
840 ep->ep.caps.type_iso = true;
841 ep->ep.caps.type_bulk = true;
842 ep->ep.caps.type_int = true;
843 ep->ep.caps.dir_in = true;
844 ep->ep.caps.dir_out = true;
845
846 return ep;
847 }