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 *(u16 *)req->buf = (ci->remote_wakeup << 1) |
823 ci->gadget.is_selfpowered;
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
932static int otg_a_alt_hnp_support(struct ci_hdrc *ci)
933{
934 dev_warn(&ci->gadget.dev,
935 "connect the device to an alternate port if you want HNP\n");
936 return isr_setup_status_phase(ci);
937}
938
939
940
941
942
943
944
945static void isr_setup_packet_handler(struct ci_hdrc *ci)
946__releases(ci->lock)
947__acquires(ci->lock)
948{
949 struct ci_hw_ep *hwep = &ci->ci_hw_ep[0];
950 struct usb_ctrlrequest req;
951 int type, num, dir, err = -EINVAL;
952 u8 tmode = 0;
953
954
955
956
957
958 _ep_nuke(ci->ep0out);
959 _ep_nuke(ci->ep0in);
960
961
962 do {
963 hw_test_and_set_setup_guard(ci);
964 memcpy(&req, &hwep->qh.ptr->setup, sizeof(req));
965 } while (!hw_test_and_clear_setup_guard(ci));
966
967 type = req.bRequestType;
968
969 ci->ep0_dir = (type & USB_DIR_IN) ? TX : RX;
970
971 switch (req.bRequest) {
972 case USB_REQ_CLEAR_FEATURE:
973 if (type == (USB_DIR_OUT|USB_RECIP_ENDPOINT) &&
974 le16_to_cpu(req.wValue) ==
975 USB_ENDPOINT_HALT) {
976 if (req.wLength != 0)
977 break;
978 num = le16_to_cpu(req.wIndex);
979 dir = num & USB_ENDPOINT_DIR_MASK;
980 num &= USB_ENDPOINT_NUMBER_MASK;
981 if (dir)
982 num += ci->hw_ep_max / 2;
983 if (!ci->ci_hw_ep[num].wedge) {
984 spin_unlock(&ci->lock);
985 err = usb_ep_clear_halt(
986 &ci->ci_hw_ep[num].ep);
987 spin_lock(&ci->lock);
988 if (err)
989 break;
990 }
991 err = isr_setup_status_phase(ci);
992 } else if (type == (USB_DIR_OUT|USB_RECIP_DEVICE) &&
993 le16_to_cpu(req.wValue) ==
994 USB_DEVICE_REMOTE_WAKEUP) {
995 if (req.wLength != 0)
996 break;
997 ci->remote_wakeup = 0;
998 err = isr_setup_status_phase(ci);
999 } else {
1000 goto delegate;
1001 }
1002 break;
1003 case USB_REQ_GET_STATUS:
1004 if (type != (USB_DIR_IN|USB_RECIP_DEVICE) &&
1005 type != (USB_DIR_IN|USB_RECIP_ENDPOINT) &&
1006 type != (USB_DIR_IN|USB_RECIP_INTERFACE))
1007 goto delegate;
1008 if (le16_to_cpu(req.wLength) != 2 ||
1009 le16_to_cpu(req.wValue) != 0)
1010 break;
1011 err = isr_get_status_response(ci, &req);
1012 break;
1013 case USB_REQ_SET_ADDRESS:
1014 if (type != (USB_DIR_OUT|USB_RECIP_DEVICE))
1015 goto delegate;
1016 if (le16_to_cpu(req.wLength) != 0 ||
1017 le16_to_cpu(req.wIndex) != 0)
1018 break;
1019 ci->address = (u8)le16_to_cpu(req.wValue);
1020 ci->setaddr = true;
1021 err = isr_setup_status_phase(ci);
1022 break;
1023 case USB_REQ_SET_FEATURE:
1024 if (type == (USB_DIR_OUT|USB_RECIP_ENDPOINT) &&
1025 le16_to_cpu(req.wValue) ==
1026 USB_ENDPOINT_HALT) {
1027 if (req.wLength != 0)
1028 break;
1029 num = le16_to_cpu(req.wIndex);
1030 dir = num & USB_ENDPOINT_DIR_MASK;
1031 num &= USB_ENDPOINT_NUMBER_MASK;
1032 if (dir)
1033 num += ci->hw_ep_max / 2;
1034
1035 spin_unlock(&ci->lock);
1036 err = usb_ep_set_halt(&ci->ci_hw_ep[num].ep);
1037 spin_lock(&ci->lock);
1038 if (!err)
1039 isr_setup_status_phase(ci);
1040 } else if (type == (USB_DIR_OUT|USB_RECIP_DEVICE)) {
1041 if (req.wLength != 0)
1042 break;
1043 switch (le16_to_cpu(req.wValue)) {
1044 case USB_DEVICE_REMOTE_WAKEUP:
1045 ci->remote_wakeup = 1;
1046 err = isr_setup_status_phase(ci);
1047 break;
1048 case USB_DEVICE_TEST_MODE:
1049 tmode = le16_to_cpu(req.wIndex) >> 8;
1050 switch (tmode) {
1051 case TEST_J:
1052 case TEST_K:
1053 case TEST_SE0_NAK:
1054 case TEST_PACKET:
1055 case TEST_FORCE_EN:
1056 ci->test_mode = tmode;
1057 err = isr_setup_status_phase(
1058 ci);
1059 break;
1060 default:
1061 break;
1062 }
1063 break;
1064 case USB_DEVICE_B_HNP_ENABLE:
1065 if (ci_otg_is_fsm_mode(ci)) {
1066 ci->gadget.b_hnp_enable = 1;
1067 err = isr_setup_status_phase(
1068 ci);
1069 }
1070 break;
1071 case USB_DEVICE_A_ALT_HNP_SUPPORT:
1072 if (ci_otg_is_fsm_mode(ci))
1073 err = otg_a_alt_hnp_support(ci);
1074 break;
1075 default:
1076 goto delegate;
1077 }
1078 } else {
1079 goto delegate;
1080 }
1081 break;
1082 default:
1083delegate:
1084 if (req.wLength == 0)
1085 ci->ep0_dir = TX;
1086
1087 spin_unlock(&ci->lock);
1088 err = ci->driver->setup(&ci->gadget, &req);
1089 spin_lock(&ci->lock);
1090 break;
1091 }
1092
1093 if (err < 0) {
1094 spin_unlock(&ci->lock);
1095 if (usb_ep_set_halt(&hwep->ep))
1096 dev_err(ci->dev, "error: ep_set_halt\n");
1097 spin_lock(&ci->lock);
1098 }
1099}
1100
1101
1102
1103
1104
1105
1106
1107static void isr_tr_complete_handler(struct ci_hdrc *ci)
1108__releases(ci->lock)
1109__acquires(ci->lock)
1110{
1111 unsigned i;
1112 int err;
1113
1114 for (i = 0; i < ci->hw_ep_max; i++) {
1115 struct ci_hw_ep *hwep = &ci->ci_hw_ep[i];
1116
1117 if (hwep->ep.desc == NULL)
1118 continue;
1119
1120 if (hw_test_and_clear_complete(ci, i)) {
1121 err = isr_tr_complete_low(hwep);
1122 if (hwep->type == USB_ENDPOINT_XFER_CONTROL) {
1123 if (err > 0)
1124 err = isr_setup_status_phase(ci);
1125 if (err < 0) {
1126 spin_unlock(&ci->lock);
1127 if (usb_ep_set_halt(&hwep->ep))
1128 dev_err(ci->dev,
1129 "error: ep_set_halt\n");
1130 spin_lock(&ci->lock);
1131 }
1132 }
1133 }
1134
1135
1136 if (i == 0 &&
1137 hw_test_and_clear(ci, OP_ENDPTSETUPSTAT, BIT(0)))
1138 isr_setup_packet_handler(ci);
1139 }
1140}
1141
1142
1143
1144
1145
1146
1147
1148
1149
1150static int ep_enable(struct usb_ep *ep,
1151 const struct usb_endpoint_descriptor *desc)
1152{
1153 struct ci_hw_ep *hwep = container_of(ep, struct ci_hw_ep, ep);
1154 int retval = 0;
1155 unsigned long flags;
1156 u32 cap = 0;
1157
1158 if (ep == NULL || desc == NULL)
1159 return -EINVAL;
1160
1161 spin_lock_irqsave(hwep->lock, flags);
1162
1163
1164
1165 hwep->ep.desc = desc;
1166
1167 if (!list_empty(&hwep->qh.queue))
1168 dev_warn(hwep->ci->dev, "enabling a non-empty endpoint!\n");
1169
1170 hwep->dir = usb_endpoint_dir_in(desc) ? TX : RX;
1171 hwep->num = usb_endpoint_num(desc);
1172 hwep->type = usb_endpoint_type(desc);
1173
1174 hwep->ep.maxpacket = usb_endpoint_maxp(desc) & 0x07ff;
1175 hwep->ep.mult = QH_ISO_MULT(usb_endpoint_maxp(desc));
1176
1177 if (hwep->type == USB_ENDPOINT_XFER_CONTROL)
1178 cap |= QH_IOS;
1179
1180 cap |= QH_ZLT;
1181 cap |= (hwep->ep.maxpacket << __ffs(QH_MAX_PKT)) & QH_MAX_PKT;
1182
1183
1184
1185
1186 if (hwep->type == USB_ENDPOINT_XFER_ISOC && hwep->dir == TX)
1187 cap |= 3 << __ffs(QH_MULT);
1188
1189 hwep->qh.ptr->cap = cpu_to_le32(cap);
1190
1191 hwep->qh.ptr->td.next |= cpu_to_le32(TD_TERMINATE);
1192
1193 if (hwep->num != 0 && hwep->type == USB_ENDPOINT_XFER_CONTROL) {
1194 dev_err(hwep->ci->dev, "Set control xfer at non-ep0\n");
1195 retval = -EINVAL;
1196 }
1197
1198
1199
1200
1201
1202 if (hwep->num)
1203 retval |= hw_ep_enable(hwep->ci, hwep->num, hwep->dir,
1204 hwep->type);
1205
1206 spin_unlock_irqrestore(hwep->lock, flags);
1207 return retval;
1208}
1209
1210
1211
1212
1213
1214
1215static int ep_disable(struct usb_ep *ep)
1216{
1217 struct ci_hw_ep *hwep = container_of(ep, struct ci_hw_ep, ep);
1218 int direction, retval = 0;
1219 unsigned long flags;
1220
1221 if (ep == NULL)
1222 return -EINVAL;
1223 else if (hwep->ep.desc == NULL)
1224 return -EBUSY;
1225
1226 spin_lock_irqsave(hwep->lock, flags);
1227
1228
1229
1230 direction = hwep->dir;
1231 do {
1232 retval |= _ep_nuke(hwep);
1233 retval |= hw_ep_disable(hwep->ci, hwep->num, hwep->dir);
1234
1235 if (hwep->type == USB_ENDPOINT_XFER_CONTROL)
1236 hwep->dir = (hwep->dir == TX) ? RX : TX;
1237
1238 } while (hwep->dir != direction);
1239
1240 hwep->ep.desc = NULL;
1241
1242 spin_unlock_irqrestore(hwep->lock, flags);
1243 return retval;
1244}
1245
1246
1247
1248
1249
1250
1251static struct usb_request *ep_alloc_request(struct usb_ep *ep, gfp_t gfp_flags)
1252{
1253 struct ci_hw_req *hwreq = NULL;
1254
1255 if (ep == NULL)
1256 return NULL;
1257
1258 hwreq = kzalloc(sizeof(struct ci_hw_req), gfp_flags);
1259 if (hwreq != NULL) {
1260 INIT_LIST_HEAD(&hwreq->queue);
1261 INIT_LIST_HEAD(&hwreq->tds);
1262 }
1263
1264 return (hwreq == NULL) ? NULL : &hwreq->req;
1265}
1266
1267
1268
1269
1270
1271
1272static void ep_free_request(struct usb_ep *ep, struct usb_request *req)
1273{
1274 struct ci_hw_ep *hwep = container_of(ep, struct ci_hw_ep, ep);
1275 struct ci_hw_req *hwreq = container_of(req, struct ci_hw_req, req);
1276 struct td_node *node, *tmpnode;
1277 unsigned long flags;
1278
1279 if (ep == NULL || req == NULL) {
1280 return;
1281 } else if (!list_empty(&hwreq->queue)) {
1282 dev_err(hwep->ci->dev, "freeing queued request\n");
1283 return;
1284 }
1285
1286 spin_lock_irqsave(hwep->lock, flags);
1287
1288 list_for_each_entry_safe(node, tmpnode, &hwreq->tds, td) {
1289 dma_pool_free(hwep->td_pool, node->ptr, node->dma);
1290 list_del_init(&node->td);
1291 node->ptr = NULL;
1292 kfree(node);
1293 }
1294
1295 kfree(hwreq);
1296
1297 spin_unlock_irqrestore(hwep->lock, flags);
1298}
1299
1300
1301
1302
1303
1304
1305static int ep_queue(struct usb_ep *ep, struct usb_request *req,
1306 gfp_t __maybe_unused gfp_flags)
1307{
1308 struct ci_hw_ep *hwep = container_of(ep, struct ci_hw_ep, ep);
1309 int retval = 0;
1310 unsigned long flags;
1311
1312 if (ep == NULL || req == NULL || hwep->ep.desc == NULL)
1313 return -EINVAL;
1314
1315 spin_lock_irqsave(hwep->lock, flags);
1316 retval = _ep_queue(ep, req, gfp_flags);
1317 spin_unlock_irqrestore(hwep->lock, flags);
1318 return retval;
1319}
1320
1321
1322
1323
1324
1325
1326static int ep_dequeue(struct usb_ep *ep, struct usb_request *req)
1327{
1328 struct ci_hw_ep *hwep = container_of(ep, struct ci_hw_ep, ep);
1329 struct ci_hw_req *hwreq = container_of(req, struct ci_hw_req, req);
1330 unsigned long flags;
1331 struct td_node *node, *tmpnode;
1332
1333 if (ep == NULL || req == NULL || hwreq->req.status != -EALREADY ||
1334 hwep->ep.desc == NULL || list_empty(&hwreq->queue) ||
1335 list_empty(&hwep->qh.queue))
1336 return -EINVAL;
1337
1338 spin_lock_irqsave(hwep->lock, flags);
1339
1340 hw_ep_flush(hwep->ci, hwep->num, hwep->dir);
1341
1342 list_for_each_entry_safe(node, tmpnode, &hwreq->tds, td) {
1343 dma_pool_free(hwep->td_pool, node->ptr, node->dma);
1344 list_del(&node->td);
1345 kfree(node);
1346 }
1347
1348
1349 list_del_init(&hwreq->queue);
1350
1351 usb_gadget_unmap_request(&hwep->ci->gadget, req, hwep->dir);
1352
1353 req->status = -ECONNRESET;
1354
1355 if (hwreq->req.complete != NULL) {
1356 spin_unlock(hwep->lock);
1357 usb_gadget_giveback_request(&hwep->ep, &hwreq->req);
1358 spin_lock(hwep->lock);
1359 }
1360
1361 spin_unlock_irqrestore(hwep->lock, flags);
1362 return 0;
1363}
1364
1365
1366
1367
1368
1369
1370static int ep_set_halt(struct usb_ep *ep, int value)
1371{
1372 struct ci_hw_ep *hwep = container_of(ep, struct ci_hw_ep, ep);
1373 int direction, retval = 0;
1374 unsigned long flags;
1375
1376 if (ep == NULL || hwep->ep.desc == NULL)
1377 return -EINVAL;
1378
1379 if (usb_endpoint_xfer_isoc(hwep->ep.desc))
1380 return -EOPNOTSUPP;
1381
1382 spin_lock_irqsave(hwep->lock, flags);
1383
1384#ifndef STALL_IN
1385
1386 if (value && hwep->type == USB_ENDPOINT_XFER_BULK && hwep->dir == TX &&
1387 !list_empty(&hwep->qh.queue)) {
1388 spin_unlock_irqrestore(hwep->lock, flags);
1389 return -EAGAIN;
1390 }
1391#endif
1392
1393 direction = hwep->dir;
1394 do {
1395 retval |= hw_ep_set_halt(hwep->ci, hwep->num, hwep->dir, value);
1396
1397 if (!value)
1398 hwep->wedge = 0;
1399
1400 if (hwep->type == USB_ENDPOINT_XFER_CONTROL)
1401 hwep->dir = (hwep->dir == TX) ? RX : TX;
1402
1403 } while (hwep->dir != direction);
1404
1405 spin_unlock_irqrestore(hwep->lock, flags);
1406 return retval;
1407}
1408
1409
1410
1411
1412
1413
1414static int ep_set_wedge(struct usb_ep *ep)
1415{
1416 struct ci_hw_ep *hwep = container_of(ep, struct ci_hw_ep, ep);
1417 unsigned long flags;
1418
1419 if (ep == NULL || hwep->ep.desc == NULL)
1420 return -EINVAL;
1421
1422 spin_lock_irqsave(hwep->lock, flags);
1423 hwep->wedge = 1;
1424 spin_unlock_irqrestore(hwep->lock, flags);
1425
1426 return usb_ep_set_halt(ep);
1427}
1428
1429
1430
1431
1432
1433
1434static void ep_fifo_flush(struct usb_ep *ep)
1435{
1436 struct ci_hw_ep *hwep = container_of(ep, struct ci_hw_ep, ep);
1437 unsigned long flags;
1438
1439 if (ep == NULL) {
1440 dev_err(hwep->ci->dev, "%02X: -EINVAL\n", _usb_addr(hwep));
1441 return;
1442 }
1443
1444 spin_lock_irqsave(hwep->lock, flags);
1445
1446 hw_ep_flush(hwep->ci, hwep->num, hwep->dir);
1447
1448 spin_unlock_irqrestore(hwep->lock, flags);
1449}
1450
1451
1452
1453
1454
1455static const struct usb_ep_ops usb_ep_ops = {
1456 .enable = ep_enable,
1457 .disable = ep_disable,
1458 .alloc_request = ep_alloc_request,
1459 .free_request = ep_free_request,
1460 .queue = ep_queue,
1461 .dequeue = ep_dequeue,
1462 .set_halt = ep_set_halt,
1463 .set_wedge = ep_set_wedge,
1464 .fifo_flush = ep_fifo_flush,
1465};
1466
1467
1468
1469
1470static int ci_udc_vbus_session(struct usb_gadget *_gadget, int is_active)
1471{
1472 struct ci_hdrc *ci = container_of(_gadget, struct ci_hdrc, gadget);
1473 unsigned long flags;
1474 int gadget_ready = 0;
1475
1476 spin_lock_irqsave(&ci->lock, flags);
1477 ci->vbus_active = is_active;
1478 if (ci->driver)
1479 gadget_ready = 1;
1480 spin_unlock_irqrestore(&ci->lock, flags);
1481
1482 if (gadget_ready) {
1483 if (is_active) {
1484 pm_runtime_get_sync(&_gadget->dev);
1485 hw_device_reset(ci);
1486 hw_device_state(ci, ci->ep0out->qh.dma);
1487 usb_gadget_set_state(_gadget, USB_STATE_POWERED);
1488 } else {
1489 if (ci->driver)
1490 ci->driver->disconnect(&ci->gadget);
1491 hw_device_state(ci, 0);
1492 if (ci->platdata->notify_event)
1493 ci->platdata->notify_event(ci,
1494 CI_HDRC_CONTROLLER_STOPPED_EVENT);
1495 _gadget_stop_activity(&ci->gadget);
1496 pm_runtime_put_sync(&_gadget->dev);
1497 usb_gadget_set_state(_gadget, USB_STATE_NOTATTACHED);
1498 }
1499 }
1500
1501 return 0;
1502}
1503
1504static int ci_udc_wakeup(struct usb_gadget *_gadget)
1505{
1506 struct ci_hdrc *ci = container_of(_gadget, struct ci_hdrc, gadget);
1507 unsigned long flags;
1508 int ret = 0;
1509
1510 spin_lock_irqsave(&ci->lock, flags);
1511 if (!ci->remote_wakeup) {
1512 ret = -EOPNOTSUPP;
1513 goto out;
1514 }
1515 if (!hw_read(ci, OP_PORTSC, PORTSC_SUSP)) {
1516 ret = -EINVAL;
1517 goto out;
1518 }
1519 hw_write(ci, OP_PORTSC, PORTSC_FPR, PORTSC_FPR);
1520out:
1521 spin_unlock_irqrestore(&ci->lock, flags);
1522 return ret;
1523}
1524
1525static int ci_udc_vbus_draw(struct usb_gadget *_gadget, unsigned ma)
1526{
1527 struct ci_hdrc *ci = container_of(_gadget, struct ci_hdrc, gadget);
1528
1529 if (ci->usb_phy)
1530 return usb_phy_set_power(ci->usb_phy, ma);
1531 return -ENOTSUPP;
1532}
1533
1534static int ci_udc_selfpowered(struct usb_gadget *_gadget, int is_on)
1535{
1536 struct ci_hdrc *ci = container_of(_gadget, struct ci_hdrc, gadget);
1537 struct ci_hw_ep *hwep = ci->ep0in;
1538 unsigned long flags;
1539
1540 spin_lock_irqsave(hwep->lock, flags);
1541 _gadget->is_selfpowered = (is_on != 0);
1542 spin_unlock_irqrestore(hwep->lock, flags);
1543
1544 return 0;
1545}
1546
1547
1548
1549
1550static int ci_udc_pullup(struct usb_gadget *_gadget, int is_on)
1551{
1552 struct ci_hdrc *ci = container_of(_gadget, struct ci_hdrc, gadget);
1553
1554 if (!ci->vbus_active)
1555 return -EOPNOTSUPP;
1556
1557 if (is_on)
1558 hw_write(ci, OP_USBCMD, USBCMD_RS, USBCMD_RS);
1559 else
1560 hw_write(ci, OP_USBCMD, USBCMD_RS, 0);
1561
1562 return 0;
1563}
1564
1565static int ci_udc_start(struct usb_gadget *gadget,
1566 struct usb_gadget_driver *driver);
1567static int ci_udc_stop(struct usb_gadget *gadget);
1568
1569
1570
1571
1572
1573static const struct usb_gadget_ops usb_gadget_ops = {
1574 .vbus_session = ci_udc_vbus_session,
1575 .wakeup = ci_udc_wakeup,
1576 .set_selfpowered = ci_udc_selfpowered,
1577 .pullup = ci_udc_pullup,
1578 .vbus_draw = ci_udc_vbus_draw,
1579 .udc_start = ci_udc_start,
1580 .udc_stop = ci_udc_stop,
1581};
1582
1583static int init_eps(struct ci_hdrc *ci)
1584{
1585 int retval = 0, i, j;
1586
1587 for (i = 0; i < ci->hw_ep_max/2; i++)
1588 for (j = RX; j <= TX; j++) {
1589 int k = i + j * ci->hw_ep_max/2;
1590 struct ci_hw_ep *hwep = &ci->ci_hw_ep[k];
1591
1592 scnprintf(hwep->name, sizeof(hwep->name), "ep%i%s", i,
1593 (j == TX) ? "in" : "out");
1594
1595 hwep->ci = ci;
1596 hwep->lock = &ci->lock;
1597 hwep->td_pool = ci->td_pool;
1598
1599 hwep->ep.name = hwep->name;
1600 hwep->ep.ops = &usb_ep_ops;
1601
1602
1603
1604
1605
1606 usb_ep_set_maxpacket_limit(&hwep->ep, (unsigned short)~0);
1607
1608 INIT_LIST_HEAD(&hwep->qh.queue);
1609 hwep->qh.ptr = dma_pool_alloc(ci->qh_pool, GFP_KERNEL,
1610 &hwep->qh.dma);
1611 if (hwep->qh.ptr == NULL)
1612 retval = -ENOMEM;
1613 else
1614 memset(hwep->qh.ptr, 0, sizeof(*hwep->qh.ptr));
1615
1616
1617
1618
1619
1620 if (i == 0) {
1621 if (j == RX)
1622 ci->ep0out = hwep;
1623 else
1624 ci->ep0in = hwep;
1625
1626 usb_ep_set_maxpacket_limit(&hwep->ep, CTRL_PAYLOAD_MAX);
1627 continue;
1628 }
1629
1630 list_add_tail(&hwep->ep.ep_list, &ci->gadget.ep_list);
1631 }
1632
1633 return retval;
1634}
1635
1636static void destroy_eps(struct ci_hdrc *ci)
1637{
1638 int i;
1639
1640 for (i = 0; i < ci->hw_ep_max; i++) {
1641 struct ci_hw_ep *hwep = &ci->ci_hw_ep[i];
1642
1643 if (hwep->pending_td)
1644 free_pending_td(hwep);
1645 dma_pool_free(ci->qh_pool, hwep->qh.ptr, hwep->qh.dma);
1646 }
1647}
1648
1649
1650
1651
1652
1653
1654
1655
1656static int ci_udc_start(struct usb_gadget *gadget,
1657 struct usb_gadget_driver *driver)
1658{
1659 struct ci_hdrc *ci = container_of(gadget, struct ci_hdrc, gadget);
1660 unsigned long flags;
1661 int retval = -ENOMEM;
1662
1663 if (driver->disconnect == NULL)
1664 return -EINVAL;
1665
1666
1667 ci->ep0out->ep.desc = &ctrl_endpt_out_desc;
1668 retval = usb_ep_enable(&ci->ep0out->ep);
1669 if (retval)
1670 return retval;
1671
1672 ci->ep0in->ep.desc = &ctrl_endpt_in_desc;
1673 retval = usb_ep_enable(&ci->ep0in->ep);
1674 if (retval)
1675 return retval;
1676
1677 ci->driver = driver;
1678
1679
1680 if (ci_otg_is_fsm_mode(ci) && ci->fsm.id) {
1681 ci_hdrc_otg_fsm_start(ci);
1682 return retval;
1683 }
1684
1685 pm_runtime_get_sync(&ci->gadget.dev);
1686 if (ci->vbus_active) {
1687 spin_lock_irqsave(&ci->lock, flags);
1688 hw_device_reset(ci);
1689 } else {
1690 pm_runtime_put_sync(&ci->gadget.dev);
1691 return retval;
1692 }
1693
1694 retval = hw_device_state(ci, ci->ep0out->qh.dma);
1695 spin_unlock_irqrestore(&ci->lock, flags);
1696 if (retval)
1697 pm_runtime_put_sync(&ci->gadget.dev);
1698
1699 return retval;
1700}
1701
1702
1703
1704
1705static int ci_udc_stop(struct usb_gadget *gadget)
1706{
1707 struct ci_hdrc *ci = container_of(gadget, struct ci_hdrc, gadget);
1708 unsigned long flags;
1709
1710 spin_lock_irqsave(&ci->lock, flags);
1711
1712 if (ci->vbus_active) {
1713 hw_device_state(ci, 0);
1714 if (ci->platdata->notify_event)
1715 ci->platdata->notify_event(ci,
1716 CI_HDRC_CONTROLLER_STOPPED_EVENT);
1717 spin_unlock_irqrestore(&ci->lock, flags);
1718 _gadget_stop_activity(&ci->gadget);
1719 spin_lock_irqsave(&ci->lock, flags);
1720 pm_runtime_put(&ci->gadget.dev);
1721 }
1722
1723 ci->driver = NULL;
1724 spin_unlock_irqrestore(&ci->lock, flags);
1725
1726 return 0;
1727}
1728
1729
1730
1731
1732
1733
1734
1735
1736
1737
1738static irqreturn_t udc_irq(struct ci_hdrc *ci)
1739{
1740 irqreturn_t retval;
1741 u32 intr;
1742
1743 if (ci == NULL)
1744 return IRQ_HANDLED;
1745
1746 spin_lock(&ci->lock);
1747
1748 if (ci->platdata->flags & CI_HDRC_REGS_SHARED) {
1749 if (hw_read(ci, OP_USBMODE, USBMODE_CM) !=
1750 USBMODE_CM_DC) {
1751 spin_unlock(&ci->lock);
1752 return IRQ_NONE;
1753 }
1754 }
1755 intr = hw_test_and_clear_intr_active(ci);
1756
1757 if (intr) {
1758
1759 if (USBi_URI & intr)
1760 isr_reset_handler(ci);
1761
1762 if (USBi_PCI & intr) {
1763 ci->gadget.speed = hw_port_is_high_speed(ci) ?
1764 USB_SPEED_HIGH : USB_SPEED_FULL;
1765 if (ci->suspended && ci->driver->resume) {
1766 spin_unlock(&ci->lock);
1767 ci->driver->resume(&ci->gadget);
1768 spin_lock(&ci->lock);
1769 ci->suspended = 0;
1770 }
1771 }
1772
1773 if (USBi_UI & intr)
1774 isr_tr_complete_handler(ci);
1775
1776 if (USBi_SLI & intr) {
1777 if (ci->gadget.speed != USB_SPEED_UNKNOWN &&
1778 ci->driver->suspend) {
1779 ci->suspended = 1;
1780 spin_unlock(&ci->lock);
1781 ci->driver->suspend(&ci->gadget);
1782 usb_gadget_set_state(&ci->gadget,
1783 USB_STATE_SUSPENDED);
1784 spin_lock(&ci->lock);
1785 }
1786 }
1787 retval = IRQ_HANDLED;
1788 } else {
1789 retval = IRQ_NONE;
1790 }
1791 spin_unlock(&ci->lock);
1792
1793 return retval;
1794}
1795
1796
1797
1798
1799
1800static int udc_start(struct ci_hdrc *ci)
1801{
1802 struct device *dev = ci->dev;
1803 int retval = 0;
1804
1805 spin_lock_init(&ci->lock);
1806
1807 ci->gadget.ops = &usb_gadget_ops;
1808 ci->gadget.speed = USB_SPEED_UNKNOWN;
1809 ci->gadget.max_speed = USB_SPEED_HIGH;
1810 ci->gadget.is_otg = ci->is_otg ? 1 : 0;
1811 ci->gadget.name = ci->platdata->name;
1812
1813 INIT_LIST_HEAD(&ci->gadget.ep_list);
1814
1815
1816 ci->qh_pool = dma_pool_create("ci_hw_qh", dev,
1817 sizeof(struct ci_hw_qh),
1818 64, CI_HDRC_PAGE_SIZE);
1819 if (ci->qh_pool == NULL)
1820 return -ENOMEM;
1821
1822 ci->td_pool = dma_pool_create("ci_hw_td", dev,
1823 sizeof(struct ci_hw_td),
1824 64, CI_HDRC_PAGE_SIZE);
1825 if (ci->td_pool == NULL) {
1826 retval = -ENOMEM;
1827 goto free_qh_pool;
1828 }
1829
1830 retval = init_eps(ci);
1831 if (retval)
1832 goto free_pools;
1833
1834 ci->gadget.ep0 = &ci->ep0in->ep;
1835
1836 retval = usb_add_gadget_udc(dev, &ci->gadget);
1837 if (retval)
1838 goto destroy_eps;
1839
1840 pm_runtime_no_callbacks(&ci->gadget.dev);
1841 pm_runtime_enable(&ci->gadget.dev);
1842
1843 return retval;
1844
1845destroy_eps:
1846 destroy_eps(ci);
1847free_pools:
1848 dma_pool_destroy(ci->td_pool);
1849free_qh_pool:
1850 dma_pool_destroy(ci->qh_pool);
1851 return retval;
1852}
1853
1854
1855
1856
1857
1858
1859void ci_hdrc_gadget_destroy(struct ci_hdrc *ci)
1860{
1861 if (!ci->roles[CI_ROLE_GADGET])
1862 return;
1863
1864 usb_del_gadget_udc(&ci->gadget);
1865
1866 destroy_eps(ci);
1867
1868 dma_pool_destroy(ci->td_pool);
1869 dma_pool_destroy(ci->qh_pool);
1870}
1871
1872static int udc_id_switch_for_device(struct ci_hdrc *ci)
1873{
1874 if (ci->is_otg)
1875
1876 hw_write_otgsc(ci, OTGSC_BSVIS | OTGSC_BSVIE,
1877 OTGSC_BSVIS | OTGSC_BSVIE);
1878
1879 return 0;
1880}
1881
1882static void udc_id_switch_for_host(struct ci_hdrc *ci)
1883{
1884
1885
1886
1887
1888 if (ci->is_otg)
1889 hw_write_otgsc(ci, OTGSC_BSVIE | OTGSC_BSVIS, OTGSC_BSVIS);
1890}
1891
1892
1893
1894
1895
1896
1897
1898int ci_hdrc_gadget_init(struct ci_hdrc *ci)
1899{
1900 struct ci_role_driver *rdrv;
1901
1902 if (!hw_read(ci, CAP_DCCPARAMS, DCCPARAMS_DC))
1903 return -ENXIO;
1904
1905 rdrv = devm_kzalloc(ci->dev, sizeof(struct ci_role_driver), GFP_KERNEL);
1906 if (!rdrv)
1907 return -ENOMEM;
1908
1909 rdrv->start = udc_id_switch_for_device;
1910 rdrv->stop = udc_id_switch_for_host;
1911 rdrv->irq = udc_irq;
1912 rdrv->name = "gadget";
1913 ci->roles[CI_ROLE_GADGET] = rdrv;
1914
1915 return udc_start(ci);
1916}
1917