1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19#include <linux/kernel.h>
20#include <linux/module.h>
21#include <linux/spinlock.h>
22#include <linux/interrupt.h>
23#include <linux/platform_device.h>
24#include <linux/dma-mapping.h>
25#include <linux/debugfs.h>
26#include <linux/seq_file.h>
27#include <linux/delay.h>
28#include <linux/io.h>
29#include <linux/slab.h>
30#include <linux/clk.h>
31#include <linux/regulator/consumer.h>
32#include <linux/of_platform.h>
33
34#include <linux/usb/ch9.h>
35#include <linux/usb/gadget.h>
36#include <linux/usb/phy.h>
37#include <linux/platform_data/s3c-hsotg.h>
38
39#include <mach/map.h>
40
41#include "s3c-hsotg.h"
42
43static const char * const s3c_hsotg_supply_names[] = {
44 "vusb_d",
45 "vusb_a",
46};
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66#define EP0_MPS_LIMIT 64
67
68struct s3c_hsotg;
69struct s3c_hsotg_req;
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108struct s3c_hsotg_ep {
109 struct usb_ep ep;
110 struct list_head queue;
111 struct s3c_hsotg *parent;
112 struct s3c_hsotg_req *req;
113 struct dentry *debugfs;
114
115
116 unsigned long total_data;
117 unsigned int size_loaded;
118 unsigned int last_load;
119 unsigned int fifo_load;
120 unsigned short fifo_size;
121
122 unsigned char dir_in;
123 unsigned char index;
124
125 unsigned int halted:1;
126 unsigned int periodic:1;
127 unsigned int sent_zlp:1;
128
129 char name[10];
130};
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155struct s3c_hsotg {
156 struct device *dev;
157 struct usb_gadget_driver *driver;
158 struct usb_phy *phy;
159 struct s3c_hsotg_plat *plat;
160
161 spinlock_t lock;
162
163 void __iomem *regs;
164 int irq;
165 struct clk *clk;
166
167 struct regulator_bulk_data supplies[ARRAY_SIZE(s3c_hsotg_supply_names)];
168
169 unsigned int dedicated_fifos:1;
170 unsigned char num_of_eps;
171
172 struct dentry *debug_root;
173 struct dentry *debug_file;
174 struct dentry *debug_fifo;
175
176 struct usb_request *ep0_reply;
177 struct usb_request *ctrl_req;
178 u8 ep0_buff[8];
179 u8 ctrl_buff[8];
180
181 struct usb_gadget gadget;
182 unsigned int setup;
183 unsigned long last_rst;
184 struct s3c_hsotg_ep *eps;
185};
186
187
188
189
190
191
192
193
194struct s3c_hsotg_req {
195 struct usb_request req;
196 struct list_head queue;
197 unsigned char in_progress;
198 unsigned char mapped;
199};
200
201
202static inline struct s3c_hsotg_req *our_req(struct usb_request *req)
203{
204 return container_of(req, struct s3c_hsotg_req, req);
205}
206
207static inline struct s3c_hsotg_ep *our_ep(struct usb_ep *ep)
208{
209 return container_of(ep, struct s3c_hsotg_ep, ep);
210}
211
212static inline struct s3c_hsotg *to_hsotg(struct usb_gadget *gadget)
213{
214 return container_of(gadget, struct s3c_hsotg, gadget);
215}
216
217static inline void __orr32(void __iomem *ptr, u32 val)
218{
219 writel(readl(ptr) | val, ptr);
220}
221
222static inline void __bic32(void __iomem *ptr, u32 val)
223{
224 writel(readl(ptr) & ~val, ptr);
225}
226
227
228static void s3c_hsotg_dump(struct s3c_hsotg *hsotg);
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249static inline bool using_dma(struct s3c_hsotg *hsotg)
250{
251 return false;
252}
253
254
255
256
257
258
259static void s3c_hsotg_en_gsint(struct s3c_hsotg *hsotg, u32 ints)
260{
261 u32 gsintmsk = readl(hsotg->regs + GINTMSK);
262 u32 new_gsintmsk;
263
264 new_gsintmsk = gsintmsk | ints;
265
266 if (new_gsintmsk != gsintmsk) {
267 dev_dbg(hsotg->dev, "gsintmsk now 0x%08x\n", new_gsintmsk);
268 writel(new_gsintmsk, hsotg->regs + GINTMSK);
269 }
270}
271
272
273
274
275
276
277static void s3c_hsotg_disable_gsint(struct s3c_hsotg *hsotg, u32 ints)
278{
279 u32 gsintmsk = readl(hsotg->regs + GINTMSK);
280 u32 new_gsintmsk;
281
282 new_gsintmsk = gsintmsk & ~ints;
283
284 if (new_gsintmsk != gsintmsk)
285 writel(new_gsintmsk, hsotg->regs + GINTMSK);
286}
287
288
289
290
291
292
293
294
295
296
297
298static void s3c_hsotg_ctrl_epint(struct s3c_hsotg *hsotg,
299 unsigned int ep, unsigned int dir_in,
300 unsigned int en)
301{
302 unsigned long flags;
303 u32 bit = 1 << ep;
304 u32 daint;
305
306 if (!dir_in)
307 bit <<= 16;
308
309 local_irq_save(flags);
310 daint = readl(hsotg->regs + DAINTMSK);
311 if (en)
312 daint |= bit;
313 else
314 daint &= ~bit;
315 writel(daint, hsotg->regs + DAINTMSK);
316 local_irq_restore(flags);
317}
318
319
320
321
322
323static void s3c_hsotg_init_fifo(struct s3c_hsotg *hsotg)
324{
325 unsigned int ep;
326 unsigned int addr;
327 unsigned int size;
328 int timeout;
329 u32 val;
330
331
332
333 writel(2048, hsotg->regs + GRXFSIZ);
334 writel(GNPTXFSIZ_NPTxFStAddr(2048) |
335 GNPTXFSIZ_NPTxFDep(1024),
336 hsotg->regs + GNPTXFSIZ);
337
338
339
340
341
342
343
344
345
346 addr = 2048 + 1024;
347 size = 768;
348
349
350
351
352
353
354 for (ep = 1; ep <= 15; ep++) {
355 val = addr;
356 val |= size << DPTXFSIZn_DPTxFSize_SHIFT;
357 addr += size;
358
359 writel(val, hsotg->regs + DPTXFSIZn(ep));
360 }
361
362
363
364
365
366
367 writel(GRSTCTL_TxFNum(0x10) | GRSTCTL_TxFFlsh |
368 GRSTCTL_RxFFlsh, hsotg->regs + GRSTCTL);
369
370
371 timeout = 100;
372 while (1) {
373 val = readl(hsotg->regs + GRSTCTL);
374
375 if ((val & (GRSTCTL_TxFFlsh | GRSTCTL_RxFFlsh)) == 0)
376 break;
377
378 if (--timeout == 0) {
379 dev_err(hsotg->dev,
380 "%s: timeout flushing fifos (GRSTCTL=%08x)\n",
381 __func__, val);
382 }
383
384 udelay(1);
385 }
386
387 dev_dbg(hsotg->dev, "FIFOs reset, timeout at %d\n", timeout);
388}
389
390
391
392
393
394
395
396static struct usb_request *s3c_hsotg_ep_alloc_request(struct usb_ep *ep,
397 gfp_t flags)
398{
399 struct s3c_hsotg_req *req;
400
401 req = kzalloc(sizeof(struct s3c_hsotg_req), flags);
402 if (!req)
403 return NULL;
404
405 INIT_LIST_HEAD(&req->queue);
406
407 return &req->req;
408}
409
410
411
412
413
414
415
416
417static inline int is_ep_periodic(struct s3c_hsotg_ep *hs_ep)
418{
419 return hs_ep->periodic;
420}
421
422
423
424
425
426
427
428
429
430
431static void s3c_hsotg_unmap_dma(struct s3c_hsotg *hsotg,
432 struct s3c_hsotg_ep *hs_ep,
433 struct s3c_hsotg_req *hs_req)
434{
435 struct usb_request *req = &hs_req->req;
436
437
438 if (hs_req->req.length == 0)
439 return;
440
441 usb_gadget_unmap_request(&hsotg->gadget, req, hs_ep->dir_in);
442}
443
444
445
446
447
448
449
450
451
452
453
454
455
456
457
458
459
460static int s3c_hsotg_write_fifo(struct s3c_hsotg *hsotg,
461 struct s3c_hsotg_ep *hs_ep,
462 struct s3c_hsotg_req *hs_req)
463{
464 bool periodic = is_ep_periodic(hs_ep);
465 u32 gnptxsts = readl(hsotg->regs + GNPTXSTS);
466 int buf_pos = hs_req->req.actual;
467 int to_write = hs_ep->size_loaded;
468 void *data;
469 int can_write;
470 int pkt_round;
471
472 to_write -= (buf_pos - hs_ep->last_load);
473
474
475 if (to_write == 0)
476 return 0;
477
478 if (periodic && !hsotg->dedicated_fifos) {
479 u32 epsize = readl(hsotg->regs + DIEPTSIZ(hs_ep->index));
480 int size_left;
481 int size_done;
482
483
484
485
486
487
488 size_left = DxEPTSIZ_XferSize_GET(epsize);
489
490
491
492
493
494 if (hs_ep->fifo_load != 0) {
495 s3c_hsotg_en_gsint(hsotg, GINTSTS_PTxFEmp);
496 return -ENOSPC;
497 }
498
499 dev_dbg(hsotg->dev, "%s: left=%d, load=%d, fifo=%d, size %d\n",
500 __func__, size_left,
501 hs_ep->size_loaded, hs_ep->fifo_load, hs_ep->fifo_size);
502
503
504 size_done = hs_ep->size_loaded - size_left;
505
506
507 can_write = hs_ep->fifo_load - size_done;
508 dev_dbg(hsotg->dev, "%s: => can_write1=%d\n",
509 __func__, can_write);
510
511 can_write = hs_ep->fifo_size - can_write;
512 dev_dbg(hsotg->dev, "%s: => can_write2=%d\n",
513 __func__, can_write);
514
515 if (can_write <= 0) {
516 s3c_hsotg_en_gsint(hsotg, GINTSTS_PTxFEmp);
517 return -ENOSPC;
518 }
519 } else if (hsotg->dedicated_fifos && hs_ep->index != 0) {
520 can_write = readl(hsotg->regs + DTXFSTS(hs_ep->index));
521
522 can_write &= 0xffff;
523 can_write *= 4;
524 } else {
525 if (GNPTXSTS_NPTxQSpcAvail_GET(gnptxsts) == 0) {
526 dev_dbg(hsotg->dev,
527 "%s: no queue slots available (0x%08x)\n",
528 __func__, gnptxsts);
529
530 s3c_hsotg_en_gsint(hsotg, GINTSTS_NPTxFEmp);
531 return -ENOSPC;
532 }
533
534 can_write = GNPTXSTS_NPTxFSpcAvail_GET(gnptxsts);
535 can_write *= 4;
536 }
537
538 dev_dbg(hsotg->dev, "%s: GNPTXSTS=%08x, can=%d, to=%d, mps %d\n",
539 __func__, gnptxsts, can_write, to_write, hs_ep->ep.maxpacket);
540
541
542
543
544
545
546 if (can_write > 512 && !periodic)
547 can_write = 512;
548
549
550
551
552
553
554 if (to_write > hs_ep->ep.maxpacket) {
555 to_write = hs_ep->ep.maxpacket;
556
557 s3c_hsotg_en_gsint(hsotg,
558 periodic ? GINTSTS_PTxFEmp :
559 GINTSTS_NPTxFEmp);
560 }
561
562
563
564 if (to_write > can_write) {
565 to_write = can_write;
566 pkt_round = to_write % hs_ep->ep.maxpacket;
567
568
569
570
571
572
573
574
575
576 if (pkt_round)
577 to_write -= pkt_round;
578
579
580
581
582
583
584 s3c_hsotg_en_gsint(hsotg,
585 periodic ? GINTSTS_PTxFEmp :
586 GINTSTS_NPTxFEmp);
587 }
588
589 dev_dbg(hsotg->dev, "write %d/%d, can_write %d, done %d\n",
590 to_write, hs_req->req.length, can_write, buf_pos);
591
592 if (to_write <= 0)
593 return -ENOSPC;
594
595 hs_req->req.actual = buf_pos + to_write;
596 hs_ep->total_data += to_write;
597
598 if (periodic)
599 hs_ep->fifo_load += to_write;
600
601 to_write = DIV_ROUND_UP(to_write, 4);
602 data = hs_req->req.buf + buf_pos;
603
604 writesl(hsotg->regs + EPFIFO(hs_ep->index), data, to_write);
605
606 return (to_write >= can_write) ? -ENOSPC : 0;
607}
608
609
610
611
612
613
614
615
616static unsigned get_ep_limit(struct s3c_hsotg_ep *hs_ep)
617{
618 int index = hs_ep->index;
619 unsigned maxsize;
620 unsigned maxpkt;
621
622 if (index != 0) {
623 maxsize = DxEPTSIZ_XferSize_LIMIT + 1;
624 maxpkt = DxEPTSIZ_PktCnt_LIMIT + 1;
625 } else {
626 maxsize = 64+64;
627 if (hs_ep->dir_in)
628 maxpkt = DIEPTSIZ0_PktCnt_LIMIT + 1;
629 else
630 maxpkt = 2;
631 }
632
633
634 maxpkt--;
635 maxsize--;
636
637
638
639
640
641
642 if ((maxpkt * hs_ep->ep.maxpacket) < maxsize)
643 maxsize = maxpkt * hs_ep->ep.maxpacket;
644
645 return maxsize;
646}
647
648
649
650
651
652
653
654
655
656
657
658static void s3c_hsotg_start_req(struct s3c_hsotg *hsotg,
659 struct s3c_hsotg_ep *hs_ep,
660 struct s3c_hsotg_req *hs_req,
661 bool continuing)
662{
663 struct usb_request *ureq = &hs_req->req;
664 int index = hs_ep->index;
665 int dir_in = hs_ep->dir_in;
666 u32 epctrl_reg;
667 u32 epsize_reg;
668 u32 epsize;
669 u32 ctrl;
670 unsigned length;
671 unsigned packets;
672 unsigned maxreq;
673
674 if (index != 0) {
675 if (hs_ep->req && !continuing) {
676 dev_err(hsotg->dev, "%s: active request\n", __func__);
677 WARN_ON(1);
678 return;
679 } else if (hs_ep->req != hs_req && continuing) {
680 dev_err(hsotg->dev,
681 "%s: continue different req\n", __func__);
682 WARN_ON(1);
683 return;
684 }
685 }
686
687 epctrl_reg = dir_in ? DIEPCTL(index) : DOEPCTL(index);
688 epsize_reg = dir_in ? DIEPTSIZ(index) : DOEPTSIZ(index);
689
690 dev_dbg(hsotg->dev, "%s: DxEPCTL=0x%08x, ep %d, dir %s\n",
691 __func__, readl(hsotg->regs + epctrl_reg), index,
692 hs_ep->dir_in ? "in" : "out");
693
694
695 ctrl = readl(hsotg->regs + epctrl_reg);
696
697 if (ctrl & DxEPCTL_Stall) {
698 dev_warn(hsotg->dev, "%s: ep%d is stalled\n", __func__, index);
699 return;
700 }
701
702 length = ureq->length - ureq->actual;
703 dev_dbg(hsotg->dev, "ureq->length:%d ureq->actual:%d\n",
704 ureq->length, ureq->actual);
705 if (0)
706 dev_dbg(hsotg->dev,
707 "REQ buf %p len %d dma 0x%08x noi=%d zp=%d snok=%d\n",
708 ureq->buf, length, ureq->dma,
709 ureq->no_interrupt, ureq->zero, ureq->short_not_ok);
710
711 maxreq = get_ep_limit(hs_ep);
712 if (length > maxreq) {
713 int round = maxreq % hs_ep->ep.maxpacket;
714
715 dev_dbg(hsotg->dev, "%s: length %d, max-req %d, r %d\n",
716 __func__, length, maxreq, round);
717
718
719 if (round)
720 maxreq -= round;
721
722 length = maxreq;
723 }
724
725 if (length)
726 packets = DIV_ROUND_UP(length, hs_ep->ep.maxpacket);
727 else
728 packets = 1;
729
730 if (dir_in && index != 0)
731 epsize = DxEPTSIZ_MC(1);
732 else
733 epsize = 0;
734
735 if (index != 0 && ureq->zero) {
736
737
738
739
740
741 if (length == (packets * hs_ep->ep.maxpacket))
742 packets++;
743 }
744
745 epsize |= DxEPTSIZ_PktCnt(packets);
746 epsize |= DxEPTSIZ_XferSize(length);
747
748 dev_dbg(hsotg->dev, "%s: %d@%d/%d, 0x%08x => 0x%08x\n",
749 __func__, packets, length, ureq->length, epsize, epsize_reg);
750
751
752 hs_ep->req = hs_req;
753
754
755 writel(epsize, hsotg->regs + epsize_reg);
756
757 if (using_dma(hsotg) && !continuing) {
758 unsigned int dma_reg;
759
760
761
762
763
764
765 dma_reg = dir_in ? DIEPDMA(index) : DOEPDMA(index);
766 writel(ureq->dma, hsotg->regs + dma_reg);
767
768 dev_dbg(hsotg->dev, "%s: 0x%08x => 0x%08x\n",
769 __func__, ureq->dma, dma_reg);
770 }
771
772 ctrl |= DxEPCTL_EPEna;
773 ctrl |= DxEPCTL_USBActEp;
774
775 dev_dbg(hsotg->dev, "setup req:%d\n", hsotg->setup);
776
777
778 if (hsotg->setup && index == 0)
779 hsotg->setup = 0;
780 else
781 ctrl |= DxEPCTL_CNAK;
782
783
784 dev_dbg(hsotg->dev, "%s: DxEPCTL=0x%08x\n", __func__, ctrl);
785 writel(ctrl, hsotg->regs + epctrl_reg);
786
787
788
789
790
791
792 hs_ep->size_loaded = length;
793 hs_ep->last_load = ureq->actual;
794
795 if (dir_in && !using_dma(hsotg)) {
796
797 hs_ep->fifo_load = 0;
798
799 s3c_hsotg_write_fifo(hsotg, hs_ep, hs_req);
800 }
801
802
803
804
805
806 if (dir_in)
807 writel(DIEPMSK_INTknTXFEmpMsk,
808 hsotg->regs + DIEPINT(index));
809
810
811
812
813
814
815
816 if (!(readl(hsotg->regs + epctrl_reg) & DxEPCTL_EPEna))
817 dev_warn(hsotg->dev,
818 "ep%d: failed to become enabled (DxEPCTL=0x%08x)?\n",
819 index, readl(hsotg->regs + epctrl_reg));
820
821 dev_dbg(hsotg->dev, "%s: DxEPCTL=0x%08x\n",
822 __func__, readl(hsotg->regs + epctrl_reg));
823}
824
825
826
827
828
829
830
831
832
833
834
835
836
837static int s3c_hsotg_map_dma(struct s3c_hsotg *hsotg,
838 struct s3c_hsotg_ep *hs_ep,
839 struct usb_request *req)
840{
841 struct s3c_hsotg_req *hs_req = our_req(req);
842 int ret;
843
844
845 if (hs_req->req.length == 0)
846 return 0;
847
848 ret = usb_gadget_map_request(&hsotg->gadget, req, hs_ep->dir_in);
849 if (ret)
850 goto dma_error;
851
852 return 0;
853
854dma_error:
855 dev_err(hsotg->dev, "%s: failed to map buffer %p, %d bytes\n",
856 __func__, req->buf, req->length);
857
858 return -EIO;
859}
860
861static int s3c_hsotg_ep_queue(struct usb_ep *ep, struct usb_request *req,
862 gfp_t gfp_flags)
863{
864 struct s3c_hsotg_req *hs_req = our_req(req);
865 struct s3c_hsotg_ep *hs_ep = our_ep(ep);
866 struct s3c_hsotg *hs = hs_ep->parent;
867 bool first;
868
869 dev_dbg(hs->dev, "%s: req %p: %d@%p, noi=%d, zero=%d, snok=%d\n",
870 ep->name, req, req->length, req->buf, req->no_interrupt,
871 req->zero, req->short_not_ok);
872
873
874 INIT_LIST_HEAD(&hs_req->queue);
875 req->actual = 0;
876 req->status = -EINPROGRESS;
877
878
879 if (using_dma(hs)) {
880 int ret = s3c_hsotg_map_dma(hs, hs_ep, req);
881 if (ret)
882 return ret;
883 }
884
885 first = list_empty(&hs_ep->queue);
886 list_add_tail(&hs_req->queue, &hs_ep->queue);
887
888 if (first)
889 s3c_hsotg_start_req(hs, hs_ep, hs_req, false);
890
891 return 0;
892}
893
894static int s3c_hsotg_ep_queue_lock(struct usb_ep *ep, struct usb_request *req,
895 gfp_t gfp_flags)
896{
897 struct s3c_hsotg_ep *hs_ep = our_ep(ep);
898 struct s3c_hsotg *hs = hs_ep->parent;
899 unsigned long flags = 0;
900 int ret = 0;
901
902 spin_lock_irqsave(&hs->lock, flags);
903 ret = s3c_hsotg_ep_queue(ep, req, gfp_flags);
904 spin_unlock_irqrestore(&hs->lock, flags);
905
906 return ret;
907}
908
909static void s3c_hsotg_ep_free_request(struct usb_ep *ep,
910 struct usb_request *req)
911{
912 struct s3c_hsotg_req *hs_req = our_req(req);
913
914 kfree(hs_req);
915}
916
917
918
919
920
921
922
923
924
925static void s3c_hsotg_complete_oursetup(struct usb_ep *ep,
926 struct usb_request *req)
927{
928 struct s3c_hsotg_ep *hs_ep = our_ep(ep);
929 struct s3c_hsotg *hsotg = hs_ep->parent;
930
931 dev_dbg(hsotg->dev, "%s: ep %p, req %p\n", __func__, ep, req);
932
933 s3c_hsotg_ep_free_request(ep, req);
934}
935
936
937
938
939
940
941
942
943
944static struct s3c_hsotg_ep *ep_from_windex(struct s3c_hsotg *hsotg,
945 u32 windex)
946{
947 struct s3c_hsotg_ep *ep = &hsotg->eps[windex & 0x7F];
948 int dir = (windex & USB_DIR_IN) ? 1 : 0;
949 int idx = windex & 0x7F;
950
951 if (windex >= 0x100)
952 return NULL;
953
954 if (idx > hsotg->num_of_eps)
955 return NULL;
956
957 if (idx && ep->dir_in != dir)
958 return NULL;
959
960 return ep;
961}
962
963
964
965
966
967
968
969
970
971
972
973static int s3c_hsotg_send_reply(struct s3c_hsotg *hsotg,
974 struct s3c_hsotg_ep *ep,
975 void *buff,
976 int length)
977{
978 struct usb_request *req;
979 int ret;
980
981 dev_dbg(hsotg->dev, "%s: buff %p, len %d\n", __func__, buff, length);
982
983 req = s3c_hsotg_ep_alloc_request(&ep->ep, GFP_ATOMIC);
984 hsotg->ep0_reply = req;
985 if (!req) {
986 dev_warn(hsotg->dev, "%s: cannot alloc req\n", __func__);
987 return -ENOMEM;
988 }
989
990 req->buf = hsotg->ep0_buff;
991 req->length = length;
992 req->zero = 1;
993 req->complete = s3c_hsotg_complete_oursetup;
994
995 if (length)
996 memcpy(req->buf, buff, length);
997 else
998 ep->sent_zlp = 1;
999
1000 ret = s3c_hsotg_ep_queue(&ep->ep, req, GFP_ATOMIC);
1001 if (ret) {
1002 dev_warn(hsotg->dev, "%s: cannot queue req\n", __func__);
1003 return ret;
1004 }
1005
1006 return 0;
1007}
1008
1009
1010
1011
1012
1013
1014static int s3c_hsotg_process_req_status(struct s3c_hsotg *hsotg,
1015 struct usb_ctrlrequest *ctrl)
1016{
1017 struct s3c_hsotg_ep *ep0 = &hsotg->eps[0];
1018 struct s3c_hsotg_ep *ep;
1019 __le16 reply;
1020 int ret;
1021
1022 dev_dbg(hsotg->dev, "%s: USB_REQ_GET_STATUS\n", __func__);
1023
1024 if (!ep0->dir_in) {
1025 dev_warn(hsotg->dev, "%s: direction out?\n", __func__);
1026 return -EINVAL;
1027 }
1028
1029 switch (ctrl->bRequestType & USB_RECIP_MASK) {
1030 case USB_RECIP_DEVICE:
1031 reply = cpu_to_le16(0);
1032
1033 break;
1034
1035 case USB_RECIP_INTERFACE:
1036
1037 reply = cpu_to_le16(0);
1038 break;
1039
1040 case USB_RECIP_ENDPOINT:
1041 ep = ep_from_windex(hsotg, le16_to_cpu(ctrl->wIndex));
1042 if (!ep)
1043 return -ENOENT;
1044
1045 reply = cpu_to_le16(ep->halted ? 1 : 0);
1046 break;
1047
1048 default:
1049 return 0;
1050 }
1051
1052 if (le16_to_cpu(ctrl->wLength) != 2)
1053 return -EINVAL;
1054
1055 ret = s3c_hsotg_send_reply(hsotg, ep0, &reply, 2);
1056 if (ret) {
1057 dev_err(hsotg->dev, "%s: failed to send reply\n", __func__);
1058 return ret;
1059 }
1060
1061 return 1;
1062}
1063
1064static int s3c_hsotg_ep_sethalt(struct usb_ep *ep, int value);
1065
1066
1067
1068
1069
1070
1071
1072static struct s3c_hsotg_req *get_ep_head(struct s3c_hsotg_ep *hs_ep)
1073{
1074 if (list_empty(&hs_ep->queue))
1075 return NULL;
1076
1077 return list_first_entry(&hs_ep->queue, struct s3c_hsotg_req, queue);
1078}
1079
1080
1081
1082
1083
1084
1085static int s3c_hsotg_process_req_feature(struct s3c_hsotg *hsotg,
1086 struct usb_ctrlrequest *ctrl)
1087{
1088 struct s3c_hsotg_ep *ep0 = &hsotg->eps[0];
1089 struct s3c_hsotg_req *hs_req;
1090 bool restart;
1091 bool set = (ctrl->bRequest == USB_REQ_SET_FEATURE);
1092 struct s3c_hsotg_ep *ep;
1093 int ret;
1094
1095 dev_dbg(hsotg->dev, "%s: %s_FEATURE\n",
1096 __func__, set ? "SET" : "CLEAR");
1097
1098 if (ctrl->bRequestType == USB_RECIP_ENDPOINT) {
1099 ep = ep_from_windex(hsotg, le16_to_cpu(ctrl->wIndex));
1100 if (!ep) {
1101 dev_dbg(hsotg->dev, "%s: no endpoint for 0x%04x\n",
1102 __func__, le16_to_cpu(ctrl->wIndex));
1103 return -ENOENT;
1104 }
1105
1106 switch (le16_to_cpu(ctrl->wValue)) {
1107 case USB_ENDPOINT_HALT:
1108 s3c_hsotg_ep_sethalt(&ep->ep, set);
1109
1110 ret = s3c_hsotg_send_reply(hsotg, ep0, NULL, 0);
1111 if (ret) {
1112 dev_err(hsotg->dev,
1113 "%s: failed to send reply\n", __func__);
1114 return ret;
1115 }
1116
1117 if (!set) {
1118
1119
1120
1121
1122 if (ep->req) {
1123 hs_req = ep->req;
1124 ep->req = NULL;
1125 list_del_init(&hs_req->queue);
1126 hs_req->req.complete(&ep->ep,
1127 &hs_req->req);
1128 }
1129
1130
1131 restart = !list_empty(&ep->queue);
1132 if (restart) {
1133 hs_req = get_ep_head(ep);
1134 s3c_hsotg_start_req(hsotg, ep,
1135 hs_req, false);
1136 }
1137 }
1138
1139 break;
1140
1141 default:
1142 return -ENOENT;
1143 }
1144 } else
1145 return -ENOENT;
1146
1147 return 1;
1148}
1149
1150
1151
1152
1153
1154
1155
1156
1157
1158
1159static void s3c_hsotg_process_control(struct s3c_hsotg *hsotg,
1160 struct usb_ctrlrequest *ctrl)
1161{
1162 struct s3c_hsotg_ep *ep0 = &hsotg->eps[0];
1163 int ret = 0;
1164 u32 dcfg;
1165
1166 ep0->sent_zlp = 0;
1167
1168 dev_dbg(hsotg->dev, "ctrl Req=%02x, Type=%02x, V=%04x, L=%04x\n",
1169 ctrl->bRequest, ctrl->bRequestType,
1170 ctrl->wValue, ctrl->wLength);
1171
1172
1173
1174
1175
1176
1177 ep0->dir_in = (ctrl->bRequestType & USB_DIR_IN) ? 1 : 0;
1178 dev_dbg(hsotg->dev, "ctrl: dir_in=%d\n", ep0->dir_in);
1179
1180
1181
1182
1183
1184 if (ctrl->wLength == 0)
1185 ep0->dir_in = 1;
1186
1187 if ((ctrl->bRequestType & USB_TYPE_MASK) == USB_TYPE_STANDARD) {
1188 switch (ctrl->bRequest) {
1189 case USB_REQ_SET_ADDRESS:
1190 dcfg = readl(hsotg->regs + DCFG);
1191 dcfg &= ~DCFG_DevAddr_MASK;
1192 dcfg |= ctrl->wValue << DCFG_DevAddr_SHIFT;
1193 writel(dcfg, hsotg->regs + DCFG);
1194
1195 dev_info(hsotg->dev, "new address %d\n", ctrl->wValue);
1196
1197 ret = s3c_hsotg_send_reply(hsotg, ep0, NULL, 0);
1198 return;
1199
1200 case USB_REQ_GET_STATUS:
1201 ret = s3c_hsotg_process_req_status(hsotg, ctrl);
1202 break;
1203
1204 case USB_REQ_CLEAR_FEATURE:
1205 case USB_REQ_SET_FEATURE:
1206 ret = s3c_hsotg_process_req_feature(hsotg, ctrl);
1207 break;
1208 }
1209 }
1210
1211
1212
1213 if (ret == 0 && hsotg->driver) {
1214 ret = hsotg->driver->setup(&hsotg->gadget, ctrl);
1215 if (ret < 0)
1216 dev_dbg(hsotg->dev, "driver->setup() ret %d\n", ret);
1217 }
1218
1219
1220
1221
1222
1223
1224 if (ret < 0) {
1225 u32 reg;
1226 u32 ctrl;
1227
1228 dev_dbg(hsotg->dev, "ep0 stall (dir=%d)\n", ep0->dir_in);
1229 reg = (ep0->dir_in) ? DIEPCTL0 : DOEPCTL0;
1230
1231
1232
1233
1234
1235
1236 ctrl = readl(hsotg->regs + reg);
1237 ctrl |= DxEPCTL_Stall;
1238 ctrl |= DxEPCTL_CNAK;
1239 writel(ctrl, hsotg->regs + reg);
1240
1241 dev_dbg(hsotg->dev,
1242 "written DxEPCTL=0x%08x to %08x (DxEPCTL=0x%08x)\n",
1243 ctrl, reg, readl(hsotg->regs + reg));
1244
1245
1246
1247
1248
1249 }
1250}
1251
1252static void s3c_hsotg_enqueue_setup(struct s3c_hsotg *hsotg);
1253
1254
1255
1256
1257
1258
1259
1260
1261
1262static void s3c_hsotg_complete_setup(struct usb_ep *ep,
1263 struct usb_request *req)
1264{
1265 struct s3c_hsotg_ep *hs_ep = our_ep(ep);
1266 struct s3c_hsotg *hsotg = hs_ep->parent;
1267
1268 if (req->status < 0) {
1269 dev_dbg(hsotg->dev, "%s: failed %d\n", __func__, req->status);
1270 return;
1271 }
1272
1273 if (req->actual == 0)
1274 s3c_hsotg_enqueue_setup(hsotg);
1275 else
1276 s3c_hsotg_process_control(hsotg, req->buf);
1277}
1278
1279
1280
1281
1282
1283
1284
1285
1286static void s3c_hsotg_enqueue_setup(struct s3c_hsotg *hsotg)
1287{
1288 struct usb_request *req = hsotg->ctrl_req;
1289 struct s3c_hsotg_req *hs_req = our_req(req);
1290 int ret;
1291
1292 dev_dbg(hsotg->dev, "%s: queueing setup request\n", __func__);
1293
1294 req->zero = 0;
1295 req->length = 8;
1296 req->buf = hsotg->ctrl_buff;
1297 req->complete = s3c_hsotg_complete_setup;
1298
1299 if (!list_empty(&hs_req->queue)) {
1300 dev_dbg(hsotg->dev, "%s already queued???\n", __func__);
1301 return;
1302 }
1303
1304 hsotg->eps[0].dir_in = 0;
1305
1306 ret = s3c_hsotg_ep_queue(&hsotg->eps[0].ep, req, GFP_ATOMIC);
1307 if (ret < 0) {
1308 dev_err(hsotg->dev, "%s: failed queue (%d)\n", __func__, ret);
1309
1310
1311
1312
1313 }
1314}
1315
1316
1317
1318
1319
1320
1321
1322
1323
1324
1325
1326
1327
1328
1329static void s3c_hsotg_complete_request(struct s3c_hsotg *hsotg,
1330 struct s3c_hsotg_ep *hs_ep,
1331 struct s3c_hsotg_req *hs_req,
1332 int result)
1333{
1334 bool restart;
1335
1336 if (!hs_req) {
1337 dev_dbg(hsotg->dev, "%s: nothing to complete?\n", __func__);
1338 return;
1339 }
1340
1341 dev_dbg(hsotg->dev, "complete: ep %p %s, req %p, %d => %p\n",
1342 hs_ep, hs_ep->ep.name, hs_req, result, hs_req->req.complete);
1343
1344
1345
1346
1347
1348
1349 if (hs_req->req.status == -EINPROGRESS)
1350 hs_req->req.status = result;
1351
1352 hs_ep->req = NULL;
1353 list_del_init(&hs_req->queue);
1354
1355 if (using_dma(hsotg))
1356 s3c_hsotg_unmap_dma(hsotg, hs_ep, hs_req);
1357
1358
1359
1360
1361
1362
1363 if (hs_req->req.complete) {
1364 spin_unlock(&hsotg->lock);
1365 hs_req->req.complete(&hs_ep->ep, &hs_req->req);
1366 spin_lock(&hsotg->lock);
1367 }
1368
1369
1370
1371
1372
1373
1374
1375 if (!hs_ep->req && result >= 0) {
1376 restart = !list_empty(&hs_ep->queue);
1377 if (restart) {
1378 hs_req = get_ep_head(hs_ep);
1379 s3c_hsotg_start_req(hsotg, hs_ep, hs_req, false);
1380 }
1381 }
1382}
1383
1384
1385
1386
1387
1388
1389
1390
1391
1392
1393
1394static void s3c_hsotg_rx_data(struct s3c_hsotg *hsotg, int ep_idx, int size)
1395{
1396 struct s3c_hsotg_ep *hs_ep = &hsotg->eps[ep_idx];
1397 struct s3c_hsotg_req *hs_req = hs_ep->req;
1398 void __iomem *fifo = hsotg->regs + EPFIFO(ep_idx);
1399 int to_read;
1400 int max_req;
1401 int read_ptr;
1402
1403
1404 if (!hs_req) {
1405 u32 epctl = readl(hsotg->regs + DOEPCTL(ep_idx));
1406 int ptr;
1407
1408 dev_warn(hsotg->dev,
1409 "%s: FIFO %d bytes on ep%d but no req (DxEPCTl=0x%08x)\n",
1410 __func__, size, ep_idx, epctl);
1411
1412
1413 for (ptr = 0; ptr < size; ptr += 4)
1414 (void)readl(fifo);
1415
1416 return;
1417 }
1418
1419 to_read = size;
1420 read_ptr = hs_req->req.actual;
1421 max_req = hs_req->req.length - read_ptr;
1422
1423 dev_dbg(hsotg->dev, "%s: read %d/%d, done %d/%d\n",
1424 __func__, to_read, max_req, read_ptr, hs_req->req.length);
1425
1426 if (to_read > max_req) {
1427
1428
1429
1430
1431
1432
1433 WARN_ON_ONCE(1);
1434 }
1435
1436 hs_ep->total_data += to_read;
1437 hs_req->req.actual += to_read;
1438 to_read = DIV_ROUND_UP(to_read, 4);
1439
1440
1441
1442
1443
1444 readsl(fifo, hs_req->req.buf + read_ptr, to_read);
1445}
1446
1447
1448
1449
1450
1451
1452
1453
1454
1455
1456
1457
1458
1459static void s3c_hsotg_send_zlp(struct s3c_hsotg *hsotg,
1460 struct s3c_hsotg_req *req)
1461{
1462 u32 ctrl;
1463
1464 if (!req) {
1465 dev_warn(hsotg->dev, "%s: no request?\n", __func__);
1466 return;
1467 }
1468
1469 if (req->req.length == 0) {
1470 hsotg->eps[0].sent_zlp = 1;
1471 s3c_hsotg_enqueue_setup(hsotg);
1472 return;
1473 }
1474
1475 hsotg->eps[0].dir_in = 1;
1476 hsotg->eps[0].sent_zlp = 1;
1477
1478 dev_dbg(hsotg->dev, "sending zero-length packet\n");
1479
1480
1481 writel(DxEPTSIZ_MC(1) | DxEPTSIZ_PktCnt(1) |
1482 DxEPTSIZ_XferSize(0), hsotg->regs + DIEPTSIZ(0));
1483
1484 ctrl = readl(hsotg->regs + DIEPCTL0);
1485 ctrl |= DxEPCTL_CNAK;
1486 ctrl |= DxEPCTL_EPEna;
1487 ctrl |= DxEPCTL_USBActEp;
1488 writel(ctrl, hsotg->regs + DIEPCTL0);
1489}
1490
1491
1492
1493
1494
1495
1496
1497
1498
1499
1500
1501static void s3c_hsotg_handle_outdone(struct s3c_hsotg *hsotg,
1502 int epnum, bool was_setup)
1503{
1504 u32 epsize = readl(hsotg->regs + DOEPTSIZ(epnum));
1505 struct s3c_hsotg_ep *hs_ep = &hsotg->eps[epnum];
1506 struct s3c_hsotg_req *hs_req = hs_ep->req;
1507 struct usb_request *req = &hs_req->req;
1508 unsigned size_left = DxEPTSIZ_XferSize_GET(epsize);
1509 int result = 0;
1510
1511 if (!hs_req) {
1512 dev_dbg(hsotg->dev, "%s: no request active\n", __func__);
1513 return;
1514 }
1515
1516 if (using_dma(hsotg)) {
1517 unsigned size_done;
1518
1519
1520
1521
1522
1523
1524
1525
1526
1527
1528 size_done = hs_ep->size_loaded - size_left;
1529 size_done += hs_ep->last_load;
1530
1531 req->actual = size_done;
1532 }
1533
1534
1535 if (req->actual < req->length && size_left == 0) {
1536 s3c_hsotg_start_req(hsotg, hs_ep, hs_req, true);
1537 return;
1538 } else if (epnum == 0) {
1539
1540
1541
1542
1543 hsotg->setup = was_setup ? 0 : 1;
1544 }
1545
1546 if (req->actual < req->length && req->short_not_ok) {
1547 dev_dbg(hsotg->dev, "%s: got %d/%d (short not ok) => error\n",
1548 __func__, req->actual, req->length);
1549
1550
1551
1552
1553
1554 }
1555
1556 if (epnum == 0) {
1557
1558
1559
1560
1561 if (!was_setup && req->complete != s3c_hsotg_complete_setup)
1562 s3c_hsotg_send_zlp(hsotg, hs_req);
1563 }
1564
1565 s3c_hsotg_complete_request(hsotg, hs_ep, hs_req, result);
1566}
1567
1568
1569
1570
1571
1572
1573
1574static u32 s3c_hsotg_read_frameno(struct s3c_hsotg *hsotg)
1575{
1576 u32 dsts;
1577
1578 dsts = readl(hsotg->regs + DSTS);
1579 dsts &= DSTS_SOFFN_MASK;
1580 dsts >>= DSTS_SOFFN_SHIFT;
1581
1582 return dsts;
1583}
1584
1585
1586
1587
1588
1589
1590
1591
1592
1593
1594
1595
1596
1597
1598
1599
1600
1601static void s3c_hsotg_handle_rx(struct s3c_hsotg *hsotg)
1602{
1603 u32 grxstsr = readl(hsotg->regs + GRXSTSP);
1604 u32 epnum, status, size;
1605
1606 WARN_ON(using_dma(hsotg));
1607
1608 epnum = grxstsr & GRXSTS_EPNum_MASK;
1609 status = grxstsr & GRXSTS_PktSts_MASK;
1610
1611 size = grxstsr & GRXSTS_ByteCnt_MASK;
1612 size >>= GRXSTS_ByteCnt_SHIFT;
1613
1614 if (1)
1615 dev_dbg(hsotg->dev, "%s: GRXSTSP=0x%08x (%d@%d)\n",
1616 __func__, grxstsr, size, epnum);
1617
1618#define __status(x) ((x) >> GRXSTS_PktSts_SHIFT)
1619
1620 switch (status >> GRXSTS_PktSts_SHIFT) {
1621 case __status(GRXSTS_PktSts_GlobalOutNAK):
1622 dev_dbg(hsotg->dev, "GlobalOutNAK\n");
1623 break;
1624
1625 case __status(GRXSTS_PktSts_OutDone):
1626 dev_dbg(hsotg->dev, "OutDone (Frame=0x%08x)\n",
1627 s3c_hsotg_read_frameno(hsotg));
1628
1629 if (!using_dma(hsotg))
1630 s3c_hsotg_handle_outdone(hsotg, epnum, false);
1631 break;
1632
1633 case __status(GRXSTS_PktSts_SetupDone):
1634 dev_dbg(hsotg->dev,
1635 "SetupDone (Frame=0x%08x, DOPEPCTL=0x%08x)\n",
1636 s3c_hsotg_read_frameno(hsotg),
1637 readl(hsotg->regs + DOEPCTL(0)));
1638
1639 s3c_hsotg_handle_outdone(hsotg, epnum, true);
1640 break;
1641
1642 case __status(GRXSTS_PktSts_OutRX):
1643 s3c_hsotg_rx_data(hsotg, epnum, size);
1644 break;
1645
1646 case __status(GRXSTS_PktSts_SetupRX):
1647 dev_dbg(hsotg->dev,
1648 "SetupRX (Frame=0x%08x, DOPEPCTL=0x%08x)\n",
1649 s3c_hsotg_read_frameno(hsotg),
1650 readl(hsotg->regs + DOEPCTL(0)));
1651
1652 s3c_hsotg_rx_data(hsotg, epnum, size);
1653 break;
1654
1655 default:
1656 dev_warn(hsotg->dev, "%s: unknown status %08x\n",
1657 __func__, grxstsr);
1658
1659 s3c_hsotg_dump(hsotg);
1660 break;
1661 }
1662}
1663
1664
1665
1666
1667
1668static u32 s3c_hsotg_ep0_mps(unsigned int mps)
1669{
1670 switch (mps) {
1671 case 64:
1672 return D0EPCTL_MPS_64;
1673 case 32:
1674 return D0EPCTL_MPS_32;
1675 case 16:
1676 return D0EPCTL_MPS_16;
1677 case 8:
1678 return D0EPCTL_MPS_8;
1679 }
1680
1681
1682 WARN_ON(1);
1683 return (u32)-1;
1684}
1685
1686
1687
1688
1689
1690
1691
1692
1693
1694
1695static void s3c_hsotg_set_ep_maxpacket(struct s3c_hsotg *hsotg,
1696 unsigned int ep, unsigned int mps)
1697{
1698 struct s3c_hsotg_ep *hs_ep = &hsotg->eps[ep];
1699 void __iomem *regs = hsotg->regs;
1700 u32 mpsval;
1701 u32 reg;
1702
1703 if (ep == 0) {
1704
1705 mpsval = s3c_hsotg_ep0_mps(mps);
1706 if (mpsval > 3)
1707 goto bad_mps;
1708 } else {
1709 if (mps >= DxEPCTL_MPS_LIMIT+1)
1710 goto bad_mps;
1711
1712 mpsval = mps;
1713 }
1714
1715 hs_ep->ep.maxpacket = mps;
1716
1717
1718
1719
1720
1721
1722 reg = readl(regs + DIEPCTL(ep));
1723 reg &= ~DxEPCTL_MPS_MASK;
1724 reg |= mpsval;
1725 writel(reg, regs + DIEPCTL(ep));
1726
1727 if (ep) {
1728 reg = readl(regs + DOEPCTL(ep));
1729 reg &= ~DxEPCTL_MPS_MASK;
1730 reg |= mpsval;
1731 writel(reg, regs + DOEPCTL(ep));
1732 }
1733
1734 return;
1735
1736bad_mps:
1737 dev_err(hsotg->dev, "ep%d: bad mps of %d\n", ep, mps);
1738}
1739
1740
1741
1742
1743
1744
1745static void s3c_hsotg_txfifo_flush(struct s3c_hsotg *hsotg, unsigned int idx)
1746{
1747 int timeout;
1748 int val;
1749
1750 writel(GRSTCTL_TxFNum(idx) | GRSTCTL_TxFFlsh,
1751 hsotg->regs + GRSTCTL);
1752
1753
1754 timeout = 100;
1755
1756 while (1) {
1757 val = readl(hsotg->regs + GRSTCTL);
1758
1759 if ((val & (GRSTCTL_TxFFlsh)) == 0)
1760 break;
1761
1762 if (--timeout == 0) {
1763 dev_err(hsotg->dev,
1764 "%s: timeout flushing fifo (GRSTCTL=%08x)\n",
1765 __func__, val);
1766 }
1767
1768 udelay(1);
1769 }
1770}
1771
1772
1773
1774
1775
1776
1777
1778
1779
1780static int s3c_hsotg_trytx(struct s3c_hsotg *hsotg,
1781 struct s3c_hsotg_ep *hs_ep)
1782{
1783 struct s3c_hsotg_req *hs_req = hs_ep->req;
1784
1785 if (!hs_ep->dir_in || !hs_req)
1786 return 0;
1787
1788 if (hs_req->req.actual < hs_req->req.length) {
1789 dev_dbg(hsotg->dev, "trying to write more for ep%d\n",
1790 hs_ep->index);
1791 return s3c_hsotg_write_fifo(hsotg, hs_ep, hs_req);
1792 }
1793
1794 return 0;
1795}
1796
1797
1798
1799
1800
1801
1802
1803
1804
1805static void s3c_hsotg_complete_in(struct s3c_hsotg *hsotg,
1806 struct s3c_hsotg_ep *hs_ep)
1807{
1808 struct s3c_hsotg_req *hs_req = hs_ep->req;
1809 u32 epsize = readl(hsotg->regs + DIEPTSIZ(hs_ep->index));
1810 int size_left, size_done;
1811
1812 if (!hs_req) {
1813 dev_dbg(hsotg->dev, "XferCompl but no req\n");
1814 return;
1815 }
1816
1817
1818 if (hsotg->eps[0].sent_zlp) {
1819 dev_dbg(hsotg->dev, "zlp packet received\n");
1820 s3c_hsotg_complete_request(hsotg, hs_ep, hs_req, 0);
1821 return;
1822 }
1823
1824
1825
1826
1827
1828
1829
1830
1831
1832
1833
1834 size_left = DxEPTSIZ_XferSize_GET(epsize);
1835
1836 size_done = hs_ep->size_loaded - size_left;
1837 size_done += hs_ep->last_load;
1838
1839 if (hs_req->req.actual != size_done)
1840 dev_dbg(hsotg->dev, "%s: adjusting size done %d => %d\n",
1841 __func__, hs_req->req.actual, size_done);
1842
1843 hs_req->req.actual = size_done;
1844 dev_dbg(hsotg->dev, "req->length:%d req->actual:%d req->zero:%d\n",
1845 hs_req->req.length, hs_req->req.actual, hs_req->req.zero);
1846
1847
1848
1849
1850
1851
1852
1853
1854
1855
1856
1857 if (hs_req->req.length && hs_ep->index == 0 && hs_req->req.zero &&
1858 hs_req->req.length == hs_req->req.actual &&
1859 !(hs_req->req.length % hs_ep->ep.maxpacket)) {
1860
1861 dev_dbg(hsotg->dev, "ep0 zlp IN packet sent\n");
1862 s3c_hsotg_send_zlp(hsotg, hs_req);
1863
1864 return;
1865 }
1866
1867 if (!size_left && hs_req->req.actual < hs_req->req.length) {
1868 dev_dbg(hsotg->dev, "%s trying more for req...\n", __func__);
1869 s3c_hsotg_start_req(hsotg, hs_ep, hs_req, true);
1870 } else
1871 s3c_hsotg_complete_request(hsotg, hs_ep, hs_req, 0);
1872}
1873
1874
1875
1876
1877
1878
1879
1880
1881
1882static void s3c_hsotg_epint(struct s3c_hsotg *hsotg, unsigned int idx,
1883 int dir_in)
1884{
1885 struct s3c_hsotg_ep *hs_ep = &hsotg->eps[idx];
1886 u32 epint_reg = dir_in ? DIEPINT(idx) : DOEPINT(idx);
1887 u32 epctl_reg = dir_in ? DIEPCTL(idx) : DOEPCTL(idx);
1888 u32 epsiz_reg = dir_in ? DIEPTSIZ(idx) : DOEPTSIZ(idx);
1889 u32 ints;
1890
1891 ints = readl(hsotg->regs + epint_reg);
1892
1893
1894 writel(ints, hsotg->regs + epint_reg);
1895
1896 dev_dbg(hsotg->dev, "%s: ep%d(%s) DxEPINT=0x%08x\n",
1897 __func__, idx, dir_in ? "in" : "out", ints);
1898
1899 if (ints & DxEPINT_XferCompl) {
1900 dev_dbg(hsotg->dev,
1901 "%s: XferCompl: DxEPCTL=0x%08x, DxEPTSIZ=%08x\n",
1902 __func__, readl(hsotg->regs + epctl_reg),
1903 readl(hsotg->regs + epsiz_reg));
1904
1905
1906
1907
1908
1909 if (dir_in) {
1910 s3c_hsotg_complete_in(hsotg, hs_ep);
1911
1912 if (idx == 0 && !hs_ep->req)
1913 s3c_hsotg_enqueue_setup(hsotg);
1914 } else if (using_dma(hsotg)) {
1915
1916
1917
1918
1919
1920 s3c_hsotg_handle_outdone(hsotg, idx, false);
1921 }
1922 }
1923
1924 if (ints & DxEPINT_EPDisbld) {
1925 dev_dbg(hsotg->dev, "%s: EPDisbld\n", __func__);
1926
1927 if (dir_in) {
1928 int epctl = readl(hsotg->regs + epctl_reg);
1929
1930 s3c_hsotg_txfifo_flush(hsotg, idx);
1931
1932 if ((epctl & DxEPCTL_Stall) &&
1933 (epctl & DxEPCTL_EPType_Bulk)) {
1934 int dctl = readl(hsotg->regs + DCTL);
1935
1936 dctl |= DCTL_CGNPInNAK;
1937 writel(dctl, hsotg->regs + DCTL);
1938 }
1939 }
1940 }
1941
1942 if (ints & DxEPINT_AHBErr)
1943 dev_dbg(hsotg->dev, "%s: AHBErr\n", __func__);
1944
1945 if (ints & DxEPINT_Setup) {
1946 dev_dbg(hsotg->dev, "%s: Setup/Timeout\n", __func__);
1947
1948 if (using_dma(hsotg) && idx == 0) {
1949
1950
1951
1952
1953
1954
1955
1956 if (dir_in)
1957 WARN_ON_ONCE(1);
1958 else
1959 s3c_hsotg_handle_outdone(hsotg, 0, true);
1960 }
1961 }
1962
1963 if (ints & DxEPINT_Back2BackSetup)
1964 dev_dbg(hsotg->dev, "%s: B2BSetup/INEPNakEff\n", __func__);
1965
1966 if (dir_in) {
1967
1968 if (ints & DIEPMSK_INTknTXFEmpMsk) {
1969 dev_dbg(hsotg->dev, "%s: ep%d: INTknTXFEmpMsk\n",
1970 __func__, idx);
1971 }
1972
1973
1974 if (ints & DIEPMSK_INTknEPMisMsk) {
1975 dev_warn(hsotg->dev, "%s: ep%d: INTknEP\n",
1976 __func__, idx);
1977 }
1978
1979
1980 if (hsotg->dedicated_fifos &&
1981 ints & DIEPMSK_TxFIFOEmpty) {
1982 dev_dbg(hsotg->dev, "%s: ep%d: TxFIFOEmpty\n",
1983 __func__, idx);
1984 if (!using_dma(hsotg))
1985 s3c_hsotg_trytx(hsotg, hs_ep);
1986 }
1987 }
1988}
1989
1990
1991
1992
1993
1994
1995
1996
1997static void s3c_hsotg_irq_enumdone(struct s3c_hsotg *hsotg)
1998{
1999 u32 dsts = readl(hsotg->regs + DSTS);
2000 int ep0_mps = 0, ep_mps;
2001
2002
2003
2004
2005
2006
2007
2008 dev_dbg(hsotg->dev, "EnumDone (DSTS=0x%08x)\n", dsts);
2009
2010
2011
2012
2013
2014
2015
2016
2017 switch (dsts & DSTS_EnumSpd_MASK) {
2018 case DSTS_EnumSpd_FS:
2019 case DSTS_EnumSpd_FS48:
2020 hsotg->gadget.speed = USB_SPEED_FULL;
2021 ep0_mps = EP0_MPS_LIMIT;
2022 ep_mps = 64;
2023 break;
2024
2025 case DSTS_EnumSpd_HS:
2026 hsotg->gadget.speed = USB_SPEED_HIGH;
2027 ep0_mps = EP0_MPS_LIMIT;
2028 ep_mps = 512;
2029 break;
2030
2031 case DSTS_EnumSpd_LS:
2032 hsotg->gadget.speed = USB_SPEED_LOW;
2033
2034
2035
2036
2037
2038 break;
2039 }
2040 dev_info(hsotg->dev, "new device is %s\n",
2041 usb_speed_string(hsotg->gadget.speed));
2042
2043
2044
2045
2046
2047
2048 if (ep0_mps) {
2049 int i;
2050 s3c_hsotg_set_ep_maxpacket(hsotg, 0, ep0_mps);
2051 for (i = 1; i < hsotg->num_of_eps; i++)
2052 s3c_hsotg_set_ep_maxpacket(hsotg, i, ep_mps);
2053 }
2054
2055
2056
2057 s3c_hsotg_enqueue_setup(hsotg);
2058
2059 dev_dbg(hsotg->dev, "EP0: DIEPCTL0=0x%08x, DOEPCTL0=0x%08x\n",
2060 readl(hsotg->regs + DIEPCTL0),
2061 readl(hsotg->regs + DOEPCTL0));
2062}
2063
2064
2065
2066
2067
2068
2069
2070
2071
2072
2073
2074static void kill_all_requests(struct s3c_hsotg *hsotg,
2075 struct s3c_hsotg_ep *ep,
2076 int result, bool force)
2077{
2078 struct s3c_hsotg_req *req, *treq;
2079
2080 list_for_each_entry_safe(req, treq, &ep->queue, queue) {
2081
2082
2083
2084
2085
2086 if (ep->req == req && ep->dir_in && !force)
2087 continue;
2088
2089 s3c_hsotg_complete_request(hsotg, ep, req,
2090 result);
2091 }
2092}
2093
2094#define call_gadget(_hs, _entry) \
2095 if ((_hs)->gadget.speed != USB_SPEED_UNKNOWN && \
2096 (_hs)->driver && (_hs)->driver->_entry) { \
2097 spin_unlock(&_hs->lock); \
2098 (_hs)->driver->_entry(&(_hs)->gadget); \
2099 spin_lock(&_hs->lock); \
2100 }
2101
2102
2103
2104
2105
2106
2107
2108
2109
2110static void s3c_hsotg_disconnect(struct s3c_hsotg *hsotg)
2111{
2112 unsigned ep;
2113
2114 for (ep = 0; ep < hsotg->num_of_eps; ep++)
2115 kill_all_requests(hsotg, &hsotg->eps[ep], -ESHUTDOWN, true);
2116
2117 call_gadget(hsotg, disconnect);
2118}
2119
2120
2121
2122
2123
2124
2125static void s3c_hsotg_irq_fifoempty(struct s3c_hsotg *hsotg, bool periodic)
2126{
2127 struct s3c_hsotg_ep *ep;
2128 int epno, ret;
2129
2130
2131
2132 for (epno = 0; epno < hsotg->num_of_eps; epno++) {
2133 ep = &hsotg->eps[epno];
2134
2135 if (!ep->dir_in)
2136 continue;
2137
2138 if ((periodic && !ep->periodic) ||
2139 (!periodic && ep->periodic))
2140 continue;
2141
2142 ret = s3c_hsotg_trytx(hsotg, ep);
2143 if (ret < 0)
2144 break;
2145 }
2146}
2147
2148
2149#define IRQ_RETRY_MASK (GINTSTS_NPTxFEmp | \
2150 GINTSTS_PTxFEmp | \
2151 GINTSTS_RxFLvl)
2152
2153
2154
2155
2156
2157
2158
2159static int s3c_hsotg_corereset(struct s3c_hsotg *hsotg)
2160{
2161 int timeout;
2162 u32 grstctl;
2163
2164 dev_dbg(hsotg->dev, "resetting core\n");
2165
2166
2167 writel(GRSTCTL_CSftRst, hsotg->regs + GRSTCTL);
2168
2169 timeout = 10000;
2170 do {
2171 grstctl = readl(hsotg->regs + GRSTCTL);
2172 } while ((grstctl & GRSTCTL_CSftRst) && timeout-- > 0);
2173
2174 if (grstctl & GRSTCTL_CSftRst) {
2175 dev_err(hsotg->dev, "Failed to get CSftRst asserted\n");
2176 return -EINVAL;
2177 }
2178
2179 timeout = 10000;
2180
2181 while (1) {
2182 u32 grstctl = readl(hsotg->regs + GRSTCTL);
2183
2184 if (timeout-- < 0) {
2185 dev_info(hsotg->dev,
2186 "%s: reset failed, GRSTCTL=%08x\n",
2187 __func__, grstctl);
2188 return -ETIMEDOUT;
2189 }
2190
2191 if (!(grstctl & GRSTCTL_AHBIdle))
2192 continue;
2193
2194 break;
2195 }
2196
2197 dev_dbg(hsotg->dev, "reset successful\n");
2198 return 0;
2199}
2200
2201
2202
2203
2204
2205
2206
2207static void s3c_hsotg_core_init(struct s3c_hsotg *hsotg)
2208{
2209 s3c_hsotg_corereset(hsotg);
2210
2211
2212
2213
2214
2215
2216
2217 writel(GUSBCFG_PHYIf16 | GUSBCFG_TOutCal(7) |
2218 (0x5 << 10), hsotg->regs + GUSBCFG);
2219
2220 s3c_hsotg_init_fifo(hsotg);
2221
2222 __orr32(hsotg->regs + DCTL, DCTL_SftDiscon);
2223
2224 writel(1 << 18 | DCFG_DevSpd_HS, hsotg->regs + DCFG);
2225
2226
2227 writel(0xffffffff, hsotg->regs + GOTGINT);
2228
2229
2230 writel(0xffffffff, hsotg->regs + GINTSTS);
2231
2232 writel(GINTSTS_ErlySusp | GINTSTS_SessReqInt |
2233 GINTSTS_GOUTNakEff | GINTSTS_GINNakEff |
2234 GINTSTS_ConIDStsChng | GINTSTS_USBRst |
2235 GINTSTS_EnumDone | GINTSTS_OTGInt |
2236 GINTSTS_USBSusp | GINTSTS_WkUpInt,
2237 hsotg->regs + GINTMSK);
2238
2239 if (using_dma(hsotg))
2240 writel(GAHBCFG_GlblIntrEn | GAHBCFG_DMAEn |
2241 GAHBCFG_HBstLen_Incr4,
2242 hsotg->regs + GAHBCFG);
2243 else
2244 writel(GAHBCFG_GlblIntrEn, hsotg->regs + GAHBCFG);
2245
2246
2247
2248
2249
2250
2251
2252 writel(((hsotg->dedicated_fifos) ? DIEPMSK_TxFIFOEmpty : 0) |
2253 DIEPMSK_EPDisbldMsk | DIEPMSK_XferComplMsk |
2254 DIEPMSK_TimeOUTMsk | DIEPMSK_AHBErrMsk |
2255 DIEPMSK_INTknEPMisMsk,
2256 hsotg->regs + DIEPMSK);
2257
2258
2259
2260
2261
2262 writel((using_dma(hsotg) ? (DIEPMSK_XferComplMsk |
2263 DIEPMSK_TimeOUTMsk) : 0) |
2264 DOEPMSK_EPDisbldMsk | DOEPMSK_AHBErrMsk |
2265 DOEPMSK_SetupMsk,
2266 hsotg->regs + DOEPMSK);
2267
2268 writel(0, hsotg->regs + DAINTMSK);
2269
2270 dev_dbg(hsotg->dev, "EP0: DIEPCTL0=0x%08x, DOEPCTL0=0x%08x\n",
2271 readl(hsotg->regs + DIEPCTL0),
2272 readl(hsotg->regs + DOEPCTL0));
2273
2274
2275 s3c_hsotg_en_gsint(hsotg, GINTSTS_OEPInt | GINTSTS_IEPInt);
2276
2277
2278
2279
2280
2281
2282 if (!using_dma(hsotg))
2283 s3c_hsotg_en_gsint(hsotg, GINTSTS_RxFLvl);
2284
2285
2286 s3c_hsotg_ctrl_epint(hsotg, 0, 0, 1);
2287 s3c_hsotg_ctrl_epint(hsotg, 0, 1, 1);
2288
2289 __orr32(hsotg->regs + DCTL, DCTL_PWROnPrgDone);
2290 udelay(10);
2291 __bic32(hsotg->regs + DCTL, DCTL_PWROnPrgDone);
2292
2293 dev_dbg(hsotg->dev, "DCTL=0x%08x\n", readl(hsotg->regs + DCTL));
2294
2295
2296
2297
2298
2299
2300
2301 writel(DxEPTSIZ_MC(1) | DxEPTSIZ_PktCnt(1) |
2302 DxEPTSIZ_XferSize(8), hsotg->regs + DOEPTSIZ0);
2303
2304 writel(s3c_hsotg_ep0_mps(hsotg->eps[0].ep.maxpacket) |
2305 DxEPCTL_CNAK | DxEPCTL_EPEna |
2306 DxEPCTL_USBActEp,
2307 hsotg->regs + DOEPCTL0);
2308
2309
2310 writel(s3c_hsotg_ep0_mps(hsotg->eps[0].ep.maxpacket) |
2311 DxEPCTL_USBActEp, hsotg->regs + DIEPCTL0);
2312
2313 s3c_hsotg_enqueue_setup(hsotg);
2314
2315 dev_dbg(hsotg->dev, "EP0: DIEPCTL0=0x%08x, DOEPCTL0=0x%08x\n",
2316 readl(hsotg->regs + DIEPCTL0),
2317 readl(hsotg->regs + DOEPCTL0));
2318
2319
2320 writel(DCTL_CGOUTNak | DCTL_CGNPInNAK,
2321 hsotg->regs + DCTL);
2322
2323
2324 mdelay(3);
2325
2326
2327 __bic32(hsotg->regs + DCTL, DCTL_SftDiscon);
2328}
2329
2330
2331
2332
2333
2334
2335static irqreturn_t s3c_hsotg_irq(int irq, void *pw)
2336{
2337 struct s3c_hsotg *hsotg = pw;
2338 int retry_count = 8;
2339 u32 gintsts;
2340 u32 gintmsk;
2341
2342 spin_lock(&hsotg->lock);
2343irq_retry:
2344 gintsts = readl(hsotg->regs + GINTSTS);
2345 gintmsk = readl(hsotg->regs + GINTMSK);
2346
2347 dev_dbg(hsotg->dev, "%s: %08x %08x (%08x) retry %d\n",
2348 __func__, gintsts, gintsts & gintmsk, gintmsk, retry_count);
2349
2350 gintsts &= gintmsk;
2351
2352 if (gintsts & GINTSTS_OTGInt) {
2353 u32 otgint = readl(hsotg->regs + GOTGINT);
2354
2355 dev_info(hsotg->dev, "OTGInt: %08x\n", otgint);
2356
2357 writel(otgint, hsotg->regs + GOTGINT);
2358 }
2359
2360 if (gintsts & GINTSTS_SessReqInt) {
2361 dev_dbg(hsotg->dev, "%s: SessReqInt\n", __func__);
2362 writel(GINTSTS_SessReqInt, hsotg->regs + GINTSTS);
2363 }
2364
2365 if (gintsts & GINTSTS_EnumDone) {
2366 writel(GINTSTS_EnumDone, hsotg->regs + GINTSTS);
2367
2368 s3c_hsotg_irq_enumdone(hsotg);
2369 }
2370
2371 if (gintsts & GINTSTS_ConIDStsChng) {
2372 dev_dbg(hsotg->dev, "ConIDStsChg (DSTS=0x%08x, GOTCTL=%08x)\n",
2373 readl(hsotg->regs + DSTS),
2374 readl(hsotg->regs + GOTGCTL));
2375
2376 writel(GINTSTS_ConIDStsChng, hsotg->regs + GINTSTS);
2377 }
2378
2379 if (gintsts & (GINTSTS_OEPInt | GINTSTS_IEPInt)) {
2380 u32 daint = readl(hsotg->regs + DAINT);
2381 u32 daint_out = daint >> DAINT_OutEP_SHIFT;
2382 u32 daint_in = daint & ~(daint_out << DAINT_OutEP_SHIFT);
2383 int ep;
2384
2385 dev_dbg(hsotg->dev, "%s: daint=%08x\n", __func__, daint);
2386
2387 for (ep = 0; ep < 15 && daint_out; ep++, daint_out >>= 1) {
2388 if (daint_out & 1)
2389 s3c_hsotg_epint(hsotg, ep, 0);
2390 }
2391
2392 for (ep = 0; ep < 15 && daint_in; ep++, daint_in >>= 1) {
2393 if (daint_in & 1)
2394 s3c_hsotg_epint(hsotg, ep, 1);
2395 }
2396 }
2397
2398 if (gintsts & GINTSTS_USBRst) {
2399
2400 u32 usb_status = readl(hsotg->regs + GOTGCTL);
2401
2402 dev_info(hsotg->dev, "%s: USBRst\n", __func__);
2403 dev_dbg(hsotg->dev, "GNPTXSTS=%08x\n",
2404 readl(hsotg->regs + GNPTXSTS));
2405
2406 writel(GINTSTS_USBRst, hsotg->regs + GINTSTS);
2407
2408 if (usb_status & GOTGCTL_BSESVLD) {
2409 if (time_after(jiffies, hsotg->last_rst +
2410 msecs_to_jiffies(200))) {
2411
2412 kill_all_requests(hsotg, &hsotg->eps[0],
2413 -ECONNRESET, true);
2414
2415 s3c_hsotg_core_init(hsotg);
2416 hsotg->last_rst = jiffies;
2417 }
2418 }
2419 }
2420
2421
2422
2423 if (gintsts & GINTSTS_NPTxFEmp) {
2424 dev_dbg(hsotg->dev, "NPTxFEmp\n");
2425
2426
2427
2428
2429
2430
2431
2432 s3c_hsotg_disable_gsint(hsotg, GINTSTS_NPTxFEmp);
2433 s3c_hsotg_irq_fifoempty(hsotg, false);
2434 }
2435
2436 if (gintsts & GINTSTS_PTxFEmp) {
2437 dev_dbg(hsotg->dev, "PTxFEmp\n");
2438
2439
2440
2441 s3c_hsotg_disable_gsint(hsotg, GINTSTS_PTxFEmp);
2442 s3c_hsotg_irq_fifoempty(hsotg, true);
2443 }
2444
2445 if (gintsts & GINTSTS_RxFLvl) {
2446
2447
2448
2449
2450
2451
2452 s3c_hsotg_handle_rx(hsotg);
2453 }
2454
2455 if (gintsts & GINTSTS_ModeMis) {
2456 dev_warn(hsotg->dev, "warning, mode mismatch triggered\n");
2457 writel(GINTSTS_ModeMis, hsotg->regs + GINTSTS);
2458 }
2459
2460 if (gintsts & GINTSTS_USBSusp) {
2461 dev_info(hsotg->dev, "GINTSTS_USBSusp\n");
2462 writel(GINTSTS_USBSusp, hsotg->regs + GINTSTS);
2463
2464 call_gadget(hsotg, suspend);
2465 s3c_hsotg_disconnect(hsotg);
2466 }
2467
2468 if (gintsts & GINTSTS_WkUpInt) {
2469 dev_info(hsotg->dev, "GINTSTS_WkUpIn\n");
2470 writel(GINTSTS_WkUpInt, hsotg->regs + GINTSTS);
2471
2472 call_gadget(hsotg, resume);
2473 }
2474
2475 if (gintsts & GINTSTS_ErlySusp) {
2476 dev_dbg(hsotg->dev, "GINTSTS_ErlySusp\n");
2477 writel(GINTSTS_ErlySusp, hsotg->regs + GINTSTS);
2478 }
2479
2480
2481
2482
2483
2484
2485
2486 if (gintsts & GINTSTS_GOUTNakEff) {
2487 dev_info(hsotg->dev, "GOUTNakEff triggered\n");
2488
2489 writel(DCTL_CGOUTNak, hsotg->regs + DCTL);
2490
2491 s3c_hsotg_dump(hsotg);
2492 }
2493
2494 if (gintsts & GINTSTS_GINNakEff) {
2495 dev_info(hsotg->dev, "GINNakEff triggered\n");
2496
2497 writel(DCTL_CGNPInNAK, hsotg->regs + DCTL);
2498
2499 s3c_hsotg_dump(hsotg);
2500 }
2501
2502
2503
2504
2505
2506
2507 if (gintsts & IRQ_RETRY_MASK && --retry_count > 0)
2508 goto irq_retry;
2509
2510 spin_unlock(&hsotg->lock);
2511
2512 return IRQ_HANDLED;
2513}
2514
2515
2516
2517
2518
2519
2520
2521
2522static int s3c_hsotg_ep_enable(struct usb_ep *ep,
2523 const struct usb_endpoint_descriptor *desc)
2524{
2525 struct s3c_hsotg_ep *hs_ep = our_ep(ep);
2526 struct s3c_hsotg *hsotg = hs_ep->parent;
2527 unsigned long flags;
2528 int index = hs_ep->index;
2529 u32 epctrl_reg;
2530 u32 epctrl;
2531 u32 mps;
2532 int dir_in;
2533 int ret = 0;
2534
2535 dev_dbg(hsotg->dev,
2536 "%s: ep %s: a 0x%02x, attr 0x%02x, mps 0x%04x, intr %d\n",
2537 __func__, ep->name, desc->bEndpointAddress, desc->bmAttributes,
2538 desc->wMaxPacketSize, desc->bInterval);
2539
2540
2541 WARN_ON(index == 0);
2542
2543 dir_in = (desc->bEndpointAddress & USB_ENDPOINT_DIR_MASK) ? 1 : 0;
2544 if (dir_in != hs_ep->dir_in) {
2545 dev_err(hsotg->dev, "%s: direction mismatch!\n", __func__);
2546 return -EINVAL;
2547 }
2548
2549 mps = usb_endpoint_maxp(desc);
2550
2551
2552
2553 epctrl_reg = dir_in ? DIEPCTL(index) : DOEPCTL(index);
2554 epctrl = readl(hsotg->regs + epctrl_reg);
2555
2556 dev_dbg(hsotg->dev, "%s: read DxEPCTL=0x%08x from 0x%08x\n",
2557 __func__, epctrl, epctrl_reg);
2558
2559 spin_lock_irqsave(&hsotg->lock, flags);
2560
2561 epctrl &= ~(DxEPCTL_EPType_MASK | DxEPCTL_MPS_MASK);
2562 epctrl |= DxEPCTL_MPS(mps);
2563
2564
2565
2566
2567
2568 epctrl |= DxEPCTL_USBActEp;
2569
2570
2571
2572
2573
2574
2575
2576
2577 epctrl |= DxEPCTL_SNAK;
2578
2579
2580 hs_ep->ep.maxpacket = mps;
2581
2582
2583 hs_ep->periodic = 0;
2584
2585 switch (desc->bmAttributes & USB_ENDPOINT_XFERTYPE_MASK) {
2586 case USB_ENDPOINT_XFER_ISOC:
2587 dev_err(hsotg->dev, "no current ISOC support\n");
2588 ret = -EINVAL;
2589 goto out;
2590
2591 case USB_ENDPOINT_XFER_BULK:
2592 epctrl |= DxEPCTL_EPType_Bulk;
2593 break;
2594
2595 case USB_ENDPOINT_XFER_INT:
2596 if (dir_in) {
2597
2598
2599
2600
2601
2602
2603
2604 hs_ep->periodic = 1;
2605 epctrl |= DxEPCTL_TxFNum(index);
2606 }
2607
2608 epctrl |= DxEPCTL_EPType_Intterupt;
2609 break;
2610
2611 case USB_ENDPOINT_XFER_CONTROL:
2612 epctrl |= DxEPCTL_EPType_Control;
2613 break;
2614 }
2615
2616
2617
2618
2619
2620 if (dir_in && hsotg->dedicated_fifos)
2621 epctrl |= DxEPCTL_TxFNum(index);
2622
2623
2624 if (index)
2625 epctrl |= DxEPCTL_SetD0PID;
2626
2627 dev_dbg(hsotg->dev, "%s: write DxEPCTL=0x%08x\n",
2628 __func__, epctrl);
2629
2630 writel(epctrl, hsotg->regs + epctrl_reg);
2631 dev_dbg(hsotg->dev, "%s: read DxEPCTL=0x%08x\n",
2632 __func__, readl(hsotg->regs + epctrl_reg));
2633
2634
2635 s3c_hsotg_ctrl_epint(hsotg, index, dir_in, 1);
2636
2637out:
2638 spin_unlock_irqrestore(&hsotg->lock, flags);
2639 return ret;
2640}
2641
2642
2643
2644
2645
2646static int s3c_hsotg_ep_disable(struct usb_ep *ep)
2647{
2648 struct s3c_hsotg_ep *hs_ep = our_ep(ep);
2649 struct s3c_hsotg *hsotg = hs_ep->parent;
2650 int dir_in = hs_ep->dir_in;
2651 int index = hs_ep->index;
2652 unsigned long flags;
2653 u32 epctrl_reg;
2654 u32 ctrl;
2655
2656 dev_info(hsotg->dev, "%s(ep %p)\n", __func__, ep);
2657
2658 if (ep == &hsotg->eps[0].ep) {
2659 dev_err(hsotg->dev, "%s: called for ep0\n", __func__);
2660 return -EINVAL;
2661 }
2662
2663 epctrl_reg = dir_in ? DIEPCTL(index) : DOEPCTL(index);
2664
2665 spin_lock_irqsave(&hsotg->lock, flags);
2666
2667 kill_all_requests(hsotg, hs_ep, -ESHUTDOWN, false);
2668
2669
2670 ctrl = readl(hsotg->regs + epctrl_reg);
2671 ctrl &= ~DxEPCTL_EPEna;
2672 ctrl &= ~DxEPCTL_USBActEp;
2673 ctrl |= DxEPCTL_SNAK;
2674
2675 dev_dbg(hsotg->dev, "%s: DxEPCTL=0x%08x\n", __func__, ctrl);
2676 writel(ctrl, hsotg->regs + epctrl_reg);
2677
2678
2679 s3c_hsotg_ctrl_epint(hsotg, hs_ep->index, hs_ep->dir_in, 0);
2680
2681 spin_unlock_irqrestore(&hsotg->lock, flags);
2682 return 0;
2683}
2684
2685
2686
2687
2688
2689
2690static bool on_list(struct s3c_hsotg_ep *ep, struct s3c_hsotg_req *test)
2691{
2692 struct s3c_hsotg_req *req, *treq;
2693
2694 list_for_each_entry_safe(req, treq, &ep->queue, queue) {
2695 if (req == test)
2696 return true;
2697 }
2698
2699 return false;
2700}
2701
2702
2703
2704
2705
2706
2707static int s3c_hsotg_ep_dequeue(struct usb_ep *ep, struct usb_request *req)
2708{
2709 struct s3c_hsotg_req *hs_req = our_req(req);
2710 struct s3c_hsotg_ep *hs_ep = our_ep(ep);
2711 struct s3c_hsotg *hs = hs_ep->parent;
2712 unsigned long flags;
2713
2714 dev_info(hs->dev, "ep_dequeue(%p,%p)\n", ep, req);
2715
2716 spin_lock_irqsave(&hs->lock, flags);
2717
2718 if (!on_list(hs_ep, hs_req)) {
2719 spin_unlock_irqrestore(&hs->lock, flags);
2720 return -EINVAL;
2721 }
2722
2723 s3c_hsotg_complete_request(hs, hs_ep, hs_req, -ECONNRESET);
2724 spin_unlock_irqrestore(&hs->lock, flags);
2725
2726 return 0;
2727}
2728
2729
2730
2731
2732
2733
2734static int s3c_hsotg_ep_sethalt(struct usb_ep *ep, int value)
2735{
2736 struct s3c_hsotg_ep *hs_ep = our_ep(ep);
2737 struct s3c_hsotg *hs = hs_ep->parent;
2738 int index = hs_ep->index;
2739 u32 epreg;
2740 u32 epctl;
2741 u32 xfertype;
2742
2743 dev_info(hs->dev, "%s(ep %p %s, %d)\n", __func__, ep, ep->name, value);
2744
2745
2746
2747 epreg = DIEPCTL(index);
2748 epctl = readl(hs->regs + epreg);
2749
2750 if (value) {
2751 epctl |= DxEPCTL_Stall + DxEPCTL_SNAK;
2752 if (epctl & DxEPCTL_EPEna)
2753 epctl |= DxEPCTL_EPDis;
2754 } else {
2755 epctl &= ~DxEPCTL_Stall;
2756 xfertype = epctl & DxEPCTL_EPType_MASK;
2757 if (xfertype == DxEPCTL_EPType_Bulk ||
2758 xfertype == DxEPCTL_EPType_Intterupt)
2759 epctl |= DxEPCTL_SetD0PID;
2760 }
2761
2762 writel(epctl, hs->regs + epreg);
2763
2764 epreg = DOEPCTL(index);
2765 epctl = readl(hs->regs + epreg);
2766
2767 if (value)
2768 epctl |= DxEPCTL_Stall;
2769 else {
2770 epctl &= ~DxEPCTL_Stall;
2771 xfertype = epctl & DxEPCTL_EPType_MASK;
2772 if (xfertype == DxEPCTL_EPType_Bulk ||
2773 xfertype == DxEPCTL_EPType_Intterupt)
2774 epctl |= DxEPCTL_SetD0PID;
2775 }
2776
2777 writel(epctl, hs->regs + epreg);
2778
2779 return 0;
2780}
2781
2782
2783
2784
2785
2786
2787static int s3c_hsotg_ep_sethalt_lock(struct usb_ep *ep, int value)
2788{
2789 struct s3c_hsotg_ep *hs_ep = our_ep(ep);
2790 struct s3c_hsotg *hs = hs_ep->parent;
2791 unsigned long flags = 0;
2792 int ret = 0;
2793
2794 spin_lock_irqsave(&hs->lock, flags);
2795 ret = s3c_hsotg_ep_sethalt(ep, value);
2796 spin_unlock_irqrestore(&hs->lock, flags);
2797
2798 return ret;
2799}
2800
2801static struct usb_ep_ops s3c_hsotg_ep_ops = {
2802 .enable = s3c_hsotg_ep_enable,
2803 .disable = s3c_hsotg_ep_disable,
2804 .alloc_request = s3c_hsotg_ep_alloc_request,
2805 .free_request = s3c_hsotg_ep_free_request,
2806 .queue = s3c_hsotg_ep_queue_lock,
2807 .dequeue = s3c_hsotg_ep_dequeue,
2808 .set_halt = s3c_hsotg_ep_sethalt_lock,
2809
2810};
2811
2812
2813
2814
2815
2816
2817
2818
2819static void s3c_hsotg_phy_enable(struct s3c_hsotg *hsotg)
2820{
2821 struct platform_device *pdev = to_platform_device(hsotg->dev);
2822
2823 dev_dbg(hsotg->dev, "pdev 0x%p\n", pdev);
2824
2825 if (hsotg->phy)
2826 usb_phy_init(hsotg->phy);
2827 else if (hsotg->plat->phy_init)
2828 hsotg->plat->phy_init(pdev, hsotg->plat->phy_type);
2829}
2830
2831
2832
2833
2834
2835
2836
2837
2838static void s3c_hsotg_phy_disable(struct s3c_hsotg *hsotg)
2839{
2840 struct platform_device *pdev = to_platform_device(hsotg->dev);
2841
2842 if (hsotg->phy)
2843 usb_phy_shutdown(hsotg->phy);
2844 else if (hsotg->plat->phy_exit)
2845 hsotg->plat->phy_exit(pdev, hsotg->plat->phy_type);
2846}
2847
2848
2849
2850
2851
2852static void s3c_hsotg_init(struct s3c_hsotg *hsotg)
2853{
2854
2855
2856 writel(DIEPMSK_TimeOUTMsk | DIEPMSK_AHBErrMsk |
2857 DIEPMSK_EPDisbldMsk | DIEPMSK_XferComplMsk,
2858 hsotg->regs + DIEPMSK);
2859
2860 writel(DOEPMSK_SetupMsk | DOEPMSK_AHBErrMsk |
2861 DOEPMSK_EPDisbldMsk | DOEPMSK_XferComplMsk,
2862 hsotg->regs + DOEPMSK);
2863
2864 writel(0, hsotg->regs + DAINTMSK);
2865
2866
2867 __orr32(hsotg->regs + DCTL, DCTL_SftDiscon);
2868
2869 if (0) {
2870
2871 writel(DCTL_SGNPInNAK | DCTL_SGOUTNak,
2872 hsotg->regs + DCTL);
2873 }
2874
2875
2876
2877 dev_dbg(hsotg->dev, "GRXFSIZ=0x%08x, GNPTXFSIZ=0x%08x\n",
2878 readl(hsotg->regs + GRXFSIZ),
2879 readl(hsotg->regs + GNPTXFSIZ));
2880
2881 s3c_hsotg_init_fifo(hsotg);
2882
2883
2884 writel(GUSBCFG_PHYIf16 | GUSBCFG_TOutCal(7) | (0x5 << 10),
2885 hsotg->regs + GUSBCFG);
2886
2887 writel(using_dma(hsotg) ? GAHBCFG_DMAEn : 0x0,
2888 hsotg->regs + GAHBCFG);
2889}
2890
2891
2892
2893
2894
2895
2896
2897
2898
2899static int s3c_hsotg_udc_start(struct usb_gadget *gadget,
2900 struct usb_gadget_driver *driver)
2901{
2902 struct s3c_hsotg *hsotg = to_hsotg(gadget);
2903 int ret;
2904
2905 if (!hsotg) {
2906 printk(KERN_ERR "%s: called with no device\n", __func__);
2907 return -ENODEV;
2908 }
2909
2910 if (!driver) {
2911 dev_err(hsotg->dev, "%s: no driver\n", __func__);
2912 return -EINVAL;
2913 }
2914
2915 if (driver->max_speed < USB_SPEED_FULL)
2916 dev_err(hsotg->dev, "%s: bad speed\n", __func__);
2917
2918 if (!driver->setup) {
2919 dev_err(hsotg->dev, "%s: missing entry points\n", __func__);
2920 return -EINVAL;
2921 }
2922
2923 WARN_ON(hsotg->driver);
2924
2925 driver->driver.bus = NULL;
2926 hsotg->driver = driver;
2927 hsotg->gadget.dev.of_node = hsotg->dev->of_node;
2928 hsotg->gadget.speed = USB_SPEED_UNKNOWN;
2929
2930 ret = regulator_bulk_enable(ARRAY_SIZE(hsotg->supplies),
2931 hsotg->supplies);
2932 if (ret) {
2933 dev_err(hsotg->dev, "failed to enable supplies: %d\n", ret);
2934 goto err;
2935 }
2936
2937 hsotg->last_rst = jiffies;
2938 dev_info(hsotg->dev, "bound driver %s\n", driver->driver.name);
2939 return 0;
2940
2941err:
2942 hsotg->driver = NULL;
2943 return ret;
2944}
2945
2946
2947
2948
2949
2950
2951
2952
2953static int s3c_hsotg_udc_stop(struct usb_gadget *gadget,
2954 struct usb_gadget_driver *driver)
2955{
2956 struct s3c_hsotg *hsotg = to_hsotg(gadget);
2957 unsigned long flags = 0;
2958 int ep;
2959
2960 if (!hsotg)
2961 return -ENODEV;
2962
2963
2964 for (ep = 0; ep < hsotg->num_of_eps; ep++)
2965 s3c_hsotg_ep_disable(&hsotg->eps[ep].ep);
2966
2967 spin_lock_irqsave(&hsotg->lock, flags);
2968
2969 s3c_hsotg_phy_disable(hsotg);
2970
2971 if (!driver)
2972 hsotg->driver = NULL;
2973
2974 hsotg->gadget.speed = USB_SPEED_UNKNOWN;
2975
2976 spin_unlock_irqrestore(&hsotg->lock, flags);
2977
2978 regulator_bulk_disable(ARRAY_SIZE(hsotg->supplies), hsotg->supplies);
2979
2980 return 0;
2981}
2982
2983
2984
2985
2986
2987
2988
2989static int s3c_hsotg_gadget_getframe(struct usb_gadget *gadget)
2990{
2991 return s3c_hsotg_read_frameno(to_hsotg(gadget));
2992}
2993
2994
2995
2996
2997
2998
2999
3000
3001static int s3c_hsotg_pullup(struct usb_gadget *gadget, int is_on)
3002{
3003 struct s3c_hsotg *hsotg = to_hsotg(gadget);
3004 unsigned long flags = 0;
3005
3006 dev_dbg(hsotg->dev, "%s: is_in: %d\n", __func__, is_on);
3007
3008 spin_lock_irqsave(&hsotg->lock, flags);
3009 if (is_on) {
3010 s3c_hsotg_phy_enable(hsotg);
3011 s3c_hsotg_core_init(hsotg);
3012 } else {
3013 s3c_hsotg_disconnect(hsotg);
3014 s3c_hsotg_phy_disable(hsotg);
3015 }
3016
3017 hsotg->gadget.speed = USB_SPEED_UNKNOWN;
3018 spin_unlock_irqrestore(&hsotg->lock, flags);
3019
3020 return 0;
3021}
3022
3023static const struct usb_gadget_ops s3c_hsotg_gadget_ops = {
3024 .get_frame = s3c_hsotg_gadget_getframe,
3025 .udc_start = s3c_hsotg_udc_start,
3026 .udc_stop = s3c_hsotg_udc_stop,
3027 .pullup = s3c_hsotg_pullup,
3028};
3029
3030
3031
3032
3033
3034
3035
3036
3037
3038
3039
3040static void s3c_hsotg_initep(struct s3c_hsotg *hsotg,
3041 struct s3c_hsotg_ep *hs_ep,
3042 int epnum)
3043{
3044 u32 ptxfifo;
3045 char *dir;
3046
3047 if (epnum == 0)
3048 dir = "";
3049 else if ((epnum % 2) == 0) {
3050 dir = "out";
3051 } else {
3052 dir = "in";
3053 hs_ep->dir_in = 1;
3054 }
3055
3056 hs_ep->index = epnum;
3057
3058 snprintf(hs_ep->name, sizeof(hs_ep->name), "ep%d%s", epnum, dir);
3059
3060 INIT_LIST_HEAD(&hs_ep->queue);
3061 INIT_LIST_HEAD(&hs_ep->ep.ep_list);
3062
3063
3064 if (epnum)
3065 list_add_tail(&hs_ep->ep.ep_list, &hsotg->gadget.ep_list);
3066
3067 hs_ep->parent = hsotg;
3068 hs_ep->ep.name = hs_ep->name;
3069 hs_ep->ep.maxpacket = epnum ? 512 : EP0_MPS_LIMIT;
3070 hs_ep->ep.ops = &s3c_hsotg_ep_ops;
3071
3072
3073
3074
3075
3076
3077
3078 ptxfifo = readl(hsotg->regs + DPTXFSIZn(epnum));
3079 hs_ep->fifo_size = DPTXFSIZn_DPTxFSize_GET(ptxfifo) * 4;
3080
3081
3082
3083
3084
3085
3086 if (using_dma(hsotg)) {
3087 u32 next = DxEPCTL_NextEp((epnum + 1) % 15);
3088 writel(next, hsotg->regs + DIEPCTL(epnum));
3089 writel(next, hsotg->regs + DOEPCTL(epnum));
3090 }
3091}
3092
3093
3094
3095
3096
3097
3098
3099static void s3c_hsotg_hw_cfg(struct s3c_hsotg *hsotg)
3100{
3101 u32 cfg2, cfg4;
3102
3103
3104 cfg2 = readl(hsotg->regs + 0x48);
3105 hsotg->num_of_eps = (cfg2 >> 10) & 0xF;
3106
3107 dev_info(hsotg->dev, "EPs:%d\n", hsotg->num_of_eps);
3108
3109 cfg4 = readl(hsotg->regs + 0x50);
3110 hsotg->dedicated_fifos = (cfg4 >> 25) & 1;
3111
3112 dev_info(hsotg->dev, "%s fifos\n",
3113 hsotg->dedicated_fifos ? "dedicated" : "shared");
3114}
3115
3116
3117
3118
3119
3120static void s3c_hsotg_dump(struct s3c_hsotg *hsotg)
3121{
3122#ifdef DEBUG
3123 struct device *dev = hsotg->dev;
3124 void __iomem *regs = hsotg->regs;
3125 u32 val;
3126 int idx;
3127
3128 dev_info(dev, "DCFG=0x%08x, DCTL=0x%08x, DIEPMSK=%08x\n",
3129 readl(regs + DCFG), readl(regs + DCTL),
3130 readl(regs + DIEPMSK));
3131
3132 dev_info(dev, "GAHBCFG=0x%08x, 0x44=0x%08x\n",
3133 readl(regs + GAHBCFG), readl(regs + 0x44));
3134
3135 dev_info(dev, "GRXFSIZ=0x%08x, GNPTXFSIZ=0x%08x\n",
3136 readl(regs + GRXFSIZ), readl(regs + GNPTXFSIZ));
3137
3138
3139
3140 for (idx = 1; idx <= 15; idx++) {
3141 val = readl(regs + DPTXFSIZn(idx));
3142 dev_info(dev, "DPTx[%d] FSize=%d, StAddr=0x%08x\n", idx,
3143 val >> DPTXFSIZn_DPTxFSize_SHIFT,
3144 val & DPTXFSIZn_DPTxFStAddr_MASK);
3145 }
3146
3147 for (idx = 0; idx < 15; idx++) {
3148 dev_info(dev,
3149 "ep%d-in: EPCTL=0x%08x, SIZ=0x%08x, DMA=0x%08x\n", idx,
3150 readl(regs + DIEPCTL(idx)),
3151 readl(regs + DIEPTSIZ(idx)),
3152 readl(regs + DIEPDMA(idx)));
3153
3154 val = readl(regs + DOEPCTL(idx));
3155 dev_info(dev,
3156 "ep%d-out: EPCTL=0x%08x, SIZ=0x%08x, DMA=0x%08x\n",
3157 idx, readl(regs + DOEPCTL(idx)),
3158 readl(regs + DOEPTSIZ(idx)),
3159 readl(regs + DOEPDMA(idx)));
3160
3161 }
3162
3163 dev_info(dev, "DVBUSDIS=0x%08x, DVBUSPULSE=%08x\n",
3164 readl(regs + DVBUSDIS), readl(regs + DVBUSPULSE));
3165#endif
3166}
3167
3168
3169
3170
3171
3172
3173
3174
3175
3176
3177static int state_show(struct seq_file *seq, void *v)
3178{
3179 struct s3c_hsotg *hsotg = seq->private;
3180 void __iomem *regs = hsotg->regs;
3181 int idx;
3182
3183 seq_printf(seq, "DCFG=0x%08x, DCTL=0x%08x, DSTS=0x%08x\n",
3184 readl(regs + DCFG),
3185 readl(regs + DCTL),
3186 readl(regs + DSTS));
3187
3188 seq_printf(seq, "DIEPMSK=0x%08x, DOEPMASK=0x%08x\n",
3189 readl(regs + DIEPMSK), readl(regs + DOEPMSK));
3190
3191 seq_printf(seq, "GINTMSK=0x%08x, GINTSTS=0x%08x\n",
3192 readl(regs + GINTMSK),
3193 readl(regs + GINTSTS));
3194
3195 seq_printf(seq, "DAINTMSK=0x%08x, DAINT=0x%08x\n",
3196 readl(regs + DAINTMSK),
3197 readl(regs + DAINT));
3198
3199 seq_printf(seq, "GNPTXSTS=0x%08x, GRXSTSR=%08x\n",
3200 readl(regs + GNPTXSTS),
3201 readl(regs + GRXSTSR));
3202
3203 seq_printf(seq, "\nEndpoint status:\n");
3204
3205 for (idx = 0; idx < 15; idx++) {
3206 u32 in, out;
3207
3208 in = readl(regs + DIEPCTL(idx));
3209 out = readl(regs + DOEPCTL(idx));
3210
3211 seq_printf(seq, "ep%d: DIEPCTL=0x%08x, DOEPCTL=0x%08x",
3212 idx, in, out);
3213
3214 in = readl(regs + DIEPTSIZ(idx));
3215 out = readl(regs + DOEPTSIZ(idx));
3216
3217 seq_printf(seq, ", DIEPTSIZ=0x%08x, DOEPTSIZ=0x%08x",
3218 in, out);
3219
3220 seq_printf(seq, "\n");
3221 }
3222
3223 return 0;
3224}
3225
3226static int state_open(struct inode *inode, struct file *file)
3227{
3228 return single_open(file, state_show, inode->i_private);
3229}
3230
3231static const struct file_operations state_fops = {
3232 .owner = THIS_MODULE,
3233 .open = state_open,
3234 .read = seq_read,
3235 .llseek = seq_lseek,
3236 .release = single_release,
3237};
3238
3239
3240
3241
3242
3243
3244
3245
3246
3247static int fifo_show(struct seq_file *seq, void *v)
3248{
3249 struct s3c_hsotg *hsotg = seq->private;
3250 void __iomem *regs = hsotg->regs;
3251 u32 val;
3252 int idx;
3253
3254 seq_printf(seq, "Non-periodic FIFOs:\n");
3255 seq_printf(seq, "RXFIFO: Size %d\n", readl(regs + GRXFSIZ));
3256
3257 val = readl(regs + GNPTXFSIZ);
3258 seq_printf(seq, "NPTXFIFO: Size %d, Start 0x%08x\n",
3259 val >> GNPTXFSIZ_NPTxFDep_SHIFT,
3260 val & GNPTXFSIZ_NPTxFStAddr_MASK);
3261
3262 seq_printf(seq, "\nPeriodic TXFIFOs:\n");
3263
3264 for (idx = 1; idx <= 15; idx++) {
3265 val = readl(regs + DPTXFSIZn(idx));
3266
3267 seq_printf(seq, "\tDPTXFIFO%2d: Size %d, Start 0x%08x\n", idx,
3268 val >> DPTXFSIZn_DPTxFSize_SHIFT,
3269 val & DPTXFSIZn_DPTxFStAddr_MASK);
3270 }
3271
3272 return 0;
3273}
3274
3275static int fifo_open(struct inode *inode, struct file *file)
3276{
3277 return single_open(file, fifo_show, inode->i_private);
3278}
3279
3280static const struct file_operations fifo_fops = {
3281 .owner = THIS_MODULE,
3282 .open = fifo_open,
3283 .read = seq_read,
3284 .llseek = seq_lseek,
3285 .release = single_release,
3286};
3287
3288
3289static const char *decode_direction(int is_in)
3290{
3291 return is_in ? "in" : "out";
3292}
3293
3294
3295
3296
3297
3298
3299
3300
3301
3302static int ep_show(struct seq_file *seq, void *v)
3303{
3304 struct s3c_hsotg_ep *ep = seq->private;
3305 struct s3c_hsotg *hsotg = ep->parent;
3306 struct s3c_hsotg_req *req;
3307 void __iomem *regs = hsotg->regs;
3308 int index = ep->index;
3309 int show_limit = 15;
3310 unsigned long flags;
3311
3312 seq_printf(seq, "Endpoint index %d, named %s, dir %s:\n",
3313 ep->index, ep->ep.name, decode_direction(ep->dir_in));
3314
3315
3316
3317 seq_printf(seq, "\tDIEPCTL=0x%08x, DOEPCTL=0x%08x\n",
3318 readl(regs + DIEPCTL(index)),
3319 readl(regs + DOEPCTL(index)));
3320
3321 seq_printf(seq, "\tDIEPDMA=0x%08x, DOEPDMA=0x%08x\n",
3322 readl(regs + DIEPDMA(index)),
3323 readl(regs + DOEPDMA(index)));
3324
3325 seq_printf(seq, "\tDIEPINT=0x%08x, DOEPINT=0x%08x\n",
3326 readl(regs + DIEPINT(index)),
3327 readl(regs + DOEPINT(index)));
3328
3329 seq_printf(seq, "\tDIEPTSIZ=0x%08x, DOEPTSIZ=0x%08x\n",
3330 readl(regs + DIEPTSIZ(index)),
3331 readl(regs + DOEPTSIZ(index)));
3332
3333 seq_printf(seq, "\n");
3334 seq_printf(seq, "mps %d\n", ep->ep.maxpacket);
3335 seq_printf(seq, "total_data=%ld\n", ep->total_data);
3336
3337 seq_printf(seq, "request list (%p,%p):\n",
3338 ep->queue.next, ep->queue.prev);
3339
3340 spin_lock_irqsave(&hsotg->lock, flags);
3341
3342 list_for_each_entry(req, &ep->queue, queue) {
3343 if (--show_limit < 0) {
3344 seq_printf(seq, "not showing more requests...\n");
3345 break;
3346 }
3347
3348 seq_printf(seq, "%c req %p: %d bytes @%p, ",
3349 req == ep->req ? '*' : ' ',
3350 req, req->req.length, req->req.buf);
3351 seq_printf(seq, "%d done, res %d\n",
3352 req->req.actual, req->req.status);
3353 }
3354
3355 spin_unlock_irqrestore(&hsotg->lock, flags);
3356
3357 return 0;
3358}
3359
3360static int ep_open(struct inode *inode, struct file *file)
3361{
3362 return single_open(file, ep_show, inode->i_private);
3363}
3364
3365static const struct file_operations ep_fops = {
3366 .owner = THIS_MODULE,
3367 .open = ep_open,
3368 .read = seq_read,
3369 .llseek = seq_lseek,
3370 .release = single_release,
3371};
3372
3373
3374
3375
3376
3377
3378
3379
3380
3381
3382static void s3c_hsotg_create_debug(struct s3c_hsotg *hsotg)
3383{
3384 struct dentry *root;
3385 unsigned epidx;
3386
3387 root = debugfs_create_dir(dev_name(hsotg->dev), NULL);
3388 hsotg->debug_root = root;
3389 if (IS_ERR(root)) {
3390 dev_err(hsotg->dev, "cannot create debug root\n");
3391 return;
3392 }
3393
3394
3395
3396 hsotg->debug_file = debugfs_create_file("state", 0444, root,
3397 hsotg, &state_fops);
3398
3399 if (IS_ERR(hsotg->debug_file))
3400 dev_err(hsotg->dev, "%s: failed to create state\n", __func__);
3401
3402 hsotg->debug_fifo = debugfs_create_file("fifo", 0444, root,
3403 hsotg, &fifo_fops);
3404
3405 if (IS_ERR(hsotg->debug_fifo))
3406 dev_err(hsotg->dev, "%s: failed to create fifo\n", __func__);
3407
3408
3409
3410 for (epidx = 0; epidx < hsotg->num_of_eps; epidx++) {
3411 struct s3c_hsotg_ep *ep = &hsotg->eps[epidx];
3412
3413 ep->debugfs = debugfs_create_file(ep->name, 0444,
3414 root, ep, &ep_fops);
3415
3416 if (IS_ERR(ep->debugfs))
3417 dev_err(hsotg->dev, "failed to create %s debug file\n",
3418 ep->name);
3419 }
3420}
3421
3422
3423
3424
3425
3426
3427
3428static void s3c_hsotg_delete_debug(struct s3c_hsotg *hsotg)
3429{
3430 unsigned epidx;
3431
3432 for (epidx = 0; epidx < hsotg->num_of_eps; epidx++) {
3433 struct s3c_hsotg_ep *ep = &hsotg->eps[epidx];
3434 debugfs_remove(ep->debugfs);
3435 }
3436
3437 debugfs_remove(hsotg->debug_file);
3438 debugfs_remove(hsotg->debug_fifo);
3439 debugfs_remove(hsotg->debug_root);
3440}
3441
3442
3443
3444
3445
3446
3447static int s3c_hsotg_probe(struct platform_device *pdev)
3448{
3449 struct s3c_hsotg_plat *plat = dev_get_platdata(&pdev->dev);
3450 struct usb_phy *phy;
3451 struct device *dev = &pdev->dev;
3452 struct s3c_hsotg_ep *eps;
3453 struct s3c_hsotg *hsotg;
3454 struct resource *res;
3455 int epnum;
3456 int ret;
3457 int i;
3458
3459 hsotg = devm_kzalloc(&pdev->dev, sizeof(struct s3c_hsotg), GFP_KERNEL);
3460 if (!hsotg) {
3461 dev_err(dev, "cannot get memory\n");
3462 return -ENOMEM;
3463 }
3464
3465 phy = devm_usb_get_phy(dev, USB_PHY_TYPE_USB2);
3466 if (IS_ERR(phy)) {
3467
3468 plat = dev_get_platdata(&pdev->dev);
3469 if (!plat) {
3470 dev_err(&pdev->dev, "no platform data or transceiver defined\n");
3471 return -EPROBE_DEFER;
3472 } else {
3473 hsotg->plat = plat;
3474 }
3475 } else {
3476 hsotg->phy = phy;
3477 }
3478
3479 hsotg->dev = dev;
3480
3481 hsotg->clk = devm_clk_get(&pdev->dev, "otg");
3482 if (IS_ERR(hsotg->clk)) {
3483 dev_err(dev, "cannot get otg clock\n");
3484 return PTR_ERR(hsotg->clk);
3485 }
3486
3487 platform_set_drvdata(pdev, hsotg);
3488
3489 res = platform_get_resource(pdev, IORESOURCE_MEM, 0);
3490
3491 hsotg->regs = devm_ioremap_resource(&pdev->dev, res);
3492 if (IS_ERR(hsotg->regs)) {
3493 ret = PTR_ERR(hsotg->regs);
3494 goto err_clk;
3495 }
3496
3497 ret = platform_get_irq(pdev, 0);
3498 if (ret < 0) {
3499 dev_err(dev, "cannot find IRQ\n");
3500 goto err_clk;
3501 }
3502
3503 spin_lock_init(&hsotg->lock);
3504
3505 hsotg->irq = ret;
3506
3507 ret = devm_request_irq(&pdev->dev, hsotg->irq, s3c_hsotg_irq, 0,
3508 dev_name(dev), hsotg);
3509 if (ret < 0) {
3510 dev_err(dev, "cannot claim IRQ\n");
3511 goto err_clk;
3512 }
3513
3514 dev_info(dev, "regs %p, irq %d\n", hsotg->regs, hsotg->irq);
3515
3516 hsotg->gadget.max_speed = USB_SPEED_HIGH;
3517 hsotg->gadget.ops = &s3c_hsotg_gadget_ops;
3518 hsotg->gadget.name = dev_name(dev);
3519
3520
3521
3522 clk_prepare_enable(hsotg->clk);
3523
3524
3525
3526 for (i = 0; i < ARRAY_SIZE(hsotg->supplies); i++)
3527 hsotg->supplies[i].supply = s3c_hsotg_supply_names[i];
3528
3529 ret = devm_regulator_bulk_get(dev, ARRAY_SIZE(hsotg->supplies),
3530 hsotg->supplies);
3531 if (ret) {
3532 dev_err(dev, "failed to request supplies: %d\n", ret);
3533 goto err_clk;
3534 }
3535
3536 ret = regulator_bulk_enable(ARRAY_SIZE(hsotg->supplies),
3537 hsotg->supplies);
3538
3539 if (ret) {
3540 dev_err(hsotg->dev, "failed to enable supplies: %d\n", ret);
3541 goto err_supplies;
3542 }
3543
3544
3545 s3c_hsotg_phy_enable(hsotg);
3546
3547 s3c_hsotg_corereset(hsotg);
3548 s3c_hsotg_init(hsotg);
3549 s3c_hsotg_hw_cfg(hsotg);
3550
3551
3552
3553 if (hsotg->num_of_eps == 0) {
3554 dev_err(dev, "wrong number of EPs (zero)\n");
3555 ret = -EINVAL;
3556 goto err_supplies;
3557 }
3558
3559 eps = kcalloc(hsotg->num_of_eps + 1, sizeof(struct s3c_hsotg_ep),
3560 GFP_KERNEL);
3561 if (!eps) {
3562 dev_err(dev, "cannot get memory\n");
3563 ret = -ENOMEM;
3564 goto err_supplies;
3565 }
3566
3567 hsotg->eps = eps;
3568
3569
3570
3571 INIT_LIST_HEAD(&hsotg->gadget.ep_list);
3572 hsotg->gadget.ep0 = &hsotg->eps[0].ep;
3573
3574
3575
3576 hsotg->ctrl_req = s3c_hsotg_ep_alloc_request(&hsotg->eps[0].ep,
3577 GFP_KERNEL);
3578 if (!hsotg->ctrl_req) {
3579 dev_err(dev, "failed to allocate ctrl req\n");
3580 ret = -ENOMEM;
3581 goto err_ep_mem;
3582 }
3583
3584
3585 for (epnum = 0; epnum < hsotg->num_of_eps; epnum++)
3586 s3c_hsotg_initep(hsotg, &hsotg->eps[epnum], epnum);
3587
3588
3589
3590 ret = regulator_bulk_disable(ARRAY_SIZE(hsotg->supplies),
3591 hsotg->supplies);
3592 if (ret) {
3593 dev_err(hsotg->dev, "failed to disable supplies: %d\n", ret);
3594 goto err_ep_mem;
3595 }
3596
3597 s3c_hsotg_phy_disable(hsotg);
3598
3599 ret = usb_add_gadget_udc(&pdev->dev, &hsotg->gadget);
3600 if (ret)
3601 goto err_ep_mem;
3602
3603 s3c_hsotg_create_debug(hsotg);
3604
3605 s3c_hsotg_dump(hsotg);
3606
3607 return 0;
3608
3609err_ep_mem:
3610 kfree(eps);
3611err_supplies:
3612 s3c_hsotg_phy_disable(hsotg);
3613err_clk:
3614 clk_disable_unprepare(hsotg->clk);
3615
3616 return ret;
3617}
3618
3619
3620
3621
3622
3623static int s3c_hsotg_remove(struct platform_device *pdev)
3624{
3625 struct s3c_hsotg *hsotg = platform_get_drvdata(pdev);
3626
3627 usb_del_gadget_udc(&hsotg->gadget);
3628
3629 s3c_hsotg_delete_debug(hsotg);
3630
3631 if (hsotg->driver) {
3632
3633 usb_gadget_unregister_driver(hsotg->driver);
3634 }
3635
3636 s3c_hsotg_phy_disable(hsotg);
3637 clk_disable_unprepare(hsotg->clk);
3638
3639 return 0;
3640}
3641
3642#if 1
3643#define s3c_hsotg_suspend NULL
3644#define s3c_hsotg_resume NULL
3645#endif
3646
3647#ifdef CONFIG_OF
3648static const struct of_device_id s3c_hsotg_of_ids[] = {
3649 { .compatible = "samsung,s3c6400-hsotg", },
3650 { }
3651};
3652MODULE_DEVICE_TABLE(of, s3c_hsotg_of_ids);
3653#endif
3654
3655static struct platform_driver s3c_hsotg_driver = {
3656 .driver = {
3657 .name = "s3c-hsotg",
3658 .owner = THIS_MODULE,
3659 .of_match_table = of_match_ptr(s3c_hsotg_of_ids),
3660 },
3661 .probe = s3c_hsotg_probe,
3662 .remove = s3c_hsotg_remove,
3663 .suspend = s3c_hsotg_suspend,
3664 .resume = s3c_hsotg_resume,
3665};
3666
3667module_platform_driver(s3c_hsotg_driver);
3668
3669MODULE_DESCRIPTION("Samsung S3C USB High-speed/OtG device");
3670MODULE_AUTHOR("Ben Dooks <ben@simtec.co.uk>");
3671MODULE_LICENSE("GPL");
3672MODULE_ALIAS("platform:s3c-hsotg");
3673