1
2
3
4
5
6
7
8
9
10
11
12
13#include <linux/delay.h>
14#include <linux/device.h>
15#include <linux/dmapool.h>
16#include <linux/err.h>
17#include <linux/irqreturn.h>
18#include <linux/kernel.h>
19#include <linux/slab.h>
20#include <linux/pm_runtime.h>
21#include <linux/usb/ch9.h>
22#include <linux/usb/gadget.h>
23#include <linux/usb/otg-fsm.h>
24#include <linux/usb/chipidea.h>
25
26#include "ci.h"
27#include "udc.h"
28#include "bits.h"
29#include "debug.h"
30#include "otg.h"
31#include "otg_fsm.h"
32
33
34static const struct usb_endpoint_descriptor
35ctrl_endpt_out_desc = {
36 .bLength = USB_DT_ENDPOINT_SIZE,
37 .bDescriptorType = USB_DT_ENDPOINT,
38
39 .bEndpointAddress = USB_DIR_OUT,
40 .bmAttributes = USB_ENDPOINT_XFER_CONTROL,
41 .wMaxPacketSize = cpu_to_le16(CTRL_PAYLOAD_MAX),
42};
43
44static const struct usb_endpoint_descriptor
45ctrl_endpt_in_desc = {
46 .bLength = USB_DT_ENDPOINT_SIZE,
47 .bDescriptorType = USB_DT_ENDPOINT,
48
49 .bEndpointAddress = USB_DIR_IN,
50 .bmAttributes = USB_ENDPOINT_XFER_CONTROL,
51 .wMaxPacketSize = cpu_to_le16(CTRL_PAYLOAD_MAX),
52};
53
54
55
56
57
58
59
60
61static inline int hw_ep_bit(int num, int dir)
62{
63 return num + (dir ? 16 : 0);
64}
65
66static inline int ep_to_bit(struct ci_hdrc *ci, int n)
67{
68 int fill = 16 - ci->hw_ep_max / 2;
69
70 if (n >= ci->hw_ep_max / 2)
71 n += fill;
72
73 return n;
74}
75
76
77
78
79
80
81
82static int hw_device_state(struct ci_hdrc *ci, u32 dma)
83{
84 if (dma) {
85 hw_write(ci, OP_ENDPTLISTADDR, ~0, dma);
86
87 hw_write(ci, OP_USBINTR, ~0,
88 USBi_UI|USBi_UEI|USBi_PCI|USBi_URI|USBi_SLI);
89 hw_write(ci, OP_USBCMD, USBCMD_RS, USBCMD_RS);
90 } else {
91 hw_write(ci, OP_USBINTR, ~0, 0);
92 hw_write(ci, OP_USBCMD, USBCMD_RS, 0);
93 }
94 return 0;
95}
96
97
98
99
100
101
102
103
104static int hw_ep_flush(struct ci_hdrc *ci, int num, int dir)
105{
106 int n = hw_ep_bit(num, dir);
107
108 do {
109
110 hw_write(ci, OP_ENDPTFLUSH, ~0, BIT(n));
111 while (hw_read(ci, OP_ENDPTFLUSH, BIT(n)))
112 cpu_relax();
113 } while (hw_read(ci, OP_ENDPTSTAT, BIT(n)));
114
115 return 0;
116}
117
118
119
120
121
122
123
124
125static int hw_ep_disable(struct ci_hdrc *ci, int num, int dir)
126{
127 hw_ep_flush(ci, num, dir);
128 hw_write(ci, OP_ENDPTCTRL + num,
129 dir ? ENDPTCTRL_TXE : ENDPTCTRL_RXE, 0);
130 return 0;
131}
132
133
134
135
136
137
138
139
140
141static int hw_ep_enable(struct ci_hdrc *ci, int num, int dir, int type)
142{
143 u32 mask, data;
144
145 if (dir) {
146 mask = ENDPTCTRL_TXT;
147 data = type << __ffs(mask);
148
149 mask |= ENDPTCTRL_TXS;
150 mask |= ENDPTCTRL_TXR;
151 data |= ENDPTCTRL_TXR;
152 mask |= ENDPTCTRL_TXE;
153 data |= ENDPTCTRL_TXE;
154 } else {
155 mask = ENDPTCTRL_RXT;
156 data = type << __ffs(mask);
157
158 mask |= ENDPTCTRL_RXS;
159 mask |= ENDPTCTRL_RXR;
160 data |= ENDPTCTRL_RXR;
161 mask |= ENDPTCTRL_RXE;
162 data |= ENDPTCTRL_RXE;
163 }
164 hw_write(ci, OP_ENDPTCTRL + num, mask, data);
165 return 0;
166}
167
168
169
170
171
172
173
174
175static int hw_ep_get_halt(struct ci_hdrc *ci, int num, int dir)
176{
177 u32 mask = dir ? ENDPTCTRL_TXS : ENDPTCTRL_RXS;
178
179 return hw_read(ci, OP_ENDPTCTRL + num, mask) ? 1 : 0;
180}
181
182
183
184
185
186
187
188
189
190static int hw_ep_prime(struct ci_hdrc *ci, int num, int dir, int is_ctrl)
191{
192 int n = hw_ep_bit(num, dir);
193
194 if (is_ctrl && dir == RX && hw_read(ci, OP_ENDPTSETUPSTAT, BIT(num)))
195 return -EAGAIN;
196
197 hw_write(ci, OP_ENDPTPRIME, ~0, BIT(n));
198
199 while (hw_read(ci, OP_ENDPTPRIME, BIT(n)))
200 cpu_relax();
201 if (is_ctrl && dir == RX && hw_read(ci, OP_ENDPTSETUPSTAT, BIT(num)))
202 return -EAGAIN;
203
204
205 return 0;
206}
207
208
209
210
211
212
213
214
215
216
217static int hw_ep_set_halt(struct ci_hdrc *ci, int num, int dir, int value)
218{
219 if (value != 0 && value != 1)
220 return -EINVAL;
221
222 do {
223 enum ci_hw_regs reg = OP_ENDPTCTRL + num;
224 u32 mask_xs = dir ? ENDPTCTRL_TXS : ENDPTCTRL_RXS;
225 u32 mask_xr = dir ? ENDPTCTRL_TXR : ENDPTCTRL_RXR;
226
227
228 hw_write(ci, reg, mask_xs|mask_xr,
229 value ? mask_xs : mask_xr);
230 } while (value != hw_ep_get_halt(ci, num, dir));
231
232 return 0;
233}
234
235
236
237
238
239
240static int hw_port_is_high_speed(struct ci_hdrc *ci)
241{
242 return ci->hw_bank.lpm ? hw_read(ci, OP_DEVLC, DEVLC_PSPD) :
243 hw_read(ci, OP_PORTSC, PORTSC_HSP);
244}
245
246
247
248
249
250
251
252
253static int hw_test_and_clear_complete(struct ci_hdrc *ci, int n)
254{
255 n = ep_to_bit(ci, n);
256 return hw_test_and_clear(ci, OP_ENDPTCOMPLETE, BIT(n));
257}
258
259
260
261
262
263
264
265static u32 hw_test_and_clear_intr_active(struct ci_hdrc *ci)
266{
267 u32 reg = hw_read_intr_status(ci) & hw_read_intr_enable(ci);
268
269 hw_write(ci, OP_USBSTS, ~0, reg);
270 return reg;
271}
272
273
274
275
276
277
278
279static int hw_test_and_clear_setup_guard(struct ci_hdrc *ci)
280{
281 return hw_test_and_write(ci, OP_USBCMD, USBCMD_SUTW, 0);
282}
283
284
285
286
287
288
289
290static int hw_test_and_set_setup_guard(struct ci_hdrc *ci)
291{
292 return hw_test_and_write(ci, OP_USBCMD, USBCMD_SUTW, USBCMD_SUTW);
293}
294
295
296
297
298
299
300
301
302static void hw_usb_set_address(struct ci_hdrc *ci, u8 value)
303{
304 hw_write(ci, OP_DEVICEADDR, DEVICEADDR_USBADR,
305 value << __ffs(DEVICEADDR_USBADR));
306}
307
308
309
310
311
312
313
314static int hw_usb_reset(struct ci_hdrc *ci)
315{
316 hw_usb_set_address(ci, 0);
317
318
319 hw_write(ci, OP_ENDPTFLUSH, ~0, ~0);
320
321
322 hw_write(ci, OP_ENDPTSETUPSTAT, 0, 0);
323
324
325 hw_write(ci, OP_ENDPTCOMPLETE, 0, 0);
326
327
328 while (hw_read(ci, OP_ENDPTPRIME, ~0))
329 udelay(10);
330
331
332
333
334
335
336 return 0;
337}
338
339
340
341
342
343static int add_td_to_list(struct ci_hw_ep *hwep, struct ci_hw_req *hwreq,
344 unsigned length)
345{
346 int i;
347 u32 temp;
348 struct td_node *lastnode, *node = kzalloc(sizeof(struct td_node),
349 GFP_ATOMIC);
350
351 if (node == NULL)
352 return -ENOMEM;
353
354 node->ptr = dma_pool_alloc(hwep->td_pool, GFP_ATOMIC,
355 &node->dma);
356 if (node->ptr == NULL) {
357 kfree(node);
358 return -ENOMEM;
359 }
360
361 memset(node->ptr, 0, sizeof(struct ci_hw_td));
362 node->ptr->token = cpu_to_le32(length << __ffs(TD_TOTAL_BYTES));
363 node->ptr->token &= cpu_to_le32(TD_TOTAL_BYTES);
364 node->ptr->token |= cpu_to_le32(TD_STATUS_ACTIVE);
365 if (hwep->type == USB_ENDPOINT_XFER_ISOC && hwep->dir == TX) {
366 u32 mul = hwreq->req.length / hwep->ep.maxpacket;
367
368 if (hwreq->req.length == 0
369 || hwreq->req.length % hwep->ep.maxpacket)
370 mul++;
371 node->ptr->token |= mul << __ffs(TD_MULTO);
372 }
373
374 temp = (u32) (hwreq->req.dma + hwreq->req.actual);
375 if (length) {
376 node->ptr->page[0] = cpu_to_le32(temp);
377 for (i = 1; i < TD_PAGE_COUNT; i++) {
378 u32 page = temp + i * CI_HDRC_PAGE_SIZE;
379 page &= ~TD_RESERVED_MASK;
380 node->ptr->page[i] = cpu_to_le32(page);
381 }
382 }
383
384 hwreq->req.actual += length;
385
386 if (!list_empty(&hwreq->tds)) {
387
388 lastnode = list_entry(hwreq->tds.prev,
389 struct td_node, td);
390 lastnode->ptr->next = cpu_to_le32(node->dma);
391 }
392
393 INIT_LIST_HEAD(&node->td);
394 list_add_tail(&node->td, &hwreq->tds);
395
396 return 0;
397}
398
399
400
401
402
403static inline u8 _usb_addr(struct ci_hw_ep *ep)
404{
405 return ((ep->dir == TX) ? USB_ENDPOINT_DIR_MASK : 0) | ep->num;
406}
407
408
409
410
411
412
413
414
415static int _hardware_enqueue(struct ci_hw_ep *hwep, struct ci_hw_req *hwreq)
416{
417 struct ci_hdrc *ci = hwep->ci;
418 int ret = 0;
419 unsigned rest = hwreq->req.length;
420 int pages = TD_PAGE_COUNT;
421 struct td_node *firstnode, *lastnode;
422
423
424 if (hwreq->req.status == -EALREADY)
425 return -EALREADY;
426
427 hwreq->req.status = -EALREADY;
428
429 ret = usb_gadget_map_request(&ci->gadget, &hwreq->req, hwep->dir);
430 if (ret)
431 return ret;
432
433
434
435
436
437 if (hwreq->req.dma % PAGE_SIZE)
438 pages--;
439
440 if (rest == 0)
441 add_td_to_list(hwep, hwreq, 0);
442
443 while (rest > 0) {
444 unsigned count = min(hwreq->req.length - hwreq->req.actual,
445 (unsigned)(pages * CI_HDRC_PAGE_SIZE));
446 add_td_to_list(hwep, hwreq, count);
447 rest -= count;
448 }
449
450 if (hwreq->req.zero && hwreq->req.length
451 && (hwreq->req.length % hwep->ep.maxpacket == 0))
452 add_td_to_list(hwep, hwreq, 0);
453
454 firstnode = list_first_entry(&hwreq->tds, struct td_node, td);
455
456 lastnode = list_entry(hwreq->tds.prev,
457 struct td_node, td);
458
459 lastnode->ptr->next = cpu_to_le32(TD_TERMINATE);
460 if (!hwreq->req.no_interrupt)
461 lastnode->ptr->token |= cpu_to_le32(TD_IOC);
462 wmb();
463
464 hwreq->req.actual = 0;
465 if (!list_empty(&hwep->qh.queue)) {
466 struct ci_hw_req *hwreqprev;
467 int n = hw_ep_bit(hwep->num, hwep->dir);
468 int tmp_stat;
469 struct td_node *prevlastnode;
470 u32 next = firstnode->dma & TD_ADDR_MASK;
471
472 hwreqprev = list_entry(hwep->qh.queue.prev,
473 struct ci_hw_req, queue);
474 prevlastnode = list_entry(hwreqprev->tds.prev,
475 struct td_node, td);
476
477 prevlastnode->ptr->next = cpu_to_le32(next);
478 wmb();
479 if (hw_read(ci, OP_ENDPTPRIME, BIT(n)))
480 goto done;
481 do {
482 hw_write(ci, OP_USBCMD, USBCMD_ATDTW, USBCMD_ATDTW);
483 tmp_stat = hw_read(ci, OP_ENDPTSTAT, BIT(n));
484 } while (!hw_read(ci, OP_USBCMD, USBCMD_ATDTW));
485 hw_write(ci, OP_USBCMD, USBCMD_ATDTW, 0);
486 if (tmp_stat)
487 goto done;
488 }
489
490
491 hwep->qh.ptr->td.next = cpu_to_le32(firstnode->dma);
492 hwep->qh.ptr->td.token &=
493 cpu_to_le32(~(TD_STATUS_HALTED|TD_STATUS_ACTIVE));
494
495 if (hwep->type == USB_ENDPOINT_XFER_ISOC && hwep->dir == RX) {
496 u32 mul = hwreq->req.length / hwep->ep.maxpacket;
497
498 if (hwreq->req.length == 0
499 || hwreq->req.length % hwep->ep.maxpacket)
500 mul++;
501 hwep->qh.ptr->cap |= mul << __ffs(QH_MULT);
502 }
503
504 wmb();
505
506 ret = hw_ep_prime(ci, hwep->num, hwep->dir,
507 hwep->type == USB_ENDPOINT_XFER_CONTROL);
508done:
509 return ret;
510}
511
512
513
514
515
516static void free_pending_td(struct ci_hw_ep *hwep)
517{
518 struct td_node *pending = hwep->pending_td;
519
520 dma_pool_free(hwep->td_pool, pending->ptr, pending->dma);
521 hwep->pending_td = NULL;
522 kfree(pending);
523}
524
525
526
527
528
529
530
531
532static int _hardware_dequeue(struct ci_hw_ep *hwep, struct ci_hw_req *hwreq)
533{
534 u32 tmptoken;
535 struct td_node *node, *tmpnode;
536 unsigned remaining_length;
537 unsigned actual = hwreq->req.length;
538
539 if (hwreq->req.status != -EALREADY)
540 return -EINVAL;
541
542 hwreq->req.status = 0;
543
544 list_for_each_entry_safe(node, tmpnode, &hwreq->tds, td) {
545 tmptoken = le32_to_cpu(node->ptr->token);
546 if ((TD_STATUS_ACTIVE & tmptoken) != 0) {
547 hwreq->req.status = -EALREADY;
548 return -EBUSY;
549 }
550
551 remaining_length = (tmptoken & TD_TOTAL_BYTES);
552 remaining_length >>= __ffs(TD_TOTAL_BYTES);
553 actual -= remaining_length;
554
555 hwreq->req.status = tmptoken & TD_STATUS;
556 if ((TD_STATUS_HALTED & hwreq->req.status)) {
557 hwreq->req.status = -EPIPE;
558 break;
559 } else if ((TD_STATUS_DT_ERR & hwreq->req.status)) {
560 hwreq->req.status = -EPROTO;
561 break;
562 } else if ((TD_STATUS_TR_ERR & hwreq->req.status)) {
563 hwreq->req.status = -EILSEQ;
564 break;
565 }
566
567 if (remaining_length) {
568 if (hwep->dir) {
569 hwreq->req.status = -EPROTO;
570 break;
571 }
572 }
573
574
575
576
577
578 if (hwep->pending_td)
579 free_pending_td(hwep);
580
581 hwep->pending_td = node;
582 list_del_init(&node->td);
583 }
584
585 usb_gadget_unmap_request(&hwep->ci->gadget, &hwreq->req, hwep->dir);
586
587 hwreq->req.actual += actual;
588
589 if (hwreq->req.status)
590 return hwreq->req.status;
591
592 return hwreq->req.actual;
593}
594
595
596
597
598
599
600
601
602static int _ep_nuke(struct ci_hw_ep *hwep)
603__releases(hwep->lock)
604__acquires(hwep->lock)
605{
606 struct td_node *node, *tmpnode;
607 if (hwep == NULL)
608 return -EINVAL;
609
610 hw_ep_flush(hwep->ci, hwep->num, hwep->dir);
611
612 while (!list_empty(&hwep->qh.queue)) {
613
614
615 struct ci_hw_req *hwreq = list_entry(hwep->qh.queue.next,
616 struct ci_hw_req, queue);
617
618 list_for_each_entry_safe(node, tmpnode, &hwreq->tds, td) {
619 dma_pool_free(hwep->td_pool, node->ptr, node->dma);
620 list_del_init(&node->td);
621 node->ptr = NULL;
622 kfree(node);
623 }
624
625 list_del_init(&hwreq->queue);
626 hwreq->req.status = -ESHUTDOWN;
627
628 if (hwreq->req.complete != NULL) {
629 spin_unlock(hwep->lock);
630 usb_gadget_giveback_request(&hwep->ep, &hwreq->req);
631 spin_lock(hwep->lock);
632 }
633 }
634
635 if (hwep->pending_td)
636 free_pending_td(hwep);
637
638 return 0;
639}
640
641
642
643
644
645
646
647static int _gadget_stop_activity(struct usb_gadget *gadget)
648{
649 struct usb_ep *ep;
650 struct ci_hdrc *ci = container_of(gadget, struct ci_hdrc, gadget);
651 unsigned long flags;
652
653 spin_lock_irqsave(&ci->lock, flags);
654 ci->gadget.speed = USB_SPEED_UNKNOWN;
655 ci->remote_wakeup = 0;
656 ci->suspended = 0;
657 spin_unlock_irqrestore(&ci->lock, flags);
658
659
660 gadget_for_each_ep(ep, gadget) {
661 usb_ep_fifo_flush(ep);
662 }
663 usb_ep_fifo_flush(&ci->ep0out->ep);
664 usb_ep_fifo_flush(&ci->ep0in->ep);
665
666
667 gadget_for_each_ep(ep, gadget) {
668 usb_ep_disable(ep);
669 }
670
671 if (ci->status != NULL) {
672 usb_ep_free_request(&ci->ep0in->ep, ci->status);
673 ci->status = NULL;
674 }
675
676 return 0;
677}
678
679
680
681
682
683
684
685
686
687
688static void isr_reset_handler(struct ci_hdrc *ci)
689__releases(ci->lock)
690__acquires(ci->lock)
691{
692 int retval;
693
694 spin_unlock(&ci->lock);
695 if (ci->gadget.speed != USB_SPEED_UNKNOWN)
696 usb_gadget_udc_reset(&ci->gadget, ci->driver);
697
698 retval = _gadget_stop_activity(&ci->gadget);
699 if (retval)
700 goto done;
701
702 retval = hw_usb_reset(ci);
703 if (retval)
704 goto done;
705
706 ci->status = usb_ep_alloc_request(&ci->ep0in->ep, GFP_ATOMIC);
707 if (ci->status == NULL)
708 retval = -ENOMEM;
709
710done:
711 spin_lock(&ci->lock);
712
713 if (retval)
714 dev_err(ci->dev, "error: %i\n", retval);
715}
716
717
718
719
720
721
722
723
724static void isr_get_status_complete(struct usb_ep *ep, struct usb_request *req)
725{
726 if (ep == NULL || req == NULL)
727 return;
728
729 kfree(req->buf);
730 usb_ep_free_request(ep, req);
731}
732
733
734
735
736
737
738static int _ep_queue(struct usb_ep *ep, struct usb_request *req,
739 gfp_t __maybe_unused gfp_flags)
740{
741 struct ci_hw_ep *hwep = container_of(ep, struct ci_hw_ep, ep);
742 struct ci_hw_req *hwreq = container_of(req, struct ci_hw_req, req);
743 struct ci_hdrc *ci = hwep->ci;
744 int retval = 0;
745
746 if (ep == NULL || req == NULL || hwep->ep.desc == NULL)
747 return -EINVAL;
748
749 if (hwep->type == USB_ENDPOINT_XFER_CONTROL) {
750 if (req->length)
751 hwep = (ci->ep0_dir == RX) ?
752 ci->ep0out : ci->ep0in;
753 if (!list_empty(&hwep->qh.queue)) {
754 _ep_nuke(hwep);
755 retval = -EOVERFLOW;
756 dev_warn(hwep->ci->dev, "endpoint ctrl %X nuked\n",
757 _usb_addr(hwep));
758 }
759 }
760
761 if (usb_endpoint_xfer_isoc(hwep->ep.desc) &&
762 hwreq->req.length > (1 + hwep->ep.mult) * hwep->ep.maxpacket) {
763 dev_err(hwep->ci->dev, "request length too big for isochronous\n");
764 return -EMSGSIZE;
765 }
766
767
768 if (!list_empty(&hwreq->queue)) {
769 dev_err(hwep->ci->dev, "request already in queue\n");
770 return -EBUSY;
771 }
772
773
774 hwreq->req.status = -EINPROGRESS;
775 hwreq->req.actual = 0;
776
777 retval = _hardware_enqueue(hwep, hwreq);
778
779 if (retval == -EALREADY)
780 retval = 0;
781 if (!retval)
782 list_add_tail(&hwreq->queue, &hwep->qh.queue);
783
784 return retval;
785}
786
787
788
789
790
791
792
793
794static int isr_get_status_response(struct ci_hdrc *ci,
795 struct usb_ctrlrequest *setup)
796__releases(hwep->lock)
797__acquires(hwep->lock)
798{
799 struct ci_hw_ep *hwep = ci->ep0in;
800 struct usb_request *req = NULL;
801 gfp_t gfp_flags = GFP_ATOMIC;
802 int dir, num, retval;
803
804 if (hwep == NULL || setup == NULL)
805 return -EINVAL;
806
807 spin_unlock(hwep->lock);
808 req = usb_ep_alloc_request(&hwep->ep, gfp_flags);
809 spin_lock(hwep->lock);
810 if (req == NULL)
811 return -ENOMEM;
812
813 req->complete = isr_get_status_complete;
814 req->length = 2;
815 req->buf = kzalloc(req->length, gfp_flags);
816 if (req->buf == NULL) {
817 retval = -ENOMEM;
818 goto err_free_req;
819 }
820
821 if ((setup->bRequestType & USB_RECIP_MASK) == USB_RECIP_DEVICE) {
822
823 *(u16 *)req->buf = ci->remote_wakeup << 1;
824 } else if ((setup->bRequestType & USB_RECIP_MASK) \
825 == USB_RECIP_ENDPOINT) {
826 dir = (le16_to_cpu(setup->wIndex) & USB_ENDPOINT_DIR_MASK) ?
827 TX : RX;
828 num = le16_to_cpu(setup->wIndex) & USB_ENDPOINT_NUMBER_MASK;
829 *(u16 *)req->buf = hw_ep_get_halt(ci, num, dir);
830 }
831
832
833 retval = _ep_queue(&hwep->ep, req, gfp_flags);
834 if (retval)
835 goto err_free_buf;
836
837 return 0;
838
839 err_free_buf:
840 kfree(req->buf);
841 err_free_req:
842 spin_unlock(hwep->lock);
843 usb_ep_free_request(&hwep->ep, req);
844 spin_lock(hwep->lock);
845 return retval;
846}
847
848
849
850
851
852
853
854
855
856static void
857isr_setup_status_complete(struct usb_ep *ep, struct usb_request *req)
858{
859 struct ci_hdrc *ci = req->context;
860 unsigned long flags;
861
862 if (ci->setaddr) {
863 hw_usb_set_address(ci, ci->address);
864 ci->setaddr = false;
865 if (ci->address)
866 usb_gadget_set_state(&ci->gadget, USB_STATE_ADDRESS);
867 }
868
869 spin_lock_irqsave(&ci->lock, flags);
870 if (ci->test_mode)
871 hw_port_test_set(ci, ci->test_mode);
872 spin_unlock_irqrestore(&ci->lock, flags);
873}
874
875
876
877
878
879
880
881static int isr_setup_status_phase(struct ci_hdrc *ci)
882{
883 int retval;
884 struct ci_hw_ep *hwep;
885
886 hwep = (ci->ep0_dir == TX) ? ci->ep0out : ci->ep0in;
887 ci->status->context = ci;
888 ci->status->complete = isr_setup_status_complete;
889
890 retval = _ep_queue(&hwep->ep, ci->status, GFP_ATOMIC);
891
892 return retval;
893}
894
895
896
897
898
899
900
901
902static int isr_tr_complete_low(struct ci_hw_ep *hwep)
903__releases(hwep->lock)
904__acquires(hwep->lock)
905{
906 struct ci_hw_req *hwreq, *hwreqtemp;
907 struct ci_hw_ep *hweptemp = hwep;
908 int retval = 0;
909
910 list_for_each_entry_safe(hwreq, hwreqtemp, &hwep->qh.queue,
911 queue) {
912 retval = _hardware_dequeue(hwep, hwreq);
913 if (retval < 0)
914 break;
915 list_del_init(&hwreq->queue);
916 if (hwreq->req.complete != NULL) {
917 spin_unlock(hwep->lock);
918 if ((hwep->type == USB_ENDPOINT_XFER_CONTROL) &&
919 hwreq->req.length)
920 hweptemp = hwep->ci->ep0in;
921 usb_gadget_giveback_request(&hweptemp->ep, &hwreq->req);
922 spin_lock(hwep->lock);
923 }
924 }
925
926 if (retval == -EBUSY)
927 retval = 0;
928
929 return retval;
930}
931
932
933
934
935
936
937
938static void isr_setup_packet_handler(struct ci_hdrc *ci)
939__releases(ci->lock)
940__acquires(ci->lock)
941{
942 struct ci_hw_ep *hwep = &ci->ci_hw_ep[0];
943 struct usb_ctrlrequest req;
944 int type, num, dir, err = -EINVAL;
945 u8 tmode = 0;
946
947
948
949
950
951 _ep_nuke(ci->ep0out);
952 _ep_nuke(ci->ep0in);
953
954
955 do {
956 hw_test_and_set_setup_guard(ci);
957 memcpy(&req, &hwep->qh.ptr->setup, sizeof(req));
958 } while (!hw_test_and_clear_setup_guard(ci));
959
960 type = req.bRequestType;
961
962 ci->ep0_dir = (type & USB_DIR_IN) ? TX : RX;
963
964 switch (req.bRequest) {
965 case USB_REQ_CLEAR_FEATURE:
966 if (type == (USB_DIR_OUT|USB_RECIP_ENDPOINT) &&
967 le16_to_cpu(req.wValue) ==
968 USB_ENDPOINT_HALT) {
969 if (req.wLength != 0)
970 break;
971 num = le16_to_cpu(req.wIndex);
972 dir = num & USB_ENDPOINT_DIR_MASK;
973 num &= USB_ENDPOINT_NUMBER_MASK;
974 if (dir)
975 num += ci->hw_ep_max / 2;
976 if (!ci->ci_hw_ep[num].wedge) {
977 spin_unlock(&ci->lock);
978 err = usb_ep_clear_halt(
979 &ci->ci_hw_ep[num].ep);
980 spin_lock(&ci->lock);
981 if (err)
982 break;
983 }
984 err = isr_setup_status_phase(ci);
985 } else if (type == (USB_DIR_OUT|USB_RECIP_DEVICE) &&
986 le16_to_cpu(req.wValue) ==
987 USB_DEVICE_REMOTE_WAKEUP) {
988 if (req.wLength != 0)
989 break;
990 ci->remote_wakeup = 0;
991 err = isr_setup_status_phase(ci);
992 } else {
993 goto delegate;
994 }
995 break;
996 case USB_REQ_GET_STATUS:
997 if (type != (USB_DIR_IN|USB_RECIP_DEVICE) &&
998 type != (USB_DIR_IN|USB_RECIP_ENDPOINT) &&
999 type != (USB_DIR_IN|USB_RECIP_INTERFACE))
1000 goto delegate;
1001 if (le16_to_cpu(req.wLength) != 2 ||
1002 le16_to_cpu(req.wValue) != 0)
1003 break;
1004 err = isr_get_status_response(ci, &req);
1005 break;
1006 case USB_REQ_SET_ADDRESS:
1007 if (type != (USB_DIR_OUT|USB_RECIP_DEVICE))
1008 goto delegate;
1009 if (le16_to_cpu(req.wLength) != 0 ||
1010 le16_to_cpu(req.wIndex) != 0)
1011 break;
1012 ci->address = (u8)le16_to_cpu(req.wValue);
1013 ci->setaddr = true;
1014 err = isr_setup_status_phase(ci);
1015 break;
1016 case USB_REQ_SET_FEATURE:
1017 if (type == (USB_DIR_OUT|USB_RECIP_ENDPOINT) &&
1018 le16_to_cpu(req.wValue) ==
1019 USB_ENDPOINT_HALT) {
1020 if (req.wLength != 0)
1021 break;
1022 num = le16_to_cpu(req.wIndex);
1023 dir = num & USB_ENDPOINT_DIR_MASK;
1024 num &= USB_ENDPOINT_NUMBER_MASK;
1025 if (dir)
1026 num += ci->hw_ep_max / 2;
1027
1028 spin_unlock(&ci->lock);
1029 err = usb_ep_set_halt(&ci->ci_hw_ep[num].ep);
1030 spin_lock(&ci->lock);
1031 if (!err)
1032 isr_setup_status_phase(ci);
1033 } else if (type == (USB_DIR_OUT|USB_RECIP_DEVICE)) {
1034 if (req.wLength != 0)
1035 break;
1036 switch (le16_to_cpu(req.wValue)) {
1037 case USB_DEVICE_REMOTE_WAKEUP:
1038 ci->remote_wakeup = 1;
1039 err = isr_setup_status_phase(ci);
1040 break;
1041 case USB_DEVICE_TEST_MODE:
1042 tmode = le16_to_cpu(req.wIndex) >> 8;
1043 switch (tmode) {
1044 case TEST_J:
1045 case TEST_K:
1046 case TEST_SE0_NAK:
1047 case TEST_PACKET:
1048 case TEST_FORCE_EN:
1049 ci->test_mode = tmode;
1050 err = isr_setup_status_phase(
1051 ci);
1052 break;
1053 default:
1054 break;
1055 }
1056 break;
1057 case USB_DEVICE_B_HNP_ENABLE:
1058 if (ci_otg_is_fsm_mode(ci)) {
1059 ci->gadget.b_hnp_enable = 1;
1060 err = isr_setup_status_phase(
1061 ci);
1062 }
1063 break;
1064 default:
1065 goto delegate;
1066 }
1067 } else {
1068 goto delegate;
1069 }
1070 break;
1071 default:
1072delegate:
1073 if (req.wLength == 0)
1074 ci->ep0_dir = TX;
1075
1076 spin_unlock(&ci->lock);
1077 err = ci->driver->setup(&ci->gadget, &req);
1078 spin_lock(&ci->lock);
1079 break;
1080 }
1081
1082 if (err < 0) {
1083 spin_unlock(&ci->lock);
1084 if (usb_ep_set_halt(&hwep->ep))
1085 dev_err(ci->dev, "error: ep_set_halt\n");
1086 spin_lock(&ci->lock);
1087 }
1088}
1089
1090
1091
1092
1093
1094
1095
1096static void isr_tr_complete_handler(struct ci_hdrc *ci)
1097__releases(ci->lock)
1098__acquires(ci->lock)
1099{
1100 unsigned i;
1101 int err;
1102
1103 for (i = 0; i < ci->hw_ep_max; i++) {
1104 struct ci_hw_ep *hwep = &ci->ci_hw_ep[i];
1105
1106 if (hwep->ep.desc == NULL)
1107 continue;
1108
1109 if (hw_test_and_clear_complete(ci, i)) {
1110 err = isr_tr_complete_low(hwep);
1111 if (hwep->type == USB_ENDPOINT_XFER_CONTROL) {
1112 if (err > 0)
1113 err = isr_setup_status_phase(ci);
1114 if (err < 0) {
1115 spin_unlock(&ci->lock);
1116 if (usb_ep_set_halt(&hwep->ep))
1117 dev_err(ci->dev,
1118 "error: ep_set_halt\n");
1119 spin_lock(&ci->lock);
1120 }
1121 }
1122 }
1123
1124
1125 if (i == 0 &&
1126 hw_test_and_clear(ci, OP_ENDPTSETUPSTAT, BIT(0)))
1127 isr_setup_packet_handler(ci);
1128 }
1129}
1130
1131
1132
1133
1134
1135
1136
1137
1138
1139static int ep_enable(struct usb_ep *ep,
1140 const struct usb_endpoint_descriptor *desc)
1141{
1142 struct ci_hw_ep *hwep = container_of(ep, struct ci_hw_ep, ep);
1143 int retval = 0;
1144 unsigned long flags;
1145 u32 cap = 0;
1146
1147 if (ep == NULL || desc == NULL)
1148 return -EINVAL;
1149
1150 spin_lock_irqsave(hwep->lock, flags);
1151
1152
1153
1154 hwep->ep.desc = desc;
1155
1156 if (!list_empty(&hwep->qh.queue))
1157 dev_warn(hwep->ci->dev, "enabling a non-empty endpoint!\n");
1158
1159 hwep->dir = usb_endpoint_dir_in(desc) ? TX : RX;
1160 hwep->num = usb_endpoint_num(desc);
1161 hwep->type = usb_endpoint_type(desc);
1162
1163 hwep->ep.maxpacket = usb_endpoint_maxp(desc) & 0x07ff;
1164 hwep->ep.mult = QH_ISO_MULT(usb_endpoint_maxp(desc));
1165
1166 if (hwep->type == USB_ENDPOINT_XFER_CONTROL)
1167 cap |= QH_IOS;
1168
1169 cap |= QH_ZLT;
1170 cap |= (hwep->ep.maxpacket << __ffs(QH_MAX_PKT)) & QH_MAX_PKT;
1171
1172
1173
1174
1175 if (hwep->type == USB_ENDPOINT_XFER_ISOC && hwep->dir == TX)
1176 cap |= 3 << __ffs(QH_MULT);
1177
1178 hwep->qh.ptr->cap = cpu_to_le32(cap);
1179
1180 hwep->qh.ptr->td.next |= cpu_to_le32(TD_TERMINATE);
1181
1182 if (hwep->num != 0 && hwep->type == USB_ENDPOINT_XFER_CONTROL) {
1183 dev_err(hwep->ci->dev, "Set control xfer at non-ep0\n");
1184 retval = -EINVAL;
1185 }
1186
1187
1188
1189
1190
1191 if (hwep->num)
1192 retval |= hw_ep_enable(hwep->ci, hwep->num, hwep->dir,
1193 hwep->type);
1194
1195 spin_unlock_irqrestore(hwep->lock, flags);
1196 return retval;
1197}
1198
1199
1200
1201
1202
1203
1204static int ep_disable(struct usb_ep *ep)
1205{
1206 struct ci_hw_ep *hwep = container_of(ep, struct ci_hw_ep, ep);
1207 int direction, retval = 0;
1208 unsigned long flags;
1209
1210 if (ep == NULL)
1211 return -EINVAL;
1212 else if (hwep->ep.desc == NULL)
1213 return -EBUSY;
1214
1215 spin_lock_irqsave(hwep->lock, flags);
1216
1217
1218
1219 direction = hwep->dir;
1220 do {
1221 retval |= _ep_nuke(hwep);
1222 retval |= hw_ep_disable(hwep->ci, hwep->num, hwep->dir);
1223
1224 if (hwep->type == USB_ENDPOINT_XFER_CONTROL)
1225 hwep->dir = (hwep->dir == TX) ? RX : TX;
1226
1227 } while (hwep->dir != direction);
1228
1229 hwep->ep.desc = NULL;
1230
1231 spin_unlock_irqrestore(hwep->lock, flags);
1232 return retval;
1233}
1234
1235
1236
1237
1238
1239
1240static struct usb_request *ep_alloc_request(struct usb_ep *ep, gfp_t gfp_flags)
1241{
1242 struct ci_hw_req *hwreq = NULL;
1243
1244 if (ep == NULL)
1245 return NULL;
1246
1247 hwreq = kzalloc(sizeof(struct ci_hw_req), gfp_flags);
1248 if (hwreq != NULL) {
1249 INIT_LIST_HEAD(&hwreq->queue);
1250 INIT_LIST_HEAD(&hwreq->tds);
1251 }
1252
1253 return (hwreq == NULL) ? NULL : &hwreq->req;
1254}
1255
1256
1257
1258
1259
1260
1261static void ep_free_request(struct usb_ep *ep, struct usb_request *req)
1262{
1263 struct ci_hw_ep *hwep = container_of(ep, struct ci_hw_ep, ep);
1264 struct ci_hw_req *hwreq = container_of(req, struct ci_hw_req, req);
1265 struct td_node *node, *tmpnode;
1266 unsigned long flags;
1267
1268 if (ep == NULL || req == NULL) {
1269 return;
1270 } else if (!list_empty(&hwreq->queue)) {
1271 dev_err(hwep->ci->dev, "freeing queued request\n");
1272 return;
1273 }
1274
1275 spin_lock_irqsave(hwep->lock, flags);
1276
1277 list_for_each_entry_safe(node, tmpnode, &hwreq->tds, td) {
1278 dma_pool_free(hwep->td_pool, node->ptr, node->dma);
1279 list_del_init(&node->td);
1280 node->ptr = NULL;
1281 kfree(node);
1282 }
1283
1284 kfree(hwreq);
1285
1286 spin_unlock_irqrestore(hwep->lock, flags);
1287}
1288
1289
1290
1291
1292
1293
1294static int ep_queue(struct usb_ep *ep, struct usb_request *req,
1295 gfp_t __maybe_unused gfp_flags)
1296{
1297 struct ci_hw_ep *hwep = container_of(ep, struct ci_hw_ep, ep);
1298 int retval = 0;
1299 unsigned long flags;
1300
1301 if (ep == NULL || req == NULL || hwep->ep.desc == NULL)
1302 return -EINVAL;
1303
1304 spin_lock_irqsave(hwep->lock, flags);
1305 retval = _ep_queue(ep, req, gfp_flags);
1306 spin_unlock_irqrestore(hwep->lock, flags);
1307 return retval;
1308}
1309
1310
1311
1312
1313
1314
1315static int ep_dequeue(struct usb_ep *ep, struct usb_request *req)
1316{
1317 struct ci_hw_ep *hwep = container_of(ep, struct ci_hw_ep, ep);
1318 struct ci_hw_req *hwreq = container_of(req, struct ci_hw_req, req);
1319 unsigned long flags;
1320 struct td_node *node, *tmpnode;
1321
1322 if (ep == NULL || req == NULL || hwreq->req.status != -EALREADY ||
1323 hwep->ep.desc == NULL || list_empty(&hwreq->queue) ||
1324 list_empty(&hwep->qh.queue))
1325 return -EINVAL;
1326
1327 spin_lock_irqsave(hwep->lock, flags);
1328
1329 hw_ep_flush(hwep->ci, hwep->num, hwep->dir);
1330
1331 list_for_each_entry_safe(node, tmpnode, &hwreq->tds, td) {
1332 dma_pool_free(hwep->td_pool, node->ptr, node->dma);
1333 list_del(&node->td);
1334 kfree(node);
1335 }
1336
1337
1338 list_del_init(&hwreq->queue);
1339
1340 usb_gadget_unmap_request(&hwep->ci->gadget, req, hwep->dir);
1341
1342 req->status = -ECONNRESET;
1343
1344 if (hwreq->req.complete != NULL) {
1345 spin_unlock(hwep->lock);
1346 usb_gadget_giveback_request(&hwep->ep, &hwreq->req);
1347 spin_lock(hwep->lock);
1348 }
1349
1350 spin_unlock_irqrestore(hwep->lock, flags);
1351 return 0;
1352}
1353
1354
1355
1356
1357
1358
1359static int ep_set_halt(struct usb_ep *ep, int value)
1360{
1361 struct ci_hw_ep *hwep = container_of(ep, struct ci_hw_ep, ep);
1362 int direction, retval = 0;
1363 unsigned long flags;
1364
1365 if (ep == NULL || hwep->ep.desc == NULL)
1366 return -EINVAL;
1367
1368 if (usb_endpoint_xfer_isoc(hwep->ep.desc))
1369 return -EOPNOTSUPP;
1370
1371 spin_lock_irqsave(hwep->lock, flags);
1372
1373#ifndef STALL_IN
1374
1375 if (value && hwep->type == USB_ENDPOINT_XFER_BULK && hwep->dir == TX &&
1376 !list_empty(&hwep->qh.queue)) {
1377 spin_unlock_irqrestore(hwep->lock, flags);
1378 return -EAGAIN;
1379 }
1380#endif
1381
1382 direction = hwep->dir;
1383 do {
1384 retval |= hw_ep_set_halt(hwep->ci, hwep->num, hwep->dir, value);
1385
1386 if (!value)
1387 hwep->wedge = 0;
1388
1389 if (hwep->type == USB_ENDPOINT_XFER_CONTROL)
1390 hwep->dir = (hwep->dir == TX) ? RX : TX;
1391
1392 } while (hwep->dir != direction);
1393
1394 spin_unlock_irqrestore(hwep->lock, flags);
1395 return retval;
1396}
1397
1398
1399
1400
1401
1402
1403static int ep_set_wedge(struct usb_ep *ep)
1404{
1405 struct ci_hw_ep *hwep = container_of(ep, struct ci_hw_ep, ep);
1406 unsigned long flags;
1407
1408 if (ep == NULL || hwep->ep.desc == NULL)
1409 return -EINVAL;
1410
1411 spin_lock_irqsave(hwep->lock, flags);
1412 hwep->wedge = 1;
1413 spin_unlock_irqrestore(hwep->lock, flags);
1414
1415 return usb_ep_set_halt(ep);
1416}
1417
1418
1419
1420
1421
1422
1423static void ep_fifo_flush(struct usb_ep *ep)
1424{
1425 struct ci_hw_ep *hwep = container_of(ep, struct ci_hw_ep, ep);
1426 unsigned long flags;
1427
1428 if (ep == NULL) {
1429 dev_err(hwep->ci->dev, "%02X: -EINVAL\n", _usb_addr(hwep));
1430 return;
1431 }
1432
1433 spin_lock_irqsave(hwep->lock, flags);
1434
1435 hw_ep_flush(hwep->ci, hwep->num, hwep->dir);
1436
1437 spin_unlock_irqrestore(hwep->lock, flags);
1438}
1439
1440
1441
1442
1443
1444static const struct usb_ep_ops usb_ep_ops = {
1445 .enable = ep_enable,
1446 .disable = ep_disable,
1447 .alloc_request = ep_alloc_request,
1448 .free_request = ep_free_request,
1449 .queue = ep_queue,
1450 .dequeue = ep_dequeue,
1451 .set_halt = ep_set_halt,
1452 .set_wedge = ep_set_wedge,
1453 .fifo_flush = ep_fifo_flush,
1454};
1455
1456
1457
1458
1459static int ci_udc_vbus_session(struct usb_gadget *_gadget, int is_active)
1460{
1461 struct ci_hdrc *ci = container_of(_gadget, struct ci_hdrc, gadget);
1462 unsigned long flags;
1463 int gadget_ready = 0;
1464
1465 spin_lock_irqsave(&ci->lock, flags);
1466 ci->vbus_active = is_active;
1467 if (ci->driver)
1468 gadget_ready = 1;
1469 spin_unlock_irqrestore(&ci->lock, flags);
1470
1471 if (gadget_ready) {
1472 if (is_active) {
1473 pm_runtime_get_sync(&_gadget->dev);
1474 hw_device_reset(ci);
1475 hw_device_state(ci, ci->ep0out->qh.dma);
1476 usb_gadget_set_state(_gadget, USB_STATE_POWERED);
1477 } else {
1478 if (ci->driver)
1479 ci->driver->disconnect(&ci->gadget);
1480 hw_device_state(ci, 0);
1481 if (ci->platdata->notify_event)
1482 ci->platdata->notify_event(ci,
1483 CI_HDRC_CONTROLLER_STOPPED_EVENT);
1484 _gadget_stop_activity(&ci->gadget);
1485 pm_runtime_put_sync(&_gadget->dev);
1486 usb_gadget_set_state(_gadget, USB_STATE_NOTATTACHED);
1487 }
1488 }
1489
1490 return 0;
1491}
1492
1493static int ci_udc_wakeup(struct usb_gadget *_gadget)
1494{
1495 struct ci_hdrc *ci = container_of(_gadget, struct ci_hdrc, gadget);
1496 unsigned long flags;
1497 int ret = 0;
1498
1499 spin_lock_irqsave(&ci->lock, flags);
1500 if (!ci->remote_wakeup) {
1501 ret = -EOPNOTSUPP;
1502 goto out;
1503 }
1504 if (!hw_read(ci, OP_PORTSC, PORTSC_SUSP)) {
1505 ret = -EINVAL;
1506 goto out;
1507 }
1508 hw_write(ci, OP_PORTSC, PORTSC_FPR, PORTSC_FPR);
1509out:
1510 spin_unlock_irqrestore(&ci->lock, flags);
1511 return ret;
1512}
1513
1514static int ci_udc_vbus_draw(struct usb_gadget *_gadget, unsigned ma)
1515{
1516 struct ci_hdrc *ci = container_of(_gadget, struct ci_hdrc, gadget);
1517
1518 if (ci->usb_phy)
1519 return usb_phy_set_power(ci->usb_phy, ma);
1520 return -ENOTSUPP;
1521}
1522
1523
1524
1525
1526static int ci_udc_pullup(struct usb_gadget *_gadget, int is_on)
1527{
1528 struct ci_hdrc *ci = container_of(_gadget, struct ci_hdrc, gadget);
1529
1530 if (!ci->vbus_active)
1531 return -EOPNOTSUPP;
1532
1533 if (is_on)
1534 hw_write(ci, OP_USBCMD, USBCMD_RS, USBCMD_RS);
1535 else
1536 hw_write(ci, OP_USBCMD, USBCMD_RS, 0);
1537
1538 return 0;
1539}
1540
1541static int ci_udc_start(struct usb_gadget *gadget,
1542 struct usb_gadget_driver *driver);
1543static int ci_udc_stop(struct usb_gadget *gadget);
1544
1545
1546
1547
1548
1549static const struct usb_gadget_ops usb_gadget_ops = {
1550 .vbus_session = ci_udc_vbus_session,
1551 .wakeup = ci_udc_wakeup,
1552 .pullup = ci_udc_pullup,
1553 .vbus_draw = ci_udc_vbus_draw,
1554 .udc_start = ci_udc_start,
1555 .udc_stop = ci_udc_stop,
1556};
1557
1558static int init_eps(struct ci_hdrc *ci)
1559{
1560 int retval = 0, i, j;
1561
1562 for (i = 0; i < ci->hw_ep_max/2; i++)
1563 for (j = RX; j <= TX; j++) {
1564 int k = i + j * ci->hw_ep_max/2;
1565 struct ci_hw_ep *hwep = &ci->ci_hw_ep[k];
1566
1567 scnprintf(hwep->name, sizeof(hwep->name), "ep%i%s", i,
1568 (j == TX) ? "in" : "out");
1569
1570 hwep->ci = ci;
1571 hwep->lock = &ci->lock;
1572 hwep->td_pool = ci->td_pool;
1573
1574 hwep->ep.name = hwep->name;
1575 hwep->ep.ops = &usb_ep_ops;
1576
1577
1578
1579
1580
1581 usb_ep_set_maxpacket_limit(&hwep->ep, (unsigned short)~0);
1582
1583 INIT_LIST_HEAD(&hwep->qh.queue);
1584 hwep->qh.ptr = dma_pool_alloc(ci->qh_pool, GFP_KERNEL,
1585 &hwep->qh.dma);
1586 if (hwep->qh.ptr == NULL)
1587 retval = -ENOMEM;
1588 else
1589 memset(hwep->qh.ptr, 0, sizeof(*hwep->qh.ptr));
1590
1591
1592
1593
1594
1595 if (i == 0) {
1596 if (j == RX)
1597 ci->ep0out = hwep;
1598 else
1599 ci->ep0in = hwep;
1600
1601 usb_ep_set_maxpacket_limit(&hwep->ep, CTRL_PAYLOAD_MAX);
1602 continue;
1603 }
1604
1605 list_add_tail(&hwep->ep.ep_list, &ci->gadget.ep_list);
1606 }
1607
1608 return retval;
1609}
1610
1611static void destroy_eps(struct ci_hdrc *ci)
1612{
1613 int i;
1614
1615 for (i = 0; i < ci->hw_ep_max; i++) {
1616 struct ci_hw_ep *hwep = &ci->ci_hw_ep[i];
1617
1618 if (hwep->pending_td)
1619 free_pending_td(hwep);
1620 dma_pool_free(ci->qh_pool, hwep->qh.ptr, hwep->qh.dma);
1621 }
1622}
1623
1624
1625
1626
1627
1628
1629
1630
1631static int ci_udc_start(struct usb_gadget *gadget,
1632 struct usb_gadget_driver *driver)
1633{
1634 struct ci_hdrc *ci = container_of(gadget, struct ci_hdrc, gadget);
1635 unsigned long flags;
1636 int retval = -ENOMEM;
1637
1638 if (driver->disconnect == NULL)
1639 return -EINVAL;
1640
1641
1642 ci->ep0out->ep.desc = &ctrl_endpt_out_desc;
1643 retval = usb_ep_enable(&ci->ep0out->ep);
1644 if (retval)
1645 return retval;
1646
1647 ci->ep0in->ep.desc = &ctrl_endpt_in_desc;
1648 retval = usb_ep_enable(&ci->ep0in->ep);
1649 if (retval)
1650 return retval;
1651
1652 ci->driver = driver;
1653
1654
1655 if (ci_otg_is_fsm_mode(ci) && ci->fsm.id) {
1656 ci_hdrc_otg_fsm_start(ci);
1657 return retval;
1658 }
1659
1660 pm_runtime_get_sync(&ci->gadget.dev);
1661 if (ci->vbus_active) {
1662 spin_lock_irqsave(&ci->lock, flags);
1663 hw_device_reset(ci);
1664 } else {
1665 pm_runtime_put_sync(&ci->gadget.dev);
1666 return retval;
1667 }
1668
1669 retval = hw_device_state(ci, ci->ep0out->qh.dma);
1670 spin_unlock_irqrestore(&ci->lock, flags);
1671 if (retval)
1672 pm_runtime_put_sync(&ci->gadget.dev);
1673
1674 return retval;
1675}
1676
1677
1678
1679
1680static int ci_udc_stop(struct usb_gadget *gadget)
1681{
1682 struct ci_hdrc *ci = container_of(gadget, struct ci_hdrc, gadget);
1683 unsigned long flags;
1684
1685 spin_lock_irqsave(&ci->lock, flags);
1686
1687 if (ci->vbus_active) {
1688 hw_device_state(ci, 0);
1689 if (ci->platdata->notify_event)
1690 ci->platdata->notify_event(ci,
1691 CI_HDRC_CONTROLLER_STOPPED_EVENT);
1692 spin_unlock_irqrestore(&ci->lock, flags);
1693 _gadget_stop_activity(&ci->gadget);
1694 spin_lock_irqsave(&ci->lock, flags);
1695 pm_runtime_put(&ci->gadget.dev);
1696 }
1697
1698 ci->driver = NULL;
1699 spin_unlock_irqrestore(&ci->lock, flags);
1700
1701 return 0;
1702}
1703
1704
1705
1706
1707
1708
1709
1710
1711
1712
1713static irqreturn_t udc_irq(struct ci_hdrc *ci)
1714{
1715 irqreturn_t retval;
1716 u32 intr;
1717
1718 if (ci == NULL)
1719 return IRQ_HANDLED;
1720
1721 spin_lock(&ci->lock);
1722
1723 if (ci->platdata->flags & CI_HDRC_REGS_SHARED) {
1724 if (hw_read(ci, OP_USBMODE, USBMODE_CM) !=
1725 USBMODE_CM_DC) {
1726 spin_unlock(&ci->lock);
1727 return IRQ_NONE;
1728 }
1729 }
1730 intr = hw_test_and_clear_intr_active(ci);
1731
1732 if (intr) {
1733
1734 if (USBi_URI & intr)
1735 isr_reset_handler(ci);
1736
1737 if (USBi_PCI & intr) {
1738 ci->gadget.speed = hw_port_is_high_speed(ci) ?
1739 USB_SPEED_HIGH : USB_SPEED_FULL;
1740 if (ci->suspended && ci->driver->resume) {
1741 spin_unlock(&ci->lock);
1742 ci->driver->resume(&ci->gadget);
1743 spin_lock(&ci->lock);
1744 ci->suspended = 0;
1745 }
1746 }
1747
1748 if (USBi_UI & intr)
1749 isr_tr_complete_handler(ci);
1750
1751 if (USBi_SLI & intr) {
1752 if (ci->gadget.speed != USB_SPEED_UNKNOWN &&
1753 ci->driver->suspend) {
1754 ci->suspended = 1;
1755 spin_unlock(&ci->lock);
1756 ci->driver->suspend(&ci->gadget);
1757 usb_gadget_set_state(&ci->gadget,
1758 USB_STATE_SUSPENDED);
1759 spin_lock(&ci->lock);
1760 }
1761 }
1762 retval = IRQ_HANDLED;
1763 } else {
1764 retval = IRQ_NONE;
1765 }
1766 spin_unlock(&ci->lock);
1767
1768 return retval;
1769}
1770
1771
1772
1773
1774
1775static int udc_start(struct ci_hdrc *ci)
1776{
1777 struct device *dev = ci->dev;
1778 int retval = 0;
1779
1780 spin_lock_init(&ci->lock);
1781
1782 ci->gadget.ops = &usb_gadget_ops;
1783 ci->gadget.speed = USB_SPEED_UNKNOWN;
1784 ci->gadget.max_speed = USB_SPEED_HIGH;
1785 ci->gadget.is_otg = ci->is_otg ? 1 : 0;
1786 ci->gadget.name = ci->platdata->name;
1787
1788 INIT_LIST_HEAD(&ci->gadget.ep_list);
1789
1790
1791 ci->qh_pool = dma_pool_create("ci_hw_qh", dev,
1792 sizeof(struct ci_hw_qh),
1793 64, CI_HDRC_PAGE_SIZE);
1794 if (ci->qh_pool == NULL)
1795 return -ENOMEM;
1796
1797 ci->td_pool = dma_pool_create("ci_hw_td", dev,
1798 sizeof(struct ci_hw_td),
1799 64, CI_HDRC_PAGE_SIZE);
1800 if (ci->td_pool == NULL) {
1801 retval = -ENOMEM;
1802 goto free_qh_pool;
1803 }
1804
1805 retval = init_eps(ci);
1806 if (retval)
1807 goto free_pools;
1808
1809 ci->gadget.ep0 = &ci->ep0in->ep;
1810
1811 retval = usb_add_gadget_udc(dev, &ci->gadget);
1812 if (retval)
1813 goto destroy_eps;
1814
1815 pm_runtime_no_callbacks(&ci->gadget.dev);
1816 pm_runtime_enable(&ci->gadget.dev);
1817
1818 return retval;
1819
1820destroy_eps:
1821 destroy_eps(ci);
1822free_pools:
1823 dma_pool_destroy(ci->td_pool);
1824free_qh_pool:
1825 dma_pool_destroy(ci->qh_pool);
1826 return retval;
1827}
1828
1829
1830
1831
1832
1833
1834void ci_hdrc_gadget_destroy(struct ci_hdrc *ci)
1835{
1836 if (!ci->roles[CI_ROLE_GADGET])
1837 return;
1838
1839 usb_del_gadget_udc(&ci->gadget);
1840
1841 destroy_eps(ci);
1842
1843 dma_pool_destroy(ci->td_pool);
1844 dma_pool_destroy(ci->qh_pool);
1845}
1846
1847static int udc_id_switch_for_device(struct ci_hdrc *ci)
1848{
1849 if (ci->is_otg)
1850
1851 hw_write_otgsc(ci, OTGSC_BSVIS | OTGSC_BSVIE,
1852 OTGSC_BSVIS | OTGSC_BSVIE);
1853
1854 return 0;
1855}
1856
1857static void udc_id_switch_for_host(struct ci_hdrc *ci)
1858{
1859
1860
1861
1862
1863 if (ci->is_otg)
1864 hw_write_otgsc(ci, OTGSC_BSVIE | OTGSC_BSVIS, OTGSC_BSVIS);
1865}
1866
1867
1868
1869
1870
1871
1872
1873int ci_hdrc_gadget_init(struct ci_hdrc *ci)
1874{
1875 struct ci_role_driver *rdrv;
1876
1877 if (!hw_read(ci, CAP_DCCPARAMS, DCCPARAMS_DC))
1878 return -ENXIO;
1879
1880 rdrv = devm_kzalloc(ci->dev, sizeof(struct ci_role_driver), GFP_KERNEL);
1881 if (!rdrv)
1882 return -ENOMEM;
1883
1884 rdrv->start = udc_id_switch_for_device;
1885 rdrv->stop = udc_id_switch_for_host;
1886 rdrv->irq = udc_irq;
1887 rdrv->name = "gadget";
1888 ci->roles[CI_ROLE_GADGET] = rdrv;
1889
1890 return udc_start(ci);
1891}
1892