1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48#include <linux/usb.h>
49#include <linux/slab.h>
50#include <linux/module.h>
51#include <linux/usb/hcd.h>
52#include <linux/prefetch.h>
53#include <linux/dma-mapping.h>
54#include <linux/platform_device.h>
55
56#include <asm/octeon/octeon.h>
57
58#include "octeon-hcd.h"
59
60
61
62
63
64
65
66
67enum cvmx_usb_speed {
68 CVMX_USB_SPEED_HIGH = 0,
69 CVMX_USB_SPEED_FULL = 1,
70 CVMX_USB_SPEED_LOW = 2,
71};
72
73
74
75
76
77
78
79
80
81
82
83
84
85enum cvmx_usb_transfer {
86 CVMX_USB_TRANSFER_CONTROL = 0,
87 CVMX_USB_TRANSFER_ISOCHRONOUS = 1,
88 CVMX_USB_TRANSFER_BULK = 2,
89 CVMX_USB_TRANSFER_INTERRUPT = 3,
90};
91
92
93
94
95
96
97
98enum cvmx_usb_direction {
99 CVMX_USB_DIRECTION_OUT,
100 CVMX_USB_DIRECTION_IN,
101};
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123enum cvmx_usb_status {
124 CVMX_USB_STATUS_OK,
125 CVMX_USB_STATUS_SHORT,
126 CVMX_USB_STATUS_CANCEL,
127 CVMX_USB_STATUS_ERROR,
128 CVMX_USB_STATUS_STALL,
129 CVMX_USB_STATUS_XACTERR,
130 CVMX_USB_STATUS_DATATGLERR,
131 CVMX_USB_STATUS_BABBLEERR,
132 CVMX_USB_STATUS_FRAMEERR,
133};
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150struct cvmx_usb_port_status {
151 u32 reserved : 25;
152 u32 port_enabled : 1;
153 u32 port_over_current : 1;
154 u32 port_powered : 1;
155 enum cvmx_usb_speed port_speed : 2;
156 u32 connected : 1;
157 u32 connect_change : 1;
158};
159
160
161
162
163
164
165
166
167
168struct cvmx_usb_iso_packet {
169 int offset;
170 int length;
171 enum cvmx_usb_status status;
172};
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191enum cvmx_usb_initialize_flags {
192 CVMX_USB_INITIALIZE_FLAGS_CLOCK_XO_XI = 1 << 0,
193 CVMX_USB_INITIALIZE_FLAGS_CLOCK_XO_GND = 1 << 1,
194 CVMX_USB_INITIALIZE_FLAGS_CLOCK_MHZ_MASK = 3 << 3,
195 CVMX_USB_INITIALIZE_FLAGS_CLOCK_12MHZ = 1 << 3,
196 CVMX_USB_INITIALIZE_FLAGS_CLOCK_24MHZ = 2 << 3,
197 CVMX_USB_INITIALIZE_FLAGS_CLOCK_48MHZ = 3 << 3,
198
199 CVMX_USB_INITIALIZE_FLAGS_NO_DMA = 1 << 5,
200};
201
202
203
204
205
206
207
208
209
210enum cvmx_usb_pipe_flags {
211 CVMX_USB_PIPE_FLAGS_SCHEDULED = 1 << 17,
212 CVMX_USB_PIPE_FLAGS_NEED_PING = 1 << 18,
213};
214
215
216#define MAX_RETRIES 3
217
218
219#define MAX_CHANNELS 8
220
221
222
223
224
225#define MAX_TRANSFER_BYTES ((1 << 19) - 1)
226
227
228
229
230
231#define MAX_TRANSFER_PACKETS ((1 << 10) - 1)
232
233
234
235
236
237
238
239
240
241enum cvmx_usb_stage {
242 CVMX_USB_STAGE_NON_CONTROL,
243 CVMX_USB_STAGE_NON_CONTROL_SPLIT_COMPLETE,
244 CVMX_USB_STAGE_SETUP,
245 CVMX_USB_STAGE_SETUP_SPLIT_COMPLETE,
246 CVMX_USB_STAGE_DATA,
247 CVMX_USB_STAGE_DATA_SPLIT_COMPLETE,
248 CVMX_USB_STAGE_STATUS,
249 CVMX_USB_STAGE_STATUS_SPLIT_COMPLETE,
250};
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272struct cvmx_usb_transaction {
273 struct list_head node;
274 enum cvmx_usb_transfer type;
275 u64 buffer;
276 int buffer_length;
277 u64 control_header;
278 int iso_start_frame;
279 int iso_number_packets;
280 struct cvmx_usb_iso_packet *iso_packets;
281 int xfersize;
282 int pktcnt;
283 int retries;
284 int actual_bytes;
285 enum cvmx_usb_stage stage;
286 struct urb *urb;
287};
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316struct cvmx_usb_pipe {
317 struct list_head node;
318 struct list_head transactions;
319 u64 interval;
320 u64 next_tx_frame;
321 enum cvmx_usb_pipe_flags flags;
322 enum cvmx_usb_speed device_speed;
323 enum cvmx_usb_transfer transfer_type;
324 enum cvmx_usb_direction transfer_dir;
325 int multi_count;
326 u16 max_packet;
327 u8 device_addr;
328 u8 endpoint_num;
329 u8 hub_device_addr;
330 u8 hub_port;
331 u8 pid_toggle;
332 u8 channel;
333 s8 split_sc_frame;
334};
335
336struct cvmx_usb_tx_fifo {
337 struct {
338 int channel;
339 int size;
340 u64 address;
341 } entry[MAX_CHANNELS + 1];
342 int head;
343 int tail;
344};
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364struct octeon_hcd {
365 spinlock_t lock;
366 int init_flags;
367 int index;
368 int idle_hardware_channels;
369 union cvmx_usbcx_hprt usbcx_hprt;
370 struct cvmx_usb_pipe *pipe_for_channel[MAX_CHANNELS];
371 int indent;
372 struct cvmx_usb_port_status port_status;
373 struct list_head idle_pipes;
374 struct list_head active_pipes[4];
375 u64 frame_number;
376 struct cvmx_usb_transaction *active_split;
377 struct cvmx_usb_tx_fifo periodic;
378 struct cvmx_usb_tx_fifo nonperiodic;
379};
380
381
382
383
384
385#define USB_SET_FIELD32(address, _union, field, value) \
386 do { \
387 union _union c; \
388 \
389 c.u32 = cvmx_usb_read_csr32(usb, address); \
390 c.s.field = value; \
391 cvmx_usb_write_csr32(usb, address, c.u32); \
392 } while (0)
393
394
395#define USB_FIFO_ADDRESS(channel, usb_index) \
396 (CVMX_USBCX_GOTGCTL(usb_index) + ((channel) + 1) * 0x1000)
397
398
399
400
401
402
403
404
405
406
407struct octeon_temp_buffer {
408 void *orig_buffer;
409 u8 data[];
410};
411
412static inline struct usb_hcd *octeon_to_hcd(struct octeon_hcd *p)
413{
414 return container_of((void *)p, struct usb_hcd, hcd_priv);
415}
416
417
418
419
420
421
422
423
424
425
426static int octeon_alloc_temp_buffer(struct urb *urb, gfp_t mem_flags)
427{
428 struct octeon_temp_buffer *temp;
429
430 if (urb->num_sgs || urb->sg ||
431 (urb->transfer_flags & URB_NO_TRANSFER_DMA_MAP) ||
432 !(urb->transfer_buffer_length % sizeof(u32)))
433 return 0;
434
435 temp = kmalloc(ALIGN(urb->transfer_buffer_length, sizeof(u32)) +
436 sizeof(*temp), mem_flags);
437 if (!temp)
438 return -ENOMEM;
439
440 temp->orig_buffer = urb->transfer_buffer;
441 if (usb_urb_dir_out(urb))
442 memcpy(temp->data, urb->transfer_buffer,
443 urb->transfer_buffer_length);
444 urb->transfer_buffer = temp->data;
445 urb->transfer_flags |= URB_ALIGNED_TEMP_BUFFER;
446
447 return 0;
448}
449
450
451
452
453
454
455
456static void octeon_free_temp_buffer(struct urb *urb)
457{
458 struct octeon_temp_buffer *temp;
459 size_t length;
460
461 if (!(urb->transfer_flags & URB_ALIGNED_TEMP_BUFFER))
462 return;
463
464 temp = container_of(urb->transfer_buffer, struct octeon_temp_buffer,
465 data);
466 if (usb_urb_dir_in(urb)) {
467 if (usb_pipeisoc(urb->pipe))
468 length = urb->transfer_buffer_length;
469 else
470 length = urb->actual_length;
471
472 memcpy(temp->orig_buffer, urb->transfer_buffer, length);
473 }
474 urb->transfer_buffer = temp->orig_buffer;
475 urb->transfer_flags &= ~URB_ALIGNED_TEMP_BUFFER;
476 kfree(temp);
477}
478
479
480
481
482
483
484
485static int octeon_map_urb_for_dma(struct usb_hcd *hcd, struct urb *urb,
486 gfp_t mem_flags)
487{
488 int ret;
489
490 ret = octeon_alloc_temp_buffer(urb, mem_flags);
491 if (ret)
492 return ret;
493
494 ret = usb_hcd_map_urb_for_dma(hcd, urb, mem_flags);
495 if (ret)
496 octeon_free_temp_buffer(urb);
497
498 return ret;
499}
500
501
502
503
504
505
506static void octeon_unmap_urb_for_dma(struct usb_hcd *hcd, struct urb *urb)
507{
508 usb_hcd_unmap_urb_for_dma(hcd, urb);
509 octeon_free_temp_buffer(urb);
510}
511
512
513
514
515
516
517
518
519
520
521
522static inline u32 cvmx_usb_read_csr32(struct octeon_hcd *usb, u64 address)
523{
524 return cvmx_read64_uint32(address ^ 4);
525}
526
527
528
529
530
531
532
533
534
535
536static inline void cvmx_usb_write_csr32(struct octeon_hcd *usb,
537 u64 address, u32 value)
538{
539 cvmx_write64_uint32(address ^ 4, value);
540 cvmx_read64_uint64(CVMX_USBNX_DMA0_INB_CHN0(usb->index));
541}
542
543
544
545
546
547
548
549
550
551
552static inline int cvmx_usb_pipe_needs_split(struct octeon_hcd *usb,
553 struct cvmx_usb_pipe *pipe)
554{
555 return pipe->device_speed != CVMX_USB_SPEED_HIGH &&
556 usb->usbcx_hprt.s.prtspd == CVMX_USB_SPEED_HIGH;
557}
558
559
560
561
562
563
564
565
566static inline int cvmx_usb_get_data_pid(struct cvmx_usb_pipe *pipe)
567{
568 if (pipe->pid_toggle)
569 return 2;
570 return 0;
571}
572
573
574static int cvmx_wait_tx_rx(struct octeon_hcd *usb, int fflsh_type)
575{
576 int result;
577 u64 address = CVMX_USBCX_GRSTCTL(usb->index);
578 u64 done = cvmx_get_cycle() + 100 *
579 (u64)octeon_get_clock_rate / 1000000;
580 union cvmx_usbcx_grstctl c;
581
582 while (1) {
583 c.u32 = cvmx_usb_read_csr32(usb, address);
584 if (fflsh_type == 0 && c.s.txfflsh == 0) {
585 result = 0;
586 break;
587 } else if (fflsh_type == 1 && c.s.rxfflsh == 0) {
588 result = 0;
589 break;
590 } else if (cvmx_get_cycle() > done) {
591 result = -1;
592 break;
593 }
594
595 __delay(100);
596 }
597 return result;
598}
599
600static void cvmx_fifo_setup(struct octeon_hcd *usb)
601{
602 union cvmx_usbcx_ghwcfg3 usbcx_ghwcfg3;
603 union cvmx_usbcx_gnptxfsiz npsiz;
604 union cvmx_usbcx_hptxfsiz psiz;
605
606 usbcx_ghwcfg3.u32 = cvmx_usb_read_csr32(usb,
607 CVMX_USBCX_GHWCFG3(usb->index));
608
609
610
611
612
613 USB_SET_FIELD32(CVMX_USBCX_GRXFSIZ(usb->index), cvmx_usbcx_grxfsiz,
614 rxfdep, usbcx_ghwcfg3.s.dfifodepth / 4);
615
616
617
618
619
620
621 npsiz.u32 = cvmx_usb_read_csr32(usb, CVMX_USBCX_GNPTXFSIZ(usb->index));
622 npsiz.s.nptxfdep = usbcx_ghwcfg3.s.dfifodepth / 2;
623 npsiz.s.nptxfstaddr = usbcx_ghwcfg3.s.dfifodepth / 4;
624 cvmx_usb_write_csr32(usb, CVMX_USBCX_GNPTXFSIZ(usb->index), npsiz.u32);
625
626
627
628
629
630
631 psiz.u32 = cvmx_usb_read_csr32(usb, CVMX_USBCX_HPTXFSIZ(usb->index));
632 psiz.s.ptxfsize = usbcx_ghwcfg3.s.dfifodepth / 4;
633 psiz.s.ptxfstaddr = 3 * usbcx_ghwcfg3.s.dfifodepth / 4;
634 cvmx_usb_write_csr32(usb, CVMX_USBCX_HPTXFSIZ(usb->index), psiz.u32);
635
636
637 USB_SET_FIELD32(CVMX_USBCX_GRSTCTL(usb->index),
638 cvmx_usbcx_grstctl, txfnum, 0x10);
639 USB_SET_FIELD32(CVMX_USBCX_GRSTCTL(usb->index),
640 cvmx_usbcx_grstctl, txfflsh, 1);
641 cvmx_wait_tx_rx(usb, 0);
642 USB_SET_FIELD32(CVMX_USBCX_GRSTCTL(usb->index),
643 cvmx_usbcx_grstctl, rxfflsh, 1);
644 cvmx_wait_tx_rx(usb, 1);
645}
646
647
648
649
650
651
652
653
654
655
656static int cvmx_usb_shutdown(struct octeon_hcd *usb)
657{
658 union cvmx_usbnx_clk_ctl usbn_clk_ctl;
659
660
661 if (!list_empty(&usb->idle_pipes) ||
662 !list_empty(&usb->active_pipes[CVMX_USB_TRANSFER_ISOCHRONOUS]) ||
663 !list_empty(&usb->active_pipes[CVMX_USB_TRANSFER_INTERRUPT]) ||
664 !list_empty(&usb->active_pipes[CVMX_USB_TRANSFER_CONTROL]) ||
665 !list_empty(&usb->active_pipes[CVMX_USB_TRANSFER_BULK]))
666 return -EBUSY;
667
668
669 usbn_clk_ctl.u64 = cvmx_read64_uint64(CVMX_USBNX_CLK_CTL(usb->index));
670 usbn_clk_ctl.s.enable = 1;
671 usbn_clk_ctl.s.por = 1;
672 usbn_clk_ctl.s.hclk_rst = 1;
673 usbn_clk_ctl.s.prst = 0;
674 usbn_clk_ctl.s.hrst = 0;
675 cvmx_write64_uint64(CVMX_USBNX_CLK_CTL(usb->index), usbn_clk_ctl.u64);
676 return 0;
677}
678
679
680
681
682
683
684
685
686
687
688
689static int cvmx_usb_initialize(struct device *dev,
690 struct octeon_hcd *usb)
691{
692 int channel;
693 int divisor;
694 int retries = 0;
695 union cvmx_usbcx_hcfg usbcx_hcfg;
696 union cvmx_usbnx_clk_ctl usbn_clk_ctl;
697 union cvmx_usbcx_gintsts usbc_gintsts;
698 union cvmx_usbcx_gahbcfg usbcx_gahbcfg;
699 union cvmx_usbcx_gintmsk usbcx_gintmsk;
700 union cvmx_usbcx_gusbcfg usbcx_gusbcfg;
701 union cvmx_usbnx_usbp_ctl_status usbn_usbp_ctl_status;
702
703retry:
704
705
706
707
708
709
710
711
712 usbn_clk_ctl.u64 = cvmx_read64_uint64(CVMX_USBNX_CLK_CTL(usb->index));
713 usbn_clk_ctl.s.por = 1;
714 usbn_clk_ctl.s.hrst = 0;
715 usbn_clk_ctl.s.prst = 0;
716 usbn_clk_ctl.s.hclk_rst = 0;
717 usbn_clk_ctl.s.enable = 0;
718
719
720
721
722 if (usb->init_flags & CVMX_USB_INITIALIZE_FLAGS_CLOCK_XO_GND) {
723
724
725
726
727
728 if (OCTEON_IS_MODEL(OCTEON_CN3XXX) ||
729 OCTEON_IS_MODEL(OCTEON_CN56XX) ||
730 OCTEON_IS_MODEL(OCTEON_CN50XX))
731
732 usbn_clk_ctl.s.p_rtype = 2;
733 else
734
735 usbn_clk_ctl.s.p_rtype = 1;
736
737 switch (usb->init_flags &
738 CVMX_USB_INITIALIZE_FLAGS_CLOCK_MHZ_MASK) {
739 case CVMX_USB_INITIALIZE_FLAGS_CLOCK_12MHZ:
740 usbn_clk_ctl.s.p_c_sel = 0;
741 break;
742 case CVMX_USB_INITIALIZE_FLAGS_CLOCK_24MHZ:
743 usbn_clk_ctl.s.p_c_sel = 1;
744 break;
745 case CVMX_USB_INITIALIZE_FLAGS_CLOCK_48MHZ:
746 usbn_clk_ctl.s.p_c_sel = 2;
747 break;
748 }
749 } else {
750
751
752
753
754 if (OCTEON_IS_MODEL(OCTEON_CN3XXX))
755
756 usbn_clk_ctl.s.p_rtype = 3;
757 else
758
759 usbn_clk_ctl.s.p_rtype = 0;
760
761 usbn_clk_ctl.s.p_c_sel = 0;
762 }
763
764
765
766
767
768 divisor = DIV_ROUND_UP(octeon_get_clock_rate(), 125000000);
769
770 if (divisor < 4)
771 divisor = 4;
772 usbn_clk_ctl.s.divide = divisor;
773 usbn_clk_ctl.s.divide2 = 0;
774 cvmx_write64_uint64(CVMX_USBNX_CLK_CTL(usb->index), usbn_clk_ctl.u64);
775
776
777 usbn_clk_ctl.s.hclk_rst = 1;
778 cvmx_write64_uint64(CVMX_USBNX_CLK_CTL(usb->index), usbn_clk_ctl.u64);
779
780 __delay(64);
781
782
783
784
785
786 usbn_clk_ctl.s.por = 0;
787 cvmx_write64_uint64(CVMX_USBNX_CLK_CTL(usb->index), usbn_clk_ctl.u64);
788
789 mdelay(1);
790
791
792
793
794
795 usbn_usbp_ctl_status.u64 =
796 cvmx_read64_uint64(CVMX_USBNX_USBP_CTL_STATUS(usb->index));
797 usbn_usbp_ctl_status.s.ate_reset = 1;
798 cvmx_write64_uint64(CVMX_USBNX_USBP_CTL_STATUS(usb->index),
799 usbn_usbp_ctl_status.u64);
800
801 __delay(10);
802
803
804
805
806 usbn_usbp_ctl_status.s.ate_reset = 0;
807 cvmx_write64_uint64(CVMX_USBNX_USBP_CTL_STATUS(usb->index),
808 usbn_usbp_ctl_status.u64);
809
810
811
812
813 usbn_clk_ctl.s.prst = 1;
814 cvmx_write64_uint64(CVMX_USBNX_CLK_CTL(usb->index), usbn_clk_ctl.u64);
815
816
817
818
819
820 usbn_usbp_ctl_status.s.hst_mode = 0;
821 cvmx_write64_uint64(CVMX_USBNX_USBP_CTL_STATUS(usb->index),
822 usbn_usbp_ctl_status.u64);
823
824 udelay(1);
825
826
827
828
829 usbn_clk_ctl.s.hrst = 1;
830 cvmx_write64_uint64(CVMX_USBNX_CLK_CTL(usb->index), usbn_clk_ctl.u64);
831
832 usbn_clk_ctl.s.enable = 1;
833 cvmx_write64_uint64(CVMX_USBNX_CLK_CTL(usb->index), usbn_clk_ctl.u64);
834 udelay(1);
835
836
837
838
839
840
841
842
843
844
845
846
847
848
849
850
851
852
853
854 usbcx_gahbcfg.u32 = 0;
855 usbcx_gahbcfg.s.dmaen = !(usb->init_flags &
856 CVMX_USB_INITIALIZE_FLAGS_NO_DMA);
857 usbcx_gahbcfg.s.hbstlen = 0;
858 usbcx_gahbcfg.s.nptxfemplvl = 1;
859 usbcx_gahbcfg.s.ptxfemplvl = 1;
860 usbcx_gahbcfg.s.glblintrmsk = 1;
861 cvmx_usb_write_csr32(usb, CVMX_USBCX_GAHBCFG(usb->index),
862 usbcx_gahbcfg.u32);
863
864
865
866
867
868
869
870
871 usbcx_gusbcfg.u32 = cvmx_usb_read_csr32(usb,
872 CVMX_USBCX_GUSBCFG(usb->index));
873 usbcx_gusbcfg.s.toutcal = 0;
874 usbcx_gusbcfg.s.ddrsel = 0;
875 usbcx_gusbcfg.s.usbtrdtim = 0x5;
876 usbcx_gusbcfg.s.phylpwrclksel = 0;
877 cvmx_usb_write_csr32(usb, CVMX_USBCX_GUSBCFG(usb->index),
878 usbcx_gusbcfg.u32);
879
880
881
882
883
884
885
886 usbcx_gintmsk.u32 = cvmx_usb_read_csr32(usb,
887 CVMX_USBCX_GINTMSK(usb->index));
888 usbcx_gintmsk.s.otgintmsk = 1;
889 usbcx_gintmsk.s.modemismsk = 1;
890 usbcx_gintmsk.s.hchintmsk = 1;
891 usbcx_gintmsk.s.sofmsk = 0;
892
893 if (usb->init_flags & CVMX_USB_INITIALIZE_FLAGS_NO_DMA)
894 usbcx_gintmsk.s.rxflvlmsk = 1;
895 cvmx_usb_write_csr32(usb, CVMX_USBCX_GINTMSK(usb->index),
896 usbcx_gintmsk.u32);
897
898
899
900
901 for (channel = 0; channel < 8; channel++)
902 cvmx_usb_write_csr32(usb,
903 CVMX_USBCX_HCINTMSKX(channel, usb->index),
904 0);
905
906
907
908
909
910
911
912 USB_SET_FIELD32(CVMX_USBCX_GINTMSK(usb->index),
913 cvmx_usbcx_gintmsk, prtintmsk, 1);
914 USB_SET_FIELD32(CVMX_USBCX_GINTMSK(usb->index),
915 cvmx_usbcx_gintmsk, disconnintmsk, 1);
916
917
918
919
920
921 usbcx_hcfg.u32 = cvmx_usb_read_csr32(usb, CVMX_USBCX_HCFG(usb->index));
922 usbcx_hcfg.s.fslssupp = 0;
923 usbcx_hcfg.s.fslspclksel = 0;
924 cvmx_usb_write_csr32(usb, CVMX_USBCX_HCFG(usb->index), usbcx_hcfg.u32);
925
926 cvmx_fifo_setup(usb);
927
928
929
930
931
932
933 usbc_gintsts.u32 = cvmx_usb_read_csr32(usb,
934 CVMX_USBCX_GINTSTS(usb->index));
935 cvmx_usb_write_csr32(usb, CVMX_USBCX_GINTSTS(usb->index),
936 usbc_gintsts.u32);
937 dev_dbg(dev, "gintsts after reset: 0x%x\n", (int)usbc_gintsts.u32);
938 if (!usbc_gintsts.s.disconnint && !usbc_gintsts.s.prtint)
939 return 0;
940 if (retries++ >= 5)
941 return -EAGAIN;
942 dev_info(dev, "controller reset failed (gintsts=0x%x) - retrying\n",
943 (int)usbc_gintsts.u32);
944 msleep(50);
945 cvmx_usb_shutdown(usb);
946 msleep(50);
947 goto retry;
948}
949
950
951
952
953
954
955
956static void cvmx_usb_reset_port(struct octeon_hcd *usb)
957{
958 usb->usbcx_hprt.u32 = cvmx_usb_read_csr32(usb,
959 CVMX_USBCX_HPRT(usb->index));
960
961
962 USB_SET_FIELD32(CVMX_USBCX_HPRT(usb->index), cvmx_usbcx_hprt,
963 prtrst, 1);
964
965
966
967
968
969 mdelay(50);
970
971
972 USB_SET_FIELD32(CVMX_USBCX_HPRT(usb->index), cvmx_usbcx_hprt,
973 prtrst, 0);
974
975
976
977
978
979 usb->usbcx_hprt.u32 = cvmx_usb_read_csr32(usb,
980 CVMX_USBCX_HPRT(usb->index));
981}
982
983
984
985
986
987
988
989
990
991
992
993static int cvmx_usb_disable(struct octeon_hcd *usb)
994{
995
996 USB_SET_FIELD32(CVMX_USBCX_HPRT(usb->index), cvmx_usbcx_hprt,
997 prtena, 1);
998 return 0;
999}
1000
1001
1002
1003
1004
1005
1006
1007
1008
1009
1010
1011
1012static struct cvmx_usb_port_status cvmx_usb_get_status(struct octeon_hcd *usb)
1013{
1014 union cvmx_usbcx_hprt usbc_hprt;
1015 struct cvmx_usb_port_status result;
1016
1017 memset(&result, 0, sizeof(result));
1018
1019 usbc_hprt.u32 = cvmx_usb_read_csr32(usb, CVMX_USBCX_HPRT(usb->index));
1020 result.port_enabled = usbc_hprt.s.prtena;
1021 result.port_over_current = usbc_hprt.s.prtovrcurract;
1022 result.port_powered = usbc_hprt.s.prtpwr;
1023 result.port_speed = usbc_hprt.s.prtspd;
1024 result.connected = usbc_hprt.s.prtconnsts;
1025 result.connect_change =
1026 result.connected != usb->port_status.connected;
1027
1028 return result;
1029}
1030
1031
1032
1033
1034
1035
1036
1037
1038
1039
1040
1041
1042
1043
1044
1045
1046
1047
1048
1049
1050
1051
1052
1053
1054
1055
1056
1057
1058
1059
1060
1061
1062
1063
1064
1065
1066
1067
1068
1069
1070
1071
1072
1073
1074
1075
1076
1077
1078
1079
1080
1081
1082
1083static struct cvmx_usb_pipe *cvmx_usb_open_pipe(struct octeon_hcd *usb,
1084 int device_addr,
1085 int endpoint_num,
1086 enum cvmx_usb_speed
1087 device_speed,
1088 int max_packet,
1089 enum cvmx_usb_transfer
1090 transfer_type,
1091 enum cvmx_usb_direction
1092 transfer_dir,
1093 int interval, int multi_count,
1094 int hub_device_addr,
1095 int hub_port)
1096{
1097 struct cvmx_usb_pipe *pipe;
1098
1099 pipe = kzalloc(sizeof(*pipe), GFP_ATOMIC);
1100 if (!pipe)
1101 return NULL;
1102 if ((device_speed == CVMX_USB_SPEED_HIGH) &&
1103 (transfer_dir == CVMX_USB_DIRECTION_OUT) &&
1104 (transfer_type == CVMX_USB_TRANSFER_BULK))
1105 pipe->flags |= CVMX_USB_PIPE_FLAGS_NEED_PING;
1106 pipe->device_addr = device_addr;
1107 pipe->endpoint_num = endpoint_num;
1108 pipe->device_speed = device_speed;
1109 pipe->max_packet = max_packet;
1110 pipe->transfer_type = transfer_type;
1111 pipe->transfer_dir = transfer_dir;
1112 INIT_LIST_HEAD(&pipe->transactions);
1113
1114
1115
1116
1117
1118 if (!interval)
1119 interval = 1;
1120 if (cvmx_usb_pipe_needs_split(usb, pipe)) {
1121 pipe->interval = interval * 8;
1122
1123 pipe->next_tx_frame = ((usb->frame_number + 7) & ~7) +
1124 pipe->interval;
1125 } else {
1126 pipe->interval = interval;
1127 pipe->next_tx_frame = usb->frame_number + pipe->interval;
1128 }
1129 pipe->multi_count = multi_count;
1130 pipe->hub_device_addr = hub_device_addr;
1131 pipe->hub_port = hub_port;
1132 pipe->pid_toggle = 0;
1133 pipe->split_sc_frame = -1;
1134 list_add_tail(&pipe->node, &usb->idle_pipes);
1135
1136
1137
1138
1139
1140
1141 return pipe;
1142}
1143
1144
1145
1146
1147
1148
1149
1150
1151static void cvmx_usb_poll_rx_fifo(struct octeon_hcd *usb)
1152{
1153 union cvmx_usbcx_grxstsph rx_status;
1154 int channel;
1155 int bytes;
1156 u64 address;
1157 u32 *ptr;
1158
1159 rx_status.u32 = cvmx_usb_read_csr32(usb,
1160 CVMX_USBCX_GRXSTSPH(usb->index));
1161
1162 if (rx_status.s.pktsts != 2)
1163 return;
1164
1165 if (!rx_status.s.bcnt)
1166 return;
1167
1168 channel = rx_status.s.chnum;
1169 bytes = rx_status.s.bcnt;
1170 if (!bytes)
1171 return;
1172
1173
1174 address = cvmx_read64_uint64(CVMX_USBNX_DMA0_INB_CHN0(usb->index) +
1175 channel * 8);
1176
1177 ptr = cvmx_phys_to_ptr(address);
1178 cvmx_write64_uint64(CVMX_USBNX_DMA0_INB_CHN0(usb->index) + channel * 8,
1179 address + bytes);
1180
1181
1182 while (bytes > 0) {
1183 *ptr++ = cvmx_usb_read_csr32(usb,
1184 USB_FIFO_ADDRESS(channel, usb->index));
1185 bytes -= 4;
1186 }
1187 CVMX_SYNCW;
1188}
1189
1190
1191
1192
1193
1194
1195
1196
1197
1198
1199
1200
1201static int cvmx_usb_fill_tx_hw(struct octeon_hcd *usb,
1202 struct cvmx_usb_tx_fifo *fifo, int available)
1203{
1204
1205
1206
1207
1208 while (available && (fifo->head != fifo->tail)) {
1209 int i = fifo->tail;
1210 const u32 *ptr = cvmx_phys_to_ptr(fifo->entry[i].address);
1211 u64 csr_address = USB_FIFO_ADDRESS(fifo->entry[i].channel,
1212 usb->index) ^ 4;
1213 int words = available;
1214
1215
1216 if (fifo->entry[i].size <= available) {
1217 words = fifo->entry[i].size;
1218 fifo->tail++;
1219 if (fifo->tail > MAX_CHANNELS)
1220 fifo->tail = 0;
1221 }
1222
1223
1224 available -= words;
1225 fifo->entry[i].address += words * 4;
1226 fifo->entry[i].size -= words;
1227
1228
1229
1230
1231
1232 while (words > 3) {
1233 cvmx_write64_uint32(csr_address, *ptr++);
1234 cvmx_write64_uint32(csr_address, *ptr++);
1235 cvmx_write64_uint32(csr_address, *ptr++);
1236 cvmx_read64_uint64(
1237 CVMX_USBNX_DMA0_INB_CHN0(usb->index));
1238 words -= 3;
1239 }
1240 cvmx_write64_uint32(csr_address, *ptr++);
1241 if (--words) {
1242 cvmx_write64_uint32(csr_address, *ptr++);
1243 if (--words)
1244 cvmx_write64_uint32(csr_address, *ptr++);
1245 }
1246 cvmx_read64_uint64(CVMX_USBNX_DMA0_INB_CHN0(usb->index));
1247 }
1248 return fifo->head != fifo->tail;
1249}
1250
1251
1252
1253
1254
1255
1256static void cvmx_usb_poll_tx_fifo(struct octeon_hcd *usb)
1257{
1258 if (usb->periodic.head != usb->periodic.tail) {
1259 union cvmx_usbcx_hptxsts tx_status;
1260
1261 tx_status.u32 = cvmx_usb_read_csr32(usb,
1262 CVMX_USBCX_HPTXSTS(usb->index));
1263 if (cvmx_usb_fill_tx_hw(usb, &usb->periodic,
1264 tx_status.s.ptxfspcavail))
1265 USB_SET_FIELD32(CVMX_USBCX_GINTMSK(usb->index),
1266 cvmx_usbcx_gintmsk, ptxfempmsk, 1);
1267 else
1268 USB_SET_FIELD32(CVMX_USBCX_GINTMSK(usb->index),
1269 cvmx_usbcx_gintmsk, ptxfempmsk, 0);
1270 }
1271
1272 if (usb->nonperiodic.head != usb->nonperiodic.tail) {
1273 union cvmx_usbcx_gnptxsts tx_status;
1274
1275 tx_status.u32 = cvmx_usb_read_csr32(usb,
1276 CVMX_USBCX_GNPTXSTS(usb->index));
1277 if (cvmx_usb_fill_tx_hw(usb, &usb->nonperiodic,
1278 tx_status.s.nptxfspcavail))
1279 USB_SET_FIELD32(CVMX_USBCX_GINTMSK(usb->index),
1280 cvmx_usbcx_gintmsk, nptxfempmsk, 1);
1281 else
1282 USB_SET_FIELD32(CVMX_USBCX_GINTMSK(usb->index),
1283 cvmx_usbcx_gintmsk, nptxfempmsk, 0);
1284 }
1285}
1286
1287
1288
1289
1290
1291
1292
1293static void cvmx_usb_fill_tx_fifo(struct octeon_hcd *usb, int channel)
1294{
1295 union cvmx_usbcx_hccharx hcchar;
1296 union cvmx_usbcx_hcspltx usbc_hcsplt;
1297 union cvmx_usbcx_hctsizx usbc_hctsiz;
1298 struct cvmx_usb_tx_fifo *fifo;
1299
1300
1301 hcchar.u32 = cvmx_usb_read_csr32(usb,
1302 CVMX_USBCX_HCCHARX(channel, usb->index));
1303 if (hcchar.s.epdir != CVMX_USB_DIRECTION_OUT)
1304 return;
1305
1306
1307 usbc_hcsplt.u32 = cvmx_usb_read_csr32(usb,
1308 CVMX_USBCX_HCSPLTX(channel, usb->index));
1309 if (usbc_hcsplt.s.spltena && usbc_hcsplt.s.compsplt)
1310 return;
1311
1312
1313
1314
1315
1316 usbc_hctsiz.u32 = cvmx_usb_read_csr32(usb,
1317 CVMX_USBCX_HCTSIZX(channel, usb->index));
1318 if (!usbc_hctsiz.s.xfersize)
1319 return;
1320
1321 if ((hcchar.s.eptype == CVMX_USB_TRANSFER_INTERRUPT) ||
1322 (hcchar.s.eptype == CVMX_USB_TRANSFER_ISOCHRONOUS))
1323 fifo = &usb->periodic;
1324 else
1325 fifo = &usb->nonperiodic;
1326
1327 fifo->entry[fifo->head].channel = channel;
1328 fifo->entry[fifo->head].address =
1329 cvmx_read64_uint64(CVMX_USBNX_DMA0_OUTB_CHN0(usb->index) +
1330 channel * 8);
1331 fifo->entry[fifo->head].size = (usbc_hctsiz.s.xfersize + 3) >> 2;
1332 fifo->head++;
1333 if (fifo->head > MAX_CHANNELS)
1334 fifo->head = 0;
1335
1336 cvmx_usb_poll_tx_fifo(usb);
1337}
1338
1339
1340
1341
1342
1343
1344
1345
1346
1347static void cvmx_usb_start_channel_control(struct octeon_hcd *usb,
1348 int channel,
1349 struct cvmx_usb_pipe *pipe)
1350{
1351 struct usb_hcd *hcd = octeon_to_hcd(usb);
1352 struct device *dev = hcd->self.controller;
1353 struct cvmx_usb_transaction *transaction =
1354 list_first_entry(&pipe->transactions, typeof(*transaction),
1355 node);
1356 struct usb_ctrlrequest *header =
1357 cvmx_phys_to_ptr(transaction->control_header);
1358 int bytes_to_transfer = transaction->buffer_length -
1359 transaction->actual_bytes;
1360 int packets_to_transfer;
1361 union cvmx_usbcx_hctsizx usbc_hctsiz;
1362
1363 usbc_hctsiz.u32 = cvmx_usb_read_csr32(usb,
1364 CVMX_USBCX_HCTSIZX(channel, usb->index));
1365
1366 switch (transaction->stage) {
1367 case CVMX_USB_STAGE_NON_CONTROL:
1368 case CVMX_USB_STAGE_NON_CONTROL_SPLIT_COMPLETE:
1369 dev_err(dev, "%s: ERROR - Non control stage\n", __func__);
1370 break;
1371 case CVMX_USB_STAGE_SETUP:
1372 usbc_hctsiz.s.pid = 3;
1373 bytes_to_transfer = sizeof(*header);
1374
1375 USB_SET_FIELD32(CVMX_USBCX_HCCHARX(channel, usb->index),
1376 cvmx_usbcx_hccharx, epdir,
1377 CVMX_USB_DIRECTION_OUT);
1378
1379
1380
1381
1382 cvmx_write64_uint64(CVMX_USBNX_DMA0_OUTB_CHN0(usb->index) +
1383 channel * 8,
1384 transaction->control_header);
1385 break;
1386 case CVMX_USB_STAGE_SETUP_SPLIT_COMPLETE:
1387 usbc_hctsiz.s.pid = 3;
1388 bytes_to_transfer = 0;
1389
1390 USB_SET_FIELD32(CVMX_USBCX_HCCHARX(channel, usb->index),
1391 cvmx_usbcx_hccharx, epdir,
1392 CVMX_USB_DIRECTION_OUT);
1393
1394 USB_SET_FIELD32(CVMX_USBCX_HCSPLTX(channel, usb->index),
1395 cvmx_usbcx_hcspltx, compsplt, 1);
1396 break;
1397 case CVMX_USB_STAGE_DATA:
1398 usbc_hctsiz.s.pid = cvmx_usb_get_data_pid(pipe);
1399 if (cvmx_usb_pipe_needs_split(usb, pipe)) {
1400 if (header->bRequestType & USB_DIR_IN)
1401 bytes_to_transfer = 0;
1402 else if (bytes_to_transfer > pipe->max_packet)
1403 bytes_to_transfer = pipe->max_packet;
1404 }
1405 USB_SET_FIELD32(CVMX_USBCX_HCCHARX(channel, usb->index),
1406 cvmx_usbcx_hccharx, epdir,
1407 ((header->bRequestType & USB_DIR_IN) ?
1408 CVMX_USB_DIRECTION_IN :
1409 CVMX_USB_DIRECTION_OUT));
1410 break;
1411 case CVMX_USB_STAGE_DATA_SPLIT_COMPLETE:
1412 usbc_hctsiz.s.pid = cvmx_usb_get_data_pid(pipe);
1413 if (!(header->bRequestType & USB_DIR_IN))
1414 bytes_to_transfer = 0;
1415 USB_SET_FIELD32(CVMX_USBCX_HCCHARX(channel, usb->index),
1416 cvmx_usbcx_hccharx, epdir,
1417 ((header->bRequestType & USB_DIR_IN) ?
1418 CVMX_USB_DIRECTION_IN :
1419 CVMX_USB_DIRECTION_OUT));
1420 USB_SET_FIELD32(CVMX_USBCX_HCSPLTX(channel, usb->index),
1421 cvmx_usbcx_hcspltx, compsplt, 1);
1422 break;
1423 case CVMX_USB_STAGE_STATUS:
1424 usbc_hctsiz.s.pid = cvmx_usb_get_data_pid(pipe);
1425 bytes_to_transfer = 0;
1426 USB_SET_FIELD32(CVMX_USBCX_HCCHARX(channel, usb->index),
1427 cvmx_usbcx_hccharx, epdir,
1428 ((header->bRequestType & USB_DIR_IN) ?
1429 CVMX_USB_DIRECTION_OUT :
1430 CVMX_USB_DIRECTION_IN));
1431 break;
1432 case CVMX_USB_STAGE_STATUS_SPLIT_COMPLETE:
1433 usbc_hctsiz.s.pid = cvmx_usb_get_data_pid(pipe);
1434 bytes_to_transfer = 0;
1435 USB_SET_FIELD32(CVMX_USBCX_HCCHARX(channel, usb->index),
1436 cvmx_usbcx_hccharx, epdir,
1437 ((header->bRequestType & USB_DIR_IN) ?
1438 CVMX_USB_DIRECTION_OUT :
1439 CVMX_USB_DIRECTION_IN));
1440 USB_SET_FIELD32(CVMX_USBCX_HCSPLTX(channel, usb->index),
1441 cvmx_usbcx_hcspltx, compsplt, 1);
1442 break;
1443 }
1444
1445
1446
1447
1448
1449 if (bytes_to_transfer > MAX_TRANSFER_BYTES) {
1450
1451 bytes_to_transfer = MAX_TRANSFER_BYTES / pipe->max_packet;
1452 bytes_to_transfer *= pipe->max_packet;
1453 }
1454
1455
1456
1457
1458
1459 packets_to_transfer = DIV_ROUND_UP(bytes_to_transfer,
1460 pipe->max_packet);
1461 if (packets_to_transfer == 0) {
1462 packets_to_transfer = 1;
1463 } else if ((packets_to_transfer > 1) &&
1464 (usb->init_flags & CVMX_USB_INITIALIZE_FLAGS_NO_DMA)) {
1465
1466
1467
1468
1469
1470 packets_to_transfer = 1;
1471 bytes_to_transfer = packets_to_transfer * pipe->max_packet;
1472 } else if (packets_to_transfer > MAX_TRANSFER_PACKETS) {
1473
1474
1475
1476
1477 packets_to_transfer = MAX_TRANSFER_PACKETS;
1478 bytes_to_transfer = packets_to_transfer * pipe->max_packet;
1479 }
1480
1481 usbc_hctsiz.s.xfersize = bytes_to_transfer;
1482 usbc_hctsiz.s.pktcnt = packets_to_transfer;
1483
1484 cvmx_usb_write_csr32(usb, CVMX_USBCX_HCTSIZX(channel, usb->index),
1485 usbc_hctsiz.u32);
1486}
1487
1488
1489
1490
1491
1492
1493
1494
1495static void cvmx_usb_start_channel(struct octeon_hcd *usb, int channel,
1496 struct cvmx_usb_pipe *pipe)
1497{
1498 struct cvmx_usb_transaction *transaction =
1499 list_first_entry(&pipe->transactions, typeof(*transaction),
1500 node);
1501
1502
1503 CVMX_SYNCW;
1504
1505
1506 usb->pipe_for_channel[channel] = pipe;
1507 pipe->channel = channel;
1508 pipe->flags |= CVMX_USB_PIPE_FLAGS_SCHEDULED;
1509
1510
1511 usb->idle_hardware_channels &= ~(1 << channel);
1512
1513
1514 {
1515 union cvmx_usbcx_hcintx usbc_hcint;
1516 union cvmx_usbcx_hcintmskx usbc_hcintmsk;
1517 union cvmx_usbcx_haintmsk usbc_haintmsk;
1518
1519
1520 usbc_hcint.u32 = cvmx_usb_read_csr32(usb,
1521 CVMX_USBCX_HCINTX(channel, usb->index));
1522
1523 cvmx_usb_write_csr32(usb,
1524 CVMX_USBCX_HCINTX(channel, usb->index),
1525 usbc_hcint.u32);
1526
1527 usbc_hcintmsk.u32 = 0;
1528 usbc_hcintmsk.s.chhltdmsk = 1;
1529 if (usb->init_flags & CVMX_USB_INITIALIZE_FLAGS_NO_DMA) {
1530
1531
1532
1533
1534 usbc_hcintmsk.s.datatglerrmsk = 1;
1535 usbc_hcintmsk.s.frmovrunmsk = 1;
1536 usbc_hcintmsk.s.bblerrmsk = 1;
1537 usbc_hcintmsk.s.xacterrmsk = 1;
1538 if (cvmx_usb_pipe_needs_split(usb, pipe)) {
1539
1540
1541
1542
1543 usbc_hcintmsk.s.nyetmsk = 1;
1544 usbc_hcintmsk.s.ackmsk = 1;
1545 }
1546 usbc_hcintmsk.s.nakmsk = 1;
1547 usbc_hcintmsk.s.stallmsk = 1;
1548 usbc_hcintmsk.s.xfercomplmsk = 1;
1549 }
1550 cvmx_usb_write_csr32(usb,
1551 CVMX_USBCX_HCINTMSKX(channel, usb->index),
1552 usbc_hcintmsk.u32);
1553
1554
1555 usbc_haintmsk.u32 = cvmx_usb_read_csr32(usb,
1556 CVMX_USBCX_HAINTMSK(usb->index));
1557 usbc_haintmsk.s.haintmsk |= 1 << channel;
1558 cvmx_usb_write_csr32(usb, CVMX_USBCX_HAINTMSK(usb->index),
1559 usbc_haintmsk.u32);
1560 }
1561
1562
1563 {
1564 u64 reg;
1565 u64 dma_address = transaction->buffer +
1566 transaction->actual_bytes;
1567
1568 if (transaction->type == CVMX_USB_TRANSFER_ISOCHRONOUS)
1569 dma_address = transaction->buffer +
1570 transaction->iso_packets[0].offset +
1571 transaction->actual_bytes;
1572
1573 if (pipe->transfer_dir == CVMX_USB_DIRECTION_OUT)
1574 reg = CVMX_USBNX_DMA0_OUTB_CHN0(usb->index);
1575 else
1576 reg = CVMX_USBNX_DMA0_INB_CHN0(usb->index);
1577 cvmx_write64_uint64(reg + channel * 8, dma_address);
1578 }
1579
1580
1581 {
1582 union cvmx_usbcx_hcspltx usbc_hcsplt = {.u32 = 0};
1583 union cvmx_usbcx_hctsizx usbc_hctsiz = {.u32 = 0};
1584 int packets_to_transfer;
1585 int bytes_to_transfer = transaction->buffer_length -
1586 transaction->actual_bytes;
1587
1588
1589
1590
1591
1592 if (transaction->type == CVMX_USB_TRANSFER_ISOCHRONOUS)
1593 bytes_to_transfer =
1594 transaction->iso_packets[0].length -
1595 transaction->actual_bytes;
1596
1597
1598
1599
1600
1601 if (cvmx_usb_pipe_needs_split(usb, pipe)) {
1602
1603
1604
1605
1606
1607
1608 if ((transaction->stage & 1) == 0) {
1609 if (transaction->type == CVMX_USB_TRANSFER_BULK)
1610 pipe->split_sc_frame =
1611 (usb->frame_number + 1) & 0x7f;
1612 else
1613 pipe->split_sc_frame =
1614 (usb->frame_number + 2) & 0x7f;
1615 } else {
1616 pipe->split_sc_frame = -1;
1617 }
1618
1619 usbc_hcsplt.s.spltena = 1;
1620 usbc_hcsplt.s.hubaddr = pipe->hub_device_addr;
1621 usbc_hcsplt.s.prtaddr = pipe->hub_port;
1622 usbc_hcsplt.s.compsplt = (transaction->stage ==
1623 CVMX_USB_STAGE_NON_CONTROL_SPLIT_COMPLETE);
1624
1625
1626
1627
1628
1629
1630 if (bytes_to_transfer > pipe->max_packet)
1631 bytes_to_transfer = pipe->max_packet;
1632
1633
1634
1635
1636
1637
1638 if (!usbc_hcsplt.s.compsplt &&
1639 (pipe->transfer_dir == CVMX_USB_DIRECTION_OUT) &&
1640 (pipe->transfer_type ==
1641 CVMX_USB_TRANSFER_ISOCHRONOUS)) {
1642
1643
1644
1645
1646 pipe->split_sc_frame = -1;
1647
1648
1649
1650
1651 if (transaction->actual_bytes == 0) {
1652
1653
1654
1655
1656 if (bytes_to_transfer <= 188)
1657
1658 usbc_hcsplt.s.xactpos = 3;
1659 else
1660
1661 usbc_hcsplt.s.xactpos = 2;
1662 } else {
1663
1664
1665
1666
1667 if (bytes_to_transfer <= 188)
1668
1669 usbc_hcsplt.s.xactpos = 1;
1670 else
1671
1672 usbc_hcsplt.s.xactpos = 0;
1673 }
1674
1675
1676
1677
1678 if (bytes_to_transfer > 188)
1679 bytes_to_transfer = 188;
1680 }
1681 }
1682
1683
1684
1685
1686
1687
1688 if (bytes_to_transfer > MAX_TRANSFER_BYTES) {
1689
1690
1691
1692
1693 bytes_to_transfer = MAX_TRANSFER_BYTES /
1694 pipe->max_packet;
1695 bytes_to_transfer *= pipe->max_packet;
1696 }
1697
1698
1699
1700
1701
1702 packets_to_transfer =
1703 DIV_ROUND_UP(bytes_to_transfer, pipe->max_packet);
1704 if (packets_to_transfer == 0) {
1705 packets_to_transfer = 1;
1706 } else if ((packets_to_transfer > 1) &&
1707 (usb->init_flags &
1708 CVMX_USB_INITIALIZE_FLAGS_NO_DMA)) {
1709
1710
1711
1712
1713
1714
1715 packets_to_transfer = 1;
1716 bytes_to_transfer = packets_to_transfer *
1717 pipe->max_packet;
1718 } else if (packets_to_transfer > MAX_TRANSFER_PACKETS) {
1719
1720
1721
1722
1723 packets_to_transfer = MAX_TRANSFER_PACKETS;
1724 bytes_to_transfer = packets_to_transfer *
1725 pipe->max_packet;
1726 }
1727
1728 usbc_hctsiz.s.xfersize = bytes_to_transfer;
1729 usbc_hctsiz.s.pktcnt = packets_to_transfer;
1730
1731
1732 usbc_hctsiz.s.pid = cvmx_usb_get_data_pid(pipe);
1733
1734
1735
1736 if (pipe->flags & CVMX_USB_PIPE_FLAGS_NEED_PING)
1737 usbc_hctsiz.s.dopng = 1;
1738
1739 cvmx_usb_write_csr32(usb,
1740 CVMX_USBCX_HCSPLTX(channel, usb->index),
1741 usbc_hcsplt.u32);
1742 cvmx_usb_write_csr32(usb,
1743 CVMX_USBCX_HCTSIZX(channel, usb->index),
1744 usbc_hctsiz.u32);
1745 }
1746
1747
1748 {
1749 union cvmx_usbcx_hccharx usbc_hcchar = {.u32 = 0};
1750
1751
1752
1753
1754
1755 usbc_hcchar.s.oddfrm = usb->frame_number & 1;
1756
1757
1758
1759
1760
1761
1762
1763 if (cvmx_usb_pipe_needs_split(usb, pipe))
1764 usbc_hcchar.s.ec = 1;
1765 else if (pipe->multi_count < 1)
1766 usbc_hcchar.s.ec = 1;
1767 else if (pipe->multi_count > 3)
1768 usbc_hcchar.s.ec = 3;
1769 else
1770 usbc_hcchar.s.ec = pipe->multi_count;
1771
1772
1773 usbc_hcchar.s.devaddr = pipe->device_addr;
1774 usbc_hcchar.s.eptype = transaction->type;
1775 usbc_hcchar.s.lspddev =
1776 (pipe->device_speed == CVMX_USB_SPEED_LOW);
1777 usbc_hcchar.s.epdir = pipe->transfer_dir;
1778 usbc_hcchar.s.epnum = pipe->endpoint_num;
1779 usbc_hcchar.s.mps = pipe->max_packet;
1780 cvmx_usb_write_csr32(usb,
1781 CVMX_USBCX_HCCHARX(channel, usb->index),
1782 usbc_hcchar.u32);
1783 }
1784
1785
1786 switch (transaction->type) {
1787 case CVMX_USB_TRANSFER_CONTROL:
1788 cvmx_usb_start_channel_control(usb, channel, pipe);
1789 break;
1790 case CVMX_USB_TRANSFER_BULK:
1791 case CVMX_USB_TRANSFER_INTERRUPT:
1792 break;
1793 case CVMX_USB_TRANSFER_ISOCHRONOUS:
1794 if (!cvmx_usb_pipe_needs_split(usb, pipe)) {
1795
1796
1797
1798
1799 if (pipe->transfer_dir == CVMX_USB_DIRECTION_OUT) {
1800 if (pipe->multi_count < 2)
1801 USB_SET_FIELD32(
1802 CVMX_USBCX_HCTSIZX(channel,
1803 usb->index),
1804 cvmx_usbcx_hctsizx, pid, 0);
1805 else
1806 USB_SET_FIELD32(
1807 CVMX_USBCX_HCTSIZX(channel,
1808 usb->index),
1809 cvmx_usbcx_hctsizx, pid, 3);
1810 }
1811 }
1812 break;
1813 }
1814 {
1815 union cvmx_usbcx_hctsizx usbc_hctsiz = { .u32 =
1816 cvmx_usb_read_csr32(usb,
1817 CVMX_USBCX_HCTSIZX(channel,
1818 usb->index))
1819 };
1820 transaction->xfersize = usbc_hctsiz.s.xfersize;
1821 transaction->pktcnt = usbc_hctsiz.s.pktcnt;
1822 }
1823
1824 if (cvmx_usb_pipe_needs_split(usb, pipe))
1825 usb->active_split = transaction;
1826 USB_SET_FIELD32(CVMX_USBCX_HCCHARX(channel, usb->index),
1827 cvmx_usbcx_hccharx, chena, 1);
1828 if (usb->init_flags & CVMX_USB_INITIALIZE_FLAGS_NO_DMA)
1829 cvmx_usb_fill_tx_fifo(usb, channel);
1830}
1831
1832
1833
1834
1835
1836
1837
1838
1839static struct cvmx_usb_pipe *cvmx_usb_find_ready_pipe(struct octeon_hcd *usb,
1840 enum cvmx_usb_transfer xfer_type)
1841{
1842 struct list_head *list = usb->active_pipes + xfer_type;
1843 u64 current_frame = usb->frame_number;
1844 struct cvmx_usb_pipe *pipe;
1845
1846 list_for_each_entry(pipe, list, node) {
1847 struct cvmx_usb_transaction *t =
1848 list_first_entry(&pipe->transactions, typeof(*t),
1849 node);
1850 if (!(pipe->flags & CVMX_USB_PIPE_FLAGS_SCHEDULED) && t &&
1851 (pipe->next_tx_frame <= current_frame) &&
1852 ((pipe->split_sc_frame == -1) ||
1853 ((((int)current_frame - pipe->split_sc_frame) & 0x7f) <
1854 0x40)) &&
1855 (!usb->active_split || (usb->active_split == t))) {
1856 prefetch(t);
1857 return pipe;
1858 }
1859 }
1860 return NULL;
1861}
1862
1863static struct cvmx_usb_pipe *cvmx_usb_next_pipe(struct octeon_hcd *usb,
1864 int is_sof)
1865{
1866 struct cvmx_usb_pipe *pipe;
1867
1868
1869 if (is_sof) {
1870
1871
1872
1873
1874
1875 pipe = cvmx_usb_find_ready_pipe(usb,
1876 CVMX_USB_TRANSFER_ISOCHRONOUS);
1877 if (pipe)
1878 return pipe;
1879 pipe = cvmx_usb_find_ready_pipe(usb,
1880 CVMX_USB_TRANSFER_INTERRUPT);
1881 if (pipe)
1882 return pipe;
1883 }
1884 pipe = cvmx_usb_find_ready_pipe(usb, CVMX_USB_TRANSFER_CONTROL);
1885 if (pipe)
1886 return pipe;
1887 return cvmx_usb_find_ready_pipe(usb, CVMX_USB_TRANSFER_BULK);
1888}
1889
1890
1891
1892
1893
1894
1895
1896
1897static void cvmx_usb_schedule(struct octeon_hcd *usb, int is_sof)
1898{
1899 int channel;
1900 struct cvmx_usb_pipe *pipe;
1901 int need_sof;
1902 enum cvmx_usb_transfer ttype;
1903
1904 if (usb->init_flags & CVMX_USB_INITIALIZE_FLAGS_NO_DMA) {
1905
1906
1907
1908
1909 union cvmx_usbcx_hfnum hfnum = {
1910 .u32 = cvmx_usb_read_csr32(usb,
1911 CVMX_USBCX_HFNUM(usb->index))
1912 };
1913
1914 union cvmx_usbcx_hfir hfir = {
1915 .u32 = cvmx_usb_read_csr32(usb,
1916 CVMX_USBCX_HFIR(usb->index))
1917 };
1918
1919 if (hfnum.s.frrem < hfir.s.frint / 4)
1920 goto done;
1921 }
1922
1923 while (usb->idle_hardware_channels) {
1924
1925 channel = __fls(usb->idle_hardware_channels);
1926 if (unlikely(channel > 7))
1927 break;
1928
1929 pipe = cvmx_usb_next_pipe(usb, is_sof);
1930 if (!pipe)
1931 break;
1932
1933 cvmx_usb_start_channel(usb, channel, pipe);
1934 }
1935
1936done:
1937
1938
1939
1940
1941 need_sof = 0;
1942 for (ttype = CVMX_USB_TRANSFER_CONTROL;
1943 ttype <= CVMX_USB_TRANSFER_INTERRUPT; ttype++) {
1944 list_for_each_entry(pipe, &usb->active_pipes[ttype], node) {
1945 if (pipe->next_tx_frame > usb->frame_number) {
1946 need_sof = 1;
1947 break;
1948 }
1949 }
1950 }
1951 USB_SET_FIELD32(CVMX_USBCX_GINTMSK(usb->index),
1952 cvmx_usbcx_gintmsk, sofmsk, need_sof);
1953}
1954
1955static void octeon_usb_urb_complete_callback(struct octeon_hcd *usb,
1956 enum cvmx_usb_status status,
1957 struct cvmx_usb_pipe *pipe,
1958 struct cvmx_usb_transaction
1959 *transaction,
1960 int bytes_transferred,
1961 struct urb *urb)
1962{
1963 struct usb_hcd *hcd = octeon_to_hcd(usb);
1964 struct device *dev = hcd->self.controller;
1965
1966 if (likely(status == CVMX_USB_STATUS_OK))
1967 urb->actual_length = bytes_transferred;
1968 else
1969 urb->actual_length = 0;
1970
1971 urb->hcpriv = NULL;
1972
1973
1974
1975
1976 if (usb_pipetype(urb->pipe) == PIPE_ISOCHRONOUS) {
1977 int i;
1978
1979
1980
1981
1982 struct cvmx_usb_iso_packet *iso_packet =
1983 (struct cvmx_usb_iso_packet *)urb->setup_packet;
1984
1985 urb->actual_length = 0;
1986 for (i = 0; i < urb->number_of_packets; i++) {
1987 if (iso_packet[i].status == CVMX_USB_STATUS_OK) {
1988 urb->iso_frame_desc[i].status = 0;
1989 urb->iso_frame_desc[i].actual_length =
1990 iso_packet[i].length;
1991 urb->actual_length +=
1992 urb->iso_frame_desc[i].actual_length;
1993 } else {
1994 dev_dbg(dev, "ISOCHRONOUS packet=%d of %d status=%d pipe=%p transaction=%p size=%d\n",
1995 i, urb->number_of_packets,
1996 iso_packet[i].status, pipe,
1997 transaction, iso_packet[i].length);
1998 urb->iso_frame_desc[i].status = -EREMOTEIO;
1999 }
2000 }
2001
2002 kfree(iso_packet);
2003 urb->setup_packet = NULL;
2004 }
2005
2006 switch (status) {
2007 case CVMX_USB_STATUS_OK:
2008 urb->status = 0;
2009 break;
2010 case CVMX_USB_STATUS_CANCEL:
2011 if (urb->status == 0)
2012 urb->status = -ENOENT;
2013 break;
2014 case CVMX_USB_STATUS_STALL:
2015 dev_dbg(dev, "status=stall pipe=%p transaction=%p size=%d\n",
2016 pipe, transaction, bytes_transferred);
2017 urb->status = -EPIPE;
2018 break;
2019 case CVMX_USB_STATUS_BABBLEERR:
2020 dev_dbg(dev, "status=babble pipe=%p transaction=%p size=%d\n",
2021 pipe, transaction, bytes_transferred);
2022 urb->status = -EPIPE;
2023 break;
2024 case CVMX_USB_STATUS_SHORT:
2025 dev_dbg(dev, "status=short pipe=%p transaction=%p size=%d\n",
2026 pipe, transaction, bytes_transferred);
2027 urb->status = -EREMOTEIO;
2028 break;
2029 case CVMX_USB_STATUS_ERROR:
2030 case CVMX_USB_STATUS_XACTERR:
2031 case CVMX_USB_STATUS_DATATGLERR:
2032 case CVMX_USB_STATUS_FRAMEERR:
2033 dev_dbg(dev, "status=%d pipe=%p transaction=%p size=%d\n",
2034 status, pipe, transaction, bytes_transferred);
2035 urb->status = -EPROTO;
2036 break;
2037 }
2038 usb_hcd_unlink_urb_from_ep(octeon_to_hcd(usb), urb);
2039 spin_unlock(&usb->lock);
2040 usb_hcd_giveback_urb(octeon_to_hcd(usb), urb, urb->status);
2041 spin_lock(&usb->lock);
2042}
2043
2044
2045
2046
2047
2048
2049
2050
2051
2052
2053
2054
2055static void cvmx_usb_complete(struct octeon_hcd *usb,
2056 struct cvmx_usb_pipe *pipe,
2057 struct cvmx_usb_transaction *transaction,
2058 enum cvmx_usb_status complete_code)
2059{
2060
2061 if (usb->active_split == transaction)
2062 usb->active_split = NULL;
2063
2064
2065
2066
2067
2068 if (unlikely(transaction->type == CVMX_USB_TRANSFER_ISOCHRONOUS)) {
2069
2070 transaction->iso_packets[0].length = transaction->actual_bytes;
2071 transaction->iso_packets[0].status = complete_code;
2072
2073
2074
2075
2076
2077 if ((transaction->iso_number_packets > 1) &&
2078 (complete_code == CVMX_USB_STATUS_OK)) {
2079
2080 transaction->actual_bytes = 0;
2081
2082 transaction->iso_number_packets--;
2083
2084 transaction->iso_packets++;
2085 transaction->stage = CVMX_USB_STAGE_NON_CONTROL;
2086 return;
2087 }
2088 }
2089
2090
2091 list_del(&transaction->node);
2092 if (list_empty(&pipe->transactions))
2093 list_move_tail(&pipe->node, &usb->idle_pipes);
2094 octeon_usb_urb_complete_callback(usb, complete_code, pipe,
2095 transaction,
2096 transaction->actual_bytes,
2097 transaction->urb);
2098 kfree(transaction);
2099}
2100
2101
2102
2103
2104
2105
2106
2107
2108
2109
2110
2111
2112
2113
2114
2115
2116
2117
2118
2119
2120
2121
2122
2123static struct cvmx_usb_transaction *cvmx_usb_submit_transaction(
2124 struct octeon_hcd *usb,
2125 struct cvmx_usb_pipe *pipe,
2126 enum cvmx_usb_transfer type,
2127 u64 buffer,
2128 int buffer_length,
2129 u64 control_header,
2130 int iso_start_frame,
2131 int iso_number_packets,
2132 struct cvmx_usb_iso_packet *iso_packets,
2133 struct urb *urb)
2134{
2135 struct cvmx_usb_transaction *transaction;
2136
2137 if (unlikely(pipe->transfer_type != type))
2138 return NULL;
2139
2140 transaction = kzalloc(sizeof(*transaction), GFP_ATOMIC);
2141 if (unlikely(!transaction))
2142 return NULL;
2143
2144 transaction->type = type;
2145 transaction->buffer = buffer;
2146 transaction->buffer_length = buffer_length;
2147 transaction->control_header = control_header;
2148
2149 transaction->iso_start_frame = iso_start_frame;
2150 transaction->iso_number_packets = iso_number_packets;
2151 transaction->iso_packets = iso_packets;
2152 transaction->urb = urb;
2153 if (transaction->type == CVMX_USB_TRANSFER_CONTROL)
2154 transaction->stage = CVMX_USB_STAGE_SETUP;
2155 else
2156 transaction->stage = CVMX_USB_STAGE_NON_CONTROL;
2157
2158 if (!list_empty(&pipe->transactions)) {
2159 list_add_tail(&transaction->node, &pipe->transactions);
2160 } else {
2161 list_add_tail(&transaction->node, &pipe->transactions);
2162 list_move_tail(&pipe->node,
2163 &usb->active_pipes[pipe->transfer_type]);
2164
2165
2166
2167
2168
2169 cvmx_usb_schedule(usb, 0);
2170 }
2171
2172 return transaction;
2173}
2174
2175
2176
2177
2178
2179
2180
2181
2182
2183
2184static struct cvmx_usb_transaction *cvmx_usb_submit_bulk(
2185 struct octeon_hcd *usb,
2186 struct cvmx_usb_pipe *pipe,
2187 struct urb *urb)
2188{
2189 return cvmx_usb_submit_transaction(usb, pipe, CVMX_USB_TRANSFER_BULK,
2190 urb->transfer_dma,
2191 urb->transfer_buffer_length,
2192 0,
2193 0,
2194 0,
2195 NULL,
2196 urb);
2197}
2198
2199
2200
2201
2202
2203
2204
2205
2206
2207
2208static struct cvmx_usb_transaction *cvmx_usb_submit_interrupt(
2209 struct octeon_hcd *usb,
2210 struct cvmx_usb_pipe *pipe,
2211 struct urb *urb)
2212{
2213 return cvmx_usb_submit_transaction(usb, pipe,
2214 CVMX_USB_TRANSFER_INTERRUPT,
2215 urb->transfer_dma,
2216 urb->transfer_buffer_length,
2217 0,
2218 0,
2219 0,
2220 NULL,
2221 urb);
2222}
2223
2224
2225
2226
2227
2228
2229
2230
2231
2232
2233static struct cvmx_usb_transaction *cvmx_usb_submit_control(
2234 struct octeon_hcd *usb,
2235 struct cvmx_usb_pipe *pipe,
2236 struct urb *urb)
2237{
2238 int buffer_length = urb->transfer_buffer_length;
2239 u64 control_header = urb->setup_dma;
2240 struct usb_ctrlrequest *header = cvmx_phys_to_ptr(control_header);
2241
2242 if ((header->bRequestType & USB_DIR_IN) == 0)
2243 buffer_length = le16_to_cpu(header->wLength);
2244
2245 return cvmx_usb_submit_transaction(usb, pipe,
2246 CVMX_USB_TRANSFER_CONTROL,
2247 urb->transfer_dma, buffer_length,
2248 control_header,
2249 0,
2250 0,
2251 NULL,
2252 urb);
2253}
2254
2255
2256
2257
2258
2259
2260
2261
2262
2263
2264static struct cvmx_usb_transaction *cvmx_usb_submit_isochronous(
2265 struct octeon_hcd *usb,
2266 struct cvmx_usb_pipe *pipe,
2267 struct urb *urb)
2268{
2269 struct cvmx_usb_iso_packet *packets;
2270
2271 packets = (struct cvmx_usb_iso_packet *)urb->setup_packet;
2272 return cvmx_usb_submit_transaction(usb, pipe,
2273 CVMX_USB_TRANSFER_ISOCHRONOUS,
2274 urb->transfer_dma,
2275 urb->transfer_buffer_length,
2276 0,
2277 urb->start_frame,
2278 urb->number_of_packets,
2279 packets, urb);
2280}
2281
2282
2283
2284
2285
2286
2287
2288
2289
2290
2291
2292
2293
2294
2295static int cvmx_usb_cancel(struct octeon_hcd *usb,
2296 struct cvmx_usb_pipe *pipe,
2297 struct cvmx_usb_transaction *transaction)
2298{
2299
2300
2301
2302
2303 if (list_first_entry(&pipe->transactions, typeof(*transaction), node) ==
2304 transaction && (pipe->flags & CVMX_USB_PIPE_FLAGS_SCHEDULED)) {
2305 union cvmx_usbcx_hccharx usbc_hcchar;
2306
2307 usb->pipe_for_channel[pipe->channel] = NULL;
2308 pipe->flags &= ~CVMX_USB_PIPE_FLAGS_SCHEDULED;
2309
2310 CVMX_SYNCW;
2311
2312 usbc_hcchar.u32 = cvmx_usb_read_csr32(usb,
2313 CVMX_USBCX_HCCHARX(pipe->channel, usb->index));
2314
2315
2316
2317
2318 if (usbc_hcchar.s.chena) {
2319 usbc_hcchar.s.chdis = 1;
2320 cvmx_usb_write_csr32(usb,
2321 CVMX_USBCX_HCCHARX(pipe->channel,
2322 usb->index),
2323 usbc_hcchar.u32);
2324 }
2325 }
2326 cvmx_usb_complete(usb, pipe, transaction, CVMX_USB_STATUS_CANCEL);
2327 return 0;
2328}
2329
2330
2331
2332
2333
2334
2335
2336
2337
2338
2339static int cvmx_usb_cancel_all(struct octeon_hcd *usb,
2340 struct cvmx_usb_pipe *pipe)
2341{
2342 struct cvmx_usb_transaction *transaction, *next;
2343
2344
2345 list_for_each_entry_safe(transaction, next, &pipe->transactions, node) {
2346 int result = cvmx_usb_cancel(usb, pipe, transaction);
2347
2348 if (unlikely(result != 0))
2349 return result;
2350 }
2351 return 0;
2352}
2353
2354
2355
2356
2357
2358
2359
2360
2361
2362
2363static int cvmx_usb_close_pipe(struct octeon_hcd *usb,
2364 struct cvmx_usb_pipe *pipe)
2365{
2366
2367 if (!list_empty(&pipe->transactions))
2368 return -EBUSY;
2369
2370 list_del(&pipe->node);
2371 kfree(pipe);
2372
2373 return 0;
2374}
2375
2376
2377
2378
2379
2380
2381
2382
2383
2384static int cvmx_usb_get_frame_number(struct octeon_hcd *usb)
2385{
2386 union cvmx_usbcx_hfnum usbc_hfnum;
2387
2388 usbc_hfnum.u32 = cvmx_usb_read_csr32(usb, CVMX_USBCX_HFNUM(usb->index));
2389
2390 return usbc_hfnum.s.frnum;
2391}
2392
2393static void cvmx_usb_transfer_control(struct octeon_hcd *usb,
2394 struct cvmx_usb_pipe *pipe,
2395 struct cvmx_usb_transaction *transaction,
2396 union cvmx_usbcx_hccharx usbc_hcchar,
2397 int buffer_space_left,
2398 int bytes_in_last_packet)
2399{
2400 switch (transaction->stage) {
2401 case CVMX_USB_STAGE_NON_CONTROL:
2402 case CVMX_USB_STAGE_NON_CONTROL_SPLIT_COMPLETE:
2403
2404 cvmx_usb_complete(usb, pipe, transaction,
2405 CVMX_USB_STATUS_ERROR);
2406 break;
2407 case CVMX_USB_STAGE_SETUP:
2408 pipe->pid_toggle = 1;
2409 if (cvmx_usb_pipe_needs_split(usb, pipe)) {
2410 transaction->stage =
2411 CVMX_USB_STAGE_SETUP_SPLIT_COMPLETE;
2412 } else {
2413 struct usb_ctrlrequest *header =
2414 cvmx_phys_to_ptr(transaction->control_header);
2415 if (header->wLength)
2416 transaction->stage = CVMX_USB_STAGE_DATA;
2417 else
2418 transaction->stage = CVMX_USB_STAGE_STATUS;
2419 }
2420 break;
2421 case CVMX_USB_STAGE_SETUP_SPLIT_COMPLETE:
2422 {
2423 struct usb_ctrlrequest *header =
2424 cvmx_phys_to_ptr(transaction->control_header);
2425 if (header->wLength)
2426 transaction->stage = CVMX_USB_STAGE_DATA;
2427 else
2428 transaction->stage = CVMX_USB_STAGE_STATUS;
2429 }
2430 break;
2431 case CVMX_USB_STAGE_DATA:
2432 if (cvmx_usb_pipe_needs_split(usb, pipe)) {
2433 transaction->stage = CVMX_USB_STAGE_DATA_SPLIT_COMPLETE;
2434
2435
2436
2437
2438
2439
2440 if (!usbc_hcchar.s.epdir) {
2441 if (buffer_space_left < pipe->max_packet)
2442 transaction->actual_bytes +=
2443 buffer_space_left;
2444 else
2445 transaction->actual_bytes +=
2446 pipe->max_packet;
2447 }
2448 } else if ((buffer_space_left == 0) ||
2449 (bytes_in_last_packet < pipe->max_packet)) {
2450 pipe->pid_toggle = 1;
2451 transaction->stage = CVMX_USB_STAGE_STATUS;
2452 }
2453 break;
2454 case CVMX_USB_STAGE_DATA_SPLIT_COMPLETE:
2455 if ((buffer_space_left == 0) ||
2456 (bytes_in_last_packet < pipe->max_packet)) {
2457 pipe->pid_toggle = 1;
2458 transaction->stage = CVMX_USB_STAGE_STATUS;
2459 } else {
2460 transaction->stage = CVMX_USB_STAGE_DATA;
2461 }
2462 break;
2463 case CVMX_USB_STAGE_STATUS:
2464 if (cvmx_usb_pipe_needs_split(usb, pipe))
2465 transaction->stage =
2466 CVMX_USB_STAGE_STATUS_SPLIT_COMPLETE;
2467 else
2468 cvmx_usb_complete(usb, pipe, transaction,
2469 CVMX_USB_STATUS_OK);
2470 break;
2471 case CVMX_USB_STAGE_STATUS_SPLIT_COMPLETE:
2472 cvmx_usb_complete(usb, pipe, transaction, CVMX_USB_STATUS_OK);
2473 break;
2474 }
2475}
2476
2477static void cvmx_usb_transfer_bulk(struct octeon_hcd *usb,
2478 struct cvmx_usb_pipe *pipe,
2479 struct cvmx_usb_transaction *transaction,
2480 union cvmx_usbcx_hcintx usbc_hcint,
2481 int buffer_space_left,
2482 int bytes_in_last_packet)
2483{
2484
2485
2486
2487
2488
2489 if (cvmx_usb_pipe_needs_split(usb, pipe)) {
2490 if (transaction->stage == CVMX_USB_STAGE_NON_CONTROL)
2491 transaction->stage =
2492 CVMX_USB_STAGE_NON_CONTROL_SPLIT_COMPLETE;
2493 else if (buffer_space_left &&
2494 (bytes_in_last_packet == pipe->max_packet))
2495 transaction->stage = CVMX_USB_STAGE_NON_CONTROL;
2496 else
2497 cvmx_usb_complete(usb, pipe, transaction,
2498 CVMX_USB_STATUS_OK);
2499 } else {
2500 if ((pipe->device_speed == CVMX_USB_SPEED_HIGH) &&
2501 (pipe->transfer_dir == CVMX_USB_DIRECTION_OUT) &&
2502 (usbc_hcint.s.nak))
2503 pipe->flags |= CVMX_USB_PIPE_FLAGS_NEED_PING;
2504 if (!buffer_space_left ||
2505 (bytes_in_last_packet < pipe->max_packet))
2506 cvmx_usb_complete(usb, pipe, transaction,
2507 CVMX_USB_STATUS_OK);
2508 }
2509}
2510
2511static void cvmx_usb_transfer_intr(struct octeon_hcd *usb,
2512 struct cvmx_usb_pipe *pipe,
2513 struct cvmx_usb_transaction *transaction,
2514 int buffer_space_left,
2515 int bytes_in_last_packet)
2516{
2517 if (cvmx_usb_pipe_needs_split(usb, pipe)) {
2518 if (transaction->stage == CVMX_USB_STAGE_NON_CONTROL) {
2519 transaction->stage =
2520 CVMX_USB_STAGE_NON_CONTROL_SPLIT_COMPLETE;
2521 } else if (buffer_space_left &&
2522 (bytes_in_last_packet == pipe->max_packet)) {
2523 transaction->stage = CVMX_USB_STAGE_NON_CONTROL;
2524 } else {
2525 pipe->next_tx_frame += pipe->interval;
2526 cvmx_usb_complete(usb, pipe, transaction,
2527 CVMX_USB_STATUS_OK);
2528 }
2529 } else if (!buffer_space_left ||
2530 (bytes_in_last_packet < pipe->max_packet)) {
2531 pipe->next_tx_frame += pipe->interval;
2532 cvmx_usb_complete(usb, pipe, transaction, CVMX_USB_STATUS_OK);
2533 }
2534}
2535
2536static void cvmx_usb_transfer_isoc(struct octeon_hcd *usb,
2537 struct cvmx_usb_pipe *pipe,
2538 struct cvmx_usb_transaction *transaction,
2539 int buffer_space_left,
2540 int bytes_in_last_packet,
2541 int bytes_this_transfer)
2542{
2543 if (cvmx_usb_pipe_needs_split(usb, pipe)) {
2544
2545
2546
2547
2548
2549
2550 if (pipe->transfer_dir == CVMX_USB_DIRECTION_OUT) {
2551
2552
2553
2554
2555
2556 if (!buffer_space_left || (bytes_this_transfer < 188)) {
2557 pipe->next_tx_frame += pipe->interval;
2558 cvmx_usb_complete(usb, pipe, transaction,
2559 CVMX_USB_STATUS_OK);
2560 }
2561 return;
2562 }
2563 if (transaction->stage ==
2564 CVMX_USB_STAGE_NON_CONTROL_SPLIT_COMPLETE) {
2565
2566
2567
2568
2569 if ((buffer_space_left == 0) ||
2570 (bytes_in_last_packet < pipe->max_packet)) {
2571 pipe->next_tx_frame += pipe->interval;
2572 cvmx_usb_complete(usb, pipe, transaction,
2573 CVMX_USB_STATUS_OK);
2574 }
2575 } else {
2576 transaction->stage =
2577 CVMX_USB_STAGE_NON_CONTROL_SPLIT_COMPLETE;
2578 }
2579 } else {
2580 pipe->next_tx_frame += pipe->interval;
2581 cvmx_usb_complete(usb, pipe, transaction, CVMX_USB_STATUS_OK);
2582 }
2583}
2584
2585
2586
2587
2588
2589
2590
2591
2592
2593static int cvmx_usb_poll_channel(struct octeon_hcd *usb, int channel)
2594{
2595 struct usb_hcd *hcd = octeon_to_hcd(usb);
2596 struct device *dev = hcd->self.controller;
2597 union cvmx_usbcx_hcintx usbc_hcint;
2598 union cvmx_usbcx_hctsizx usbc_hctsiz;
2599 union cvmx_usbcx_hccharx usbc_hcchar;
2600 struct cvmx_usb_pipe *pipe;
2601 struct cvmx_usb_transaction *transaction;
2602 int bytes_this_transfer;
2603 int bytes_in_last_packet;
2604 int packets_processed;
2605 int buffer_space_left;
2606
2607
2608 usbc_hcint.u32 = cvmx_usb_read_csr32(usb,
2609 CVMX_USBCX_HCINTX(channel, usb->index));
2610
2611 if (usb->init_flags & CVMX_USB_INITIALIZE_FLAGS_NO_DMA) {
2612 usbc_hcchar.u32 = cvmx_usb_read_csr32(usb,
2613 CVMX_USBCX_HCCHARX(channel, usb->index));
2614
2615 if (usbc_hcchar.s.chena && usbc_hcchar.s.chdis) {
2616
2617
2618
2619
2620
2621 cvmx_usb_write_csr32(usb,
2622 CVMX_USBCX_HCCHARX(channel,
2623 usb->index),
2624 usbc_hcchar.u32);
2625 return 0;
2626 }
2627
2628
2629
2630
2631
2632 if (!usbc_hcint.s.chhltd) {
2633 if (usbc_hcchar.s.chena) {
2634 union cvmx_usbcx_hcintmskx hcintmsk;
2635
2636 hcintmsk.u32 = 0;
2637 hcintmsk.s.chhltdmsk = 1;
2638 cvmx_usb_write_csr32(usb,
2639 CVMX_USBCX_HCINTMSKX(channel, usb->index),
2640 hcintmsk.u32);
2641 usbc_hcchar.s.chdis = 1;
2642 cvmx_usb_write_csr32(usb,
2643 CVMX_USBCX_HCCHARX(channel, usb->index),
2644 usbc_hcchar.u32);
2645 return 0;
2646 } else if (usbc_hcint.s.xfercompl) {
2647
2648
2649
2650
2651 } else {
2652 dev_err(dev, "USB%d: Channel %d interrupt without halt\n",
2653 usb->index, channel);
2654 return 0;
2655 }
2656 }
2657 } else {
2658
2659
2660
2661
2662 if (!usbc_hcint.s.chhltd)
2663 return 0;
2664 }
2665
2666
2667 cvmx_usb_write_csr32(usb, CVMX_USBCX_HCINTMSKX(channel, usb->index), 0);
2668 usb->idle_hardware_channels |= (1 << channel);
2669
2670
2671 pipe = usb->pipe_for_channel[channel];
2672 prefetch(pipe);
2673 if (!pipe)
2674 return 0;
2675 transaction = list_first_entry(&pipe->transactions,
2676 typeof(*transaction),
2677 node);
2678 prefetch(transaction);
2679
2680
2681
2682
2683
2684 usb->pipe_for_channel[channel] = NULL;
2685 pipe->flags &= ~CVMX_USB_PIPE_FLAGS_SCHEDULED;
2686
2687
2688
2689
2690
2691 usbc_hcchar.u32 = cvmx_usb_read_csr32(usb,
2692 CVMX_USBCX_HCCHARX(channel, usb->index));
2693 usbc_hctsiz.u32 = cvmx_usb_read_csr32(usb,
2694 CVMX_USBCX_HCTSIZX(channel, usb->index));
2695
2696
2697
2698
2699
2700 packets_processed = transaction->pktcnt - usbc_hctsiz.s.pktcnt;
2701 if (usbc_hcchar.s.epdir) {
2702
2703
2704
2705
2706
2707
2708 bytes_this_transfer = transaction->xfersize -
2709 usbc_hctsiz.s.xfersize;
2710 } else {
2711
2712
2713
2714
2715
2716
2717 bytes_this_transfer = packets_processed * usbc_hcchar.s.mps;
2718
2719
2720
2721
2722 if (bytes_this_transfer > transaction->xfersize)
2723 bytes_this_transfer = transaction->xfersize;
2724 }
2725
2726 if (packets_processed)
2727 bytes_in_last_packet = bytes_this_transfer -
2728 (packets_processed - 1) * usbc_hcchar.s.mps;
2729 else
2730 bytes_in_last_packet = bytes_this_transfer;
2731
2732
2733
2734
2735
2736
2737 if ((transaction->stage == CVMX_USB_STAGE_SETUP) ||
2738 (transaction->stage == CVMX_USB_STAGE_SETUP_SPLIT_COMPLETE))
2739 bytes_this_transfer = 0;
2740
2741
2742
2743
2744
2745
2746 transaction->actual_bytes += bytes_this_transfer;
2747 if (transaction->type == CVMX_USB_TRANSFER_ISOCHRONOUS)
2748 buffer_space_left = transaction->iso_packets[0].length -
2749 transaction->actual_bytes;
2750 else
2751 buffer_space_left = transaction->buffer_length -
2752 transaction->actual_bytes;
2753
2754
2755
2756
2757
2758 pipe->pid_toggle = !(usbc_hctsiz.s.pid == 0);
2759
2760
2761
2762
2763
2764
2765 if ((pipe->device_speed == CVMX_USB_SPEED_HIGH) &&
2766 (pipe->transfer_type == CVMX_USB_TRANSFER_BULK) &&
2767 (pipe->transfer_dir == CVMX_USB_DIRECTION_OUT))
2768 pipe->flags |= CVMX_USB_PIPE_FLAGS_NEED_PING;
2769
2770 if (WARN_ON_ONCE(bytes_this_transfer < 0)) {
2771
2772
2773
2774
2775
2776 cvmx_usb_complete(usb, pipe, transaction,
2777 CVMX_USB_STATUS_ERROR);
2778 return 0;
2779 }
2780
2781 if (usbc_hcint.s.stall) {
2782
2783
2784
2785
2786
2787
2788 pipe->pid_toggle = 0;
2789 cvmx_usb_complete(usb, pipe, transaction,
2790 CVMX_USB_STATUS_STALL);
2791 } else if (usbc_hcint.s.xacterr) {
2792
2793
2794
2795
2796
2797 cvmx_usb_complete(usb, pipe, transaction,
2798 CVMX_USB_STATUS_XACTERR);
2799 } else if (usbc_hcint.s.bblerr) {
2800
2801 cvmx_usb_complete(usb, pipe, transaction,
2802 CVMX_USB_STATUS_BABBLEERR);
2803 } else if (usbc_hcint.s.datatglerr) {
2804
2805 cvmx_usb_complete(usb, pipe, transaction,
2806 CVMX_USB_STATUS_DATATGLERR);
2807 } else if (usbc_hcint.s.nyet) {
2808
2809
2810
2811
2812
2813
2814 if (!cvmx_usb_pipe_needs_split(usb, pipe)) {
2815 transaction->retries = 0;
2816
2817
2818
2819
2820 if ((buffer_space_left == 0) ||
2821 (bytes_in_last_packet < pipe->max_packet))
2822 cvmx_usb_complete(usb, pipe,
2823 transaction,
2824 CVMX_USB_STATUS_OK);
2825 } else {
2826
2827
2828
2829
2830
2831 transaction->retries++;
2832 if ((transaction->retries & 0x3) == 0) {
2833
2834
2835
2836
2837 transaction->stage &= ~1;
2838 pipe->split_sc_frame = -1;
2839 }
2840 }
2841 } else if (usbc_hcint.s.ack) {
2842 transaction->retries = 0;
2843
2844
2845
2846
2847
2848
2849
2850
2851
2852
2853
2854 pipe->flags &= ~CVMX_USB_PIPE_FLAGS_NEED_PING;
2855
2856 switch (transaction->type) {
2857 case CVMX_USB_TRANSFER_CONTROL:
2858 cvmx_usb_transfer_control(usb, pipe, transaction,
2859 usbc_hcchar,
2860 buffer_space_left,
2861 bytes_in_last_packet);
2862 break;
2863 case CVMX_USB_TRANSFER_BULK:
2864 cvmx_usb_transfer_bulk(usb, pipe, transaction,
2865 usbc_hcint, buffer_space_left,
2866 bytes_in_last_packet);
2867 break;
2868 case CVMX_USB_TRANSFER_INTERRUPT:
2869 cvmx_usb_transfer_intr(usb, pipe, transaction,
2870 buffer_space_left,
2871 bytes_in_last_packet);
2872 break;
2873 case CVMX_USB_TRANSFER_ISOCHRONOUS:
2874 cvmx_usb_transfer_isoc(usb, pipe, transaction,
2875 buffer_space_left,
2876 bytes_in_last_packet,
2877 bytes_this_transfer);
2878 break;
2879 }
2880 } else if (usbc_hcint.s.nak) {
2881
2882
2883
2884 if (usb->active_split == transaction)
2885 usb->active_split = NULL;
2886
2887
2888
2889
2890
2891
2892 transaction->retries = 0;
2893 transaction->stage &= ~1;
2894 pipe->next_tx_frame += pipe->interval;
2895 if (pipe->next_tx_frame < usb->frame_number)
2896 pipe->next_tx_frame = usb->frame_number +
2897 pipe->interval -
2898 (usb->frame_number - pipe->next_tx_frame) %
2899 pipe->interval;
2900 } else {
2901 struct cvmx_usb_port_status port;
2902
2903 port = cvmx_usb_get_status(usb);
2904 if (port.port_enabled) {
2905
2906 transaction->retries++;
2907 } else {
2908
2909
2910
2911
2912 cvmx_usb_complete(usb, pipe, transaction,
2913 CVMX_USB_STATUS_ERROR);
2914 }
2915 }
2916 return 0;
2917}
2918
2919static void octeon_usb_port_callback(struct octeon_hcd *usb)
2920{
2921 spin_unlock(&usb->lock);
2922 usb_hcd_poll_rh_status(octeon_to_hcd(usb));
2923 spin_lock(&usb->lock);
2924}
2925
2926
2927
2928
2929
2930
2931
2932
2933
2934
2935
2936static int cvmx_usb_poll(struct octeon_hcd *usb)
2937{
2938 union cvmx_usbcx_hfnum usbc_hfnum;
2939 union cvmx_usbcx_gintsts usbc_gintsts;
2940
2941 prefetch_range(usb, sizeof(*usb));
2942
2943
2944 usbc_hfnum.u32 = cvmx_usb_read_csr32(usb, CVMX_USBCX_HFNUM(usb->index));
2945 if ((usb->frame_number & 0x3fff) > usbc_hfnum.s.frnum)
2946 usb->frame_number += 0x4000;
2947 usb->frame_number &= ~0x3fffull;
2948 usb->frame_number |= usbc_hfnum.s.frnum;
2949
2950
2951 usbc_gintsts.u32 = cvmx_usb_read_csr32(usb,
2952 CVMX_USBCX_GINTSTS(usb->index));
2953
2954
2955 cvmx_usb_write_csr32(usb, CVMX_USBCX_GINTSTS(usb->index),
2956 usbc_gintsts.u32);
2957
2958 if (usbc_gintsts.s.rxflvl) {
2959
2960
2961
2962
2963
2964
2965
2966 if (usb->init_flags & CVMX_USB_INITIALIZE_FLAGS_NO_DMA)
2967 cvmx_usb_poll_rx_fifo(usb);
2968 }
2969 if (usbc_gintsts.s.ptxfemp || usbc_gintsts.s.nptxfemp) {
2970
2971 if (usb->init_flags & CVMX_USB_INITIALIZE_FLAGS_NO_DMA)
2972 cvmx_usb_poll_tx_fifo(usb);
2973 }
2974 if (usbc_gintsts.s.disconnint || usbc_gintsts.s.prtint) {
2975 union cvmx_usbcx_hprt usbc_hprt;
2976
2977
2978
2979
2980
2981
2982
2983
2984
2985
2986
2987
2988
2989
2990 octeon_usb_port_callback(usb);
2991
2992 usbc_hprt.u32 =
2993 cvmx_usb_read_csr32(usb, CVMX_USBCX_HPRT(usb->index));
2994 usbc_hprt.s.prtena = 0;
2995 cvmx_usb_write_csr32(usb, CVMX_USBCX_HPRT(usb->index),
2996 usbc_hprt.u32);
2997 }
2998 if (usbc_gintsts.s.hchint) {
2999
3000
3001
3002
3003
3004
3005
3006
3007
3008
3009
3010
3011 union cvmx_usbcx_haint usbc_haint;
3012
3013 usbc_haint.u32 = cvmx_usb_read_csr32(usb,
3014 CVMX_USBCX_HAINT(usb->index));
3015 while (usbc_haint.u32) {
3016 int channel;
3017
3018 channel = __fls(usbc_haint.u32);
3019 cvmx_usb_poll_channel(usb, channel);
3020 usbc_haint.u32 ^= 1 << channel;
3021 }
3022 }
3023
3024 cvmx_usb_schedule(usb, usbc_gintsts.s.sof);
3025
3026 return 0;
3027}
3028
3029
3030static inline struct octeon_hcd *hcd_to_octeon(struct usb_hcd *hcd)
3031{
3032 return (struct octeon_hcd *)(hcd->hcd_priv);
3033}
3034
3035static irqreturn_t octeon_usb_irq(struct usb_hcd *hcd)
3036{
3037 struct octeon_hcd *usb = hcd_to_octeon(hcd);
3038 unsigned long flags;
3039
3040 spin_lock_irqsave(&usb->lock, flags);
3041 cvmx_usb_poll(usb);
3042 spin_unlock_irqrestore(&usb->lock, flags);
3043 return IRQ_HANDLED;
3044}
3045
3046static int octeon_usb_start(struct usb_hcd *hcd)
3047{
3048 hcd->state = HC_STATE_RUNNING;
3049 return 0;
3050}
3051
3052static void octeon_usb_stop(struct usb_hcd *hcd)
3053{
3054 hcd->state = HC_STATE_HALT;
3055}
3056
3057static int octeon_usb_get_frame_number(struct usb_hcd *hcd)
3058{
3059 struct octeon_hcd *usb = hcd_to_octeon(hcd);
3060
3061 return cvmx_usb_get_frame_number(usb);
3062}
3063
3064static int octeon_usb_urb_enqueue(struct usb_hcd *hcd,
3065 struct urb *urb,
3066 gfp_t mem_flags)
3067{
3068 struct octeon_hcd *usb = hcd_to_octeon(hcd);
3069 struct device *dev = hcd->self.controller;
3070 struct cvmx_usb_transaction *transaction = NULL;
3071 struct cvmx_usb_pipe *pipe;
3072 unsigned long flags;
3073 struct cvmx_usb_iso_packet *iso_packet;
3074 struct usb_host_endpoint *ep = urb->ep;
3075 int rc;
3076
3077 urb->status = 0;
3078 spin_lock_irqsave(&usb->lock, flags);
3079
3080 rc = usb_hcd_link_urb_to_ep(hcd, urb);
3081 if (rc) {
3082 spin_unlock_irqrestore(&usb->lock, flags);
3083 return rc;
3084 }
3085
3086 if (!ep->hcpriv) {
3087 enum cvmx_usb_transfer transfer_type;
3088 enum cvmx_usb_speed speed;
3089 int split_device = 0;
3090 int split_port = 0;
3091
3092 switch (usb_pipetype(urb->pipe)) {
3093 case PIPE_ISOCHRONOUS:
3094 transfer_type = CVMX_USB_TRANSFER_ISOCHRONOUS;
3095 break;
3096 case PIPE_INTERRUPT:
3097 transfer_type = CVMX_USB_TRANSFER_INTERRUPT;
3098 break;
3099 case PIPE_CONTROL:
3100 transfer_type = CVMX_USB_TRANSFER_CONTROL;
3101 break;
3102 default:
3103 transfer_type = CVMX_USB_TRANSFER_BULK;
3104 break;
3105 }
3106 switch (urb->dev->speed) {
3107 case USB_SPEED_LOW:
3108 speed = CVMX_USB_SPEED_LOW;
3109 break;
3110 case USB_SPEED_FULL:
3111 speed = CVMX_USB_SPEED_FULL;
3112 break;
3113 default:
3114 speed = CVMX_USB_SPEED_HIGH;
3115 break;
3116 }
3117
3118
3119
3120
3121
3122 if (speed != CVMX_USB_SPEED_HIGH) {
3123
3124
3125
3126
3127 struct usb_device *dev = urb->dev;
3128
3129 while (dev->parent) {
3130
3131
3132
3133
3134 if (dev->parent->speed == USB_SPEED_HIGH) {
3135 split_device = dev->parent->devnum;
3136 split_port = dev->portnum;
3137 break;
3138 }
3139
3140
3141
3142
3143
3144
3145 dev = dev->parent;
3146 }
3147 }
3148 pipe = cvmx_usb_open_pipe(usb, usb_pipedevice(urb->pipe),
3149 usb_pipeendpoint(urb->pipe), speed,
3150 le16_to_cpu(ep->desc.wMaxPacketSize)
3151 & 0x7ff,
3152 transfer_type,
3153 usb_pipein(urb->pipe) ?
3154 CVMX_USB_DIRECTION_IN :
3155 CVMX_USB_DIRECTION_OUT,
3156 urb->interval,
3157 (le16_to_cpu(ep->desc.wMaxPacketSize)
3158 >> 11) & 0x3,
3159 split_device, split_port);
3160 if (!pipe) {
3161 usb_hcd_unlink_urb_from_ep(hcd, urb);
3162 spin_unlock_irqrestore(&usb->lock, flags);
3163 dev_dbg(dev, "Failed to create pipe\n");
3164 return -ENOMEM;
3165 }
3166 ep->hcpriv = pipe;
3167 } else {
3168 pipe = ep->hcpriv;
3169 }
3170
3171 switch (usb_pipetype(urb->pipe)) {
3172 case PIPE_ISOCHRONOUS:
3173 dev_dbg(dev, "Submit isochronous to %d.%d\n",
3174 usb_pipedevice(urb->pipe),
3175 usb_pipeendpoint(urb->pipe));
3176
3177
3178
3179
3180 iso_packet = kmalloc_array(urb->number_of_packets,
3181 sizeof(struct cvmx_usb_iso_packet),
3182 GFP_ATOMIC);
3183 if (iso_packet) {
3184 int i;
3185
3186 for (i = 0; i < urb->number_of_packets; i++) {
3187 iso_packet[i].offset =
3188 urb->iso_frame_desc[i].offset;
3189 iso_packet[i].length =
3190 urb->iso_frame_desc[i].length;
3191 iso_packet[i].status = CVMX_USB_STATUS_ERROR;
3192 }
3193
3194
3195
3196
3197
3198 urb->setup_packet = (char *)iso_packet;
3199 transaction = cvmx_usb_submit_isochronous(usb,
3200 pipe, urb);
3201
3202
3203
3204
3205 if (!transaction) {
3206 urb->setup_packet = NULL;
3207 kfree(iso_packet);
3208 }
3209 }
3210 break;
3211 case PIPE_INTERRUPT:
3212 dev_dbg(dev, "Submit interrupt to %d.%d\n",
3213 usb_pipedevice(urb->pipe),
3214 usb_pipeendpoint(urb->pipe));
3215 transaction = cvmx_usb_submit_interrupt(usb, pipe, urb);
3216 break;
3217 case PIPE_CONTROL:
3218 dev_dbg(dev, "Submit control to %d.%d\n",
3219 usb_pipedevice(urb->pipe),
3220 usb_pipeendpoint(urb->pipe));
3221 transaction = cvmx_usb_submit_control(usb, pipe, urb);
3222 break;
3223 case PIPE_BULK:
3224 dev_dbg(dev, "Submit bulk to %d.%d\n",
3225 usb_pipedevice(urb->pipe),
3226 usb_pipeendpoint(urb->pipe));
3227 transaction = cvmx_usb_submit_bulk(usb, pipe, urb);
3228 break;
3229 }
3230 if (!transaction) {
3231 usb_hcd_unlink_urb_from_ep(hcd, urb);
3232 spin_unlock_irqrestore(&usb->lock, flags);
3233 dev_dbg(dev, "Failed to submit\n");
3234 return -ENOMEM;
3235 }
3236 urb->hcpriv = transaction;
3237 spin_unlock_irqrestore(&usb->lock, flags);
3238 return 0;
3239}
3240
3241static int octeon_usb_urb_dequeue(struct usb_hcd *hcd,
3242 struct urb *urb,
3243 int status)
3244{
3245 struct octeon_hcd *usb = hcd_to_octeon(hcd);
3246 unsigned long flags;
3247 int rc;
3248
3249 if (!urb->dev)
3250 return -EINVAL;
3251
3252 spin_lock_irqsave(&usb->lock, flags);
3253
3254 rc = usb_hcd_check_unlink_urb(hcd, urb, status);
3255 if (rc)
3256 goto out;
3257
3258 urb->status = status;
3259 cvmx_usb_cancel(usb, urb->ep->hcpriv, urb->hcpriv);
3260
3261out:
3262 spin_unlock_irqrestore(&usb->lock, flags);
3263
3264 return rc;
3265}
3266
3267static void octeon_usb_endpoint_disable(struct usb_hcd *hcd,
3268 struct usb_host_endpoint *ep)
3269{
3270 struct device *dev = hcd->self.controller;
3271
3272 if (ep->hcpriv) {
3273 struct octeon_hcd *usb = hcd_to_octeon(hcd);
3274 struct cvmx_usb_pipe *pipe = ep->hcpriv;
3275 unsigned long flags;
3276
3277 spin_lock_irqsave(&usb->lock, flags);
3278 cvmx_usb_cancel_all(usb, pipe);
3279 if (cvmx_usb_close_pipe(usb, pipe))
3280 dev_dbg(dev, "Closing pipe %p failed\n", pipe);
3281 spin_unlock_irqrestore(&usb->lock, flags);
3282 ep->hcpriv = NULL;
3283 }
3284}
3285
3286static int octeon_usb_hub_status_data(struct usb_hcd *hcd, char *buf)
3287{
3288 struct octeon_hcd *usb = hcd_to_octeon(hcd);
3289 struct cvmx_usb_port_status port_status;
3290 unsigned long flags;
3291
3292 spin_lock_irqsave(&usb->lock, flags);
3293 port_status = cvmx_usb_get_status(usb);
3294 spin_unlock_irqrestore(&usb->lock, flags);
3295 buf[0] = port_status.connect_change << 1;
3296
3297 return buf[0] != 0;
3298}
3299
3300static int octeon_usb_hub_control(struct usb_hcd *hcd, u16 typeReq, u16 wValue,
3301 u16 wIndex, char *buf, u16 wLength)
3302{
3303 struct octeon_hcd *usb = hcd_to_octeon(hcd);
3304 struct device *dev = hcd->self.controller;
3305 struct cvmx_usb_port_status usb_port_status;
3306 int port_status;
3307 struct usb_hub_descriptor *desc;
3308 unsigned long flags;
3309
3310 switch (typeReq) {
3311 case ClearHubFeature:
3312 dev_dbg(dev, "ClearHubFeature\n");
3313 switch (wValue) {
3314 case C_HUB_LOCAL_POWER:
3315 case C_HUB_OVER_CURRENT:
3316
3317 break;
3318 default:
3319 return -EINVAL;
3320 }
3321 break;
3322 case ClearPortFeature:
3323 dev_dbg(dev, "ClearPortFeature\n");
3324 if (wIndex != 1) {
3325 dev_dbg(dev, " INVALID\n");
3326 return -EINVAL;
3327 }
3328
3329 switch (wValue) {
3330 case USB_PORT_FEAT_ENABLE:
3331 dev_dbg(dev, " ENABLE\n");
3332 spin_lock_irqsave(&usb->lock, flags);
3333 cvmx_usb_disable(usb);
3334 spin_unlock_irqrestore(&usb->lock, flags);
3335 break;
3336 case USB_PORT_FEAT_SUSPEND:
3337 dev_dbg(dev, " SUSPEND\n");
3338
3339 break;
3340 case USB_PORT_FEAT_POWER:
3341 dev_dbg(dev, " POWER\n");
3342
3343 break;
3344 case USB_PORT_FEAT_INDICATOR:
3345 dev_dbg(dev, " INDICATOR\n");
3346
3347 break;
3348 case USB_PORT_FEAT_C_CONNECTION:
3349 dev_dbg(dev, " C_CONNECTION\n");
3350
3351 spin_lock_irqsave(&usb->lock, flags);
3352 usb->port_status = cvmx_usb_get_status(usb);
3353 spin_unlock_irqrestore(&usb->lock, flags);
3354 break;
3355 case USB_PORT_FEAT_C_RESET:
3356 dev_dbg(dev, " C_RESET\n");
3357
3358
3359
3360 spin_lock_irqsave(&usb->lock, flags);
3361 usb->port_status = cvmx_usb_get_status(usb);
3362 spin_unlock_irqrestore(&usb->lock, flags);
3363 break;
3364 case USB_PORT_FEAT_C_ENABLE:
3365 dev_dbg(dev, " C_ENABLE\n");
3366
3367
3368
3369
3370 spin_lock_irqsave(&usb->lock, flags);
3371 usb->port_status = cvmx_usb_get_status(usb);
3372 spin_unlock_irqrestore(&usb->lock, flags);
3373 break;
3374 case USB_PORT_FEAT_C_SUSPEND:
3375 dev_dbg(dev, " C_SUSPEND\n");
3376
3377
3378
3379
3380
3381 break;
3382 case USB_PORT_FEAT_C_OVER_CURRENT:
3383 dev_dbg(dev, " C_OVER_CURRENT\n");
3384
3385 spin_lock_irqsave(&usb->lock, flags);
3386 usb->port_status = cvmx_usb_get_status(usb);
3387 spin_unlock_irqrestore(&usb->lock, flags);
3388 break;
3389 default:
3390 dev_dbg(dev, " UNKNOWN\n");
3391 return -EINVAL;
3392 }
3393 break;
3394 case GetHubDescriptor:
3395 dev_dbg(dev, "GetHubDescriptor\n");
3396 desc = (struct usb_hub_descriptor *)buf;
3397 desc->bDescLength = 9;
3398 desc->bDescriptorType = 0x29;
3399 desc->bNbrPorts = 1;
3400 desc->wHubCharacteristics = cpu_to_le16(0x08);
3401 desc->bPwrOn2PwrGood = 1;
3402 desc->bHubContrCurrent = 0;
3403 desc->u.hs.DeviceRemovable[0] = 0;
3404 desc->u.hs.DeviceRemovable[1] = 0xff;
3405 break;
3406 case GetHubStatus:
3407 dev_dbg(dev, "GetHubStatus\n");
3408 *(__le32 *)buf = 0;
3409 break;
3410 case GetPortStatus:
3411 dev_dbg(dev, "GetPortStatus\n");
3412 if (wIndex != 1) {
3413 dev_dbg(dev, " INVALID\n");
3414 return -EINVAL;
3415 }
3416
3417 spin_lock_irqsave(&usb->lock, flags);
3418 usb_port_status = cvmx_usb_get_status(usb);
3419 spin_unlock_irqrestore(&usb->lock, flags);
3420 port_status = 0;
3421
3422 if (usb_port_status.connect_change) {
3423 port_status |= (1 << USB_PORT_FEAT_C_CONNECTION);
3424 dev_dbg(dev, " C_CONNECTION\n");
3425 }
3426
3427 if (usb_port_status.port_enabled) {
3428 port_status |= (1 << USB_PORT_FEAT_C_ENABLE);
3429 dev_dbg(dev, " C_ENABLE\n");
3430 }
3431
3432 if (usb_port_status.connected) {
3433 port_status |= (1 << USB_PORT_FEAT_CONNECTION);
3434 dev_dbg(dev, " CONNECTION\n");
3435 }
3436
3437 if (usb_port_status.port_enabled) {
3438 port_status |= (1 << USB_PORT_FEAT_ENABLE);
3439 dev_dbg(dev, " ENABLE\n");
3440 }
3441
3442 if (usb_port_status.port_over_current) {
3443 port_status |= (1 << USB_PORT_FEAT_OVER_CURRENT);
3444 dev_dbg(dev, " OVER_CURRENT\n");
3445 }
3446
3447 if (usb_port_status.port_powered) {
3448 port_status |= (1 << USB_PORT_FEAT_POWER);
3449 dev_dbg(dev, " POWER\n");
3450 }
3451
3452 if (usb_port_status.port_speed == CVMX_USB_SPEED_HIGH) {
3453 port_status |= USB_PORT_STAT_HIGH_SPEED;
3454 dev_dbg(dev, " HIGHSPEED\n");
3455 } else if (usb_port_status.port_speed == CVMX_USB_SPEED_LOW) {
3456 port_status |= (1 << USB_PORT_FEAT_LOWSPEED);
3457 dev_dbg(dev, " LOWSPEED\n");
3458 }
3459
3460 *((__le32 *)buf) = cpu_to_le32(port_status);
3461 break;
3462 case SetHubFeature:
3463 dev_dbg(dev, "SetHubFeature\n");
3464
3465 break;
3466 case SetPortFeature:
3467 dev_dbg(dev, "SetPortFeature\n");
3468 if (wIndex != 1) {
3469 dev_dbg(dev, " INVALID\n");
3470 return -EINVAL;
3471 }
3472
3473 switch (wValue) {
3474 case USB_PORT_FEAT_SUSPEND:
3475 dev_dbg(dev, " SUSPEND\n");
3476 return -EINVAL;
3477 case USB_PORT_FEAT_POWER:
3478 dev_dbg(dev, " POWER\n");
3479
3480
3481
3482 spin_lock_irqsave(&usb->lock, flags);
3483 USB_SET_FIELD32(CVMX_USBCX_HPRT(usb->index),
3484 cvmx_usbcx_hprt, prtpwr, 1);
3485 spin_unlock_irqrestore(&usb->lock, flags);
3486 return 0;
3487 case USB_PORT_FEAT_RESET:
3488 dev_dbg(dev, " RESET\n");
3489 spin_lock_irqsave(&usb->lock, flags);
3490 cvmx_usb_reset_port(usb);
3491 spin_unlock_irqrestore(&usb->lock, flags);
3492 return 0;
3493 case USB_PORT_FEAT_INDICATOR:
3494 dev_dbg(dev, " INDICATOR\n");
3495
3496 break;
3497 default:
3498 dev_dbg(dev, " UNKNOWN\n");
3499 return -EINVAL;
3500 }
3501 break;
3502 default:
3503 dev_dbg(dev, "Unknown root hub request\n");
3504 return -EINVAL;
3505 }
3506 return 0;
3507}
3508
3509static const struct hc_driver octeon_hc_driver = {
3510 .description = "Octeon USB",
3511 .product_desc = "Octeon Host Controller",
3512 .hcd_priv_size = sizeof(struct octeon_hcd),
3513 .irq = octeon_usb_irq,
3514 .flags = HCD_MEMORY | HCD_DMA | HCD_USB2,
3515 .start = octeon_usb_start,
3516 .stop = octeon_usb_stop,
3517 .urb_enqueue = octeon_usb_urb_enqueue,
3518 .urb_dequeue = octeon_usb_urb_dequeue,
3519 .endpoint_disable = octeon_usb_endpoint_disable,
3520 .get_frame_number = octeon_usb_get_frame_number,
3521 .hub_status_data = octeon_usb_hub_status_data,
3522 .hub_control = octeon_usb_hub_control,
3523 .map_urb_for_dma = octeon_map_urb_for_dma,
3524 .unmap_urb_for_dma = octeon_unmap_urb_for_dma,
3525};
3526
3527static int octeon_usb_probe(struct platform_device *pdev)
3528{
3529 int status;
3530 int initialize_flags;
3531 int usb_num;
3532 struct resource *res_mem;
3533 struct device_node *usbn_node;
3534 int irq = platform_get_irq(pdev, 0);
3535 struct device *dev = &pdev->dev;
3536 struct octeon_hcd *usb;
3537 struct usb_hcd *hcd;
3538 u32 clock_rate = 48000000;
3539 bool is_crystal_clock = false;
3540 const char *clock_type;
3541 int i;
3542
3543 if (!dev->of_node) {
3544 dev_err(dev, "Error: empty of_node\n");
3545 return -ENXIO;
3546 }
3547 usbn_node = dev->of_node->parent;
3548
3549 i = of_property_read_u32(usbn_node,
3550 "clock-frequency", &clock_rate);
3551 if (i)
3552 i = of_property_read_u32(usbn_node,
3553 "refclk-frequency", &clock_rate);
3554 if (i) {
3555 dev_err(dev, "No USBN \"clock-frequency\"\n");
3556 return -ENXIO;
3557 }
3558 switch (clock_rate) {
3559 case 12000000:
3560 initialize_flags = CVMX_USB_INITIALIZE_FLAGS_CLOCK_12MHZ;
3561 break;
3562 case 24000000:
3563 initialize_flags = CVMX_USB_INITIALIZE_FLAGS_CLOCK_24MHZ;
3564 break;
3565 case 48000000:
3566 initialize_flags = CVMX_USB_INITIALIZE_FLAGS_CLOCK_48MHZ;
3567 break;
3568 default:
3569 dev_err(dev, "Illegal USBN \"clock-frequency\" %u\n",
3570 clock_rate);
3571 return -ENXIO;
3572 }
3573
3574 i = of_property_read_string(usbn_node,
3575 "cavium,refclk-type", &clock_type);
3576 if (i)
3577 i = of_property_read_string(usbn_node,
3578 "refclk-type", &clock_type);
3579
3580 if (!i && strcmp("crystal", clock_type) == 0)
3581 is_crystal_clock = true;
3582
3583 if (is_crystal_clock)
3584 initialize_flags |= CVMX_USB_INITIALIZE_FLAGS_CLOCK_XO_XI;
3585 else
3586 initialize_flags |= CVMX_USB_INITIALIZE_FLAGS_CLOCK_XO_GND;
3587
3588 res_mem = platform_get_resource(pdev, IORESOURCE_MEM, 0);
3589 if (!res_mem) {
3590 dev_err(dev, "found no memory resource\n");
3591 return -ENXIO;
3592 }
3593 usb_num = (res_mem->start >> 44) & 1;
3594
3595 if (irq < 0) {
3596
3597 irq_hw_number_t hwirq = usb_num ? (1 << 6) + 17 : 56;
3598
3599 irq = irq_create_mapping(NULL, hwirq);
3600 }
3601
3602
3603
3604
3605
3606 i = dma_coerce_mask_and_coherent(dev, DMA_BIT_MASK(64));
3607 if (i)
3608 return i;
3609
3610
3611
3612
3613
3614
3615
3616
3617
3618
3619
3620
3621 if (OCTEON_IS_MODEL(OCTEON_CN52XX) || OCTEON_IS_MODEL(OCTEON_CN56XX)) {
3622 union cvmx_iob_n2c_l2c_pri_cnt pri_cnt;
3623
3624 pri_cnt.u64 = 0;
3625 pri_cnt.s.cnt_enb = 1;
3626 pri_cnt.s.cnt_val = 400;
3627 cvmx_write_csr(CVMX_IOB_N2C_L2C_PRI_CNT, pri_cnt.u64);
3628 }
3629
3630 hcd = usb_create_hcd(&octeon_hc_driver, dev, dev_name(dev));
3631 if (!hcd) {
3632 dev_dbg(dev, "Failed to allocate memory for HCD\n");
3633 return -1;
3634 }
3635 hcd->uses_new_polling = 1;
3636 usb = (struct octeon_hcd *)hcd->hcd_priv;
3637
3638 spin_lock_init(&usb->lock);
3639
3640 usb->init_flags = initialize_flags;
3641
3642
3643 usb->index = usb_num;
3644 INIT_LIST_HEAD(&usb->idle_pipes);
3645 for (i = 0; i < ARRAY_SIZE(usb->active_pipes); i++)
3646 INIT_LIST_HEAD(&usb->active_pipes[i]);
3647
3648
3649 if (OCTEON_IS_MODEL(OCTEON_CN31XX)) {
3650 usb->init_flags |= CVMX_USB_INITIALIZE_FLAGS_NO_DMA;
3651
3652 usb->idle_hardware_channels = 0x1;
3653 } else if (OCTEON_IS_MODEL(OCTEON_CN5XXX)) {
3654
3655 usb->idle_hardware_channels = 0xf7;
3656 } else {
3657 usb->idle_hardware_channels = 0xff;
3658 }
3659
3660 status = cvmx_usb_initialize(dev, usb);
3661 if (status) {
3662 dev_dbg(dev, "USB initialization failed with %d\n", status);
3663 usb_put_hcd(hcd);
3664 return -1;
3665 }
3666
3667 status = usb_add_hcd(hcd, irq, 0);
3668 if (status) {
3669 dev_dbg(dev, "USB add HCD failed with %d\n", status);
3670 usb_put_hcd(hcd);
3671 return -1;
3672 }
3673 device_wakeup_enable(hcd->self.controller);
3674
3675 dev_info(dev, "Registered HCD for port %d on irq %d\n", usb_num, irq);
3676
3677 return 0;
3678}
3679
3680static int octeon_usb_remove(struct platform_device *pdev)
3681{
3682 int status;
3683 struct device *dev = &pdev->dev;
3684 struct usb_hcd *hcd = dev_get_drvdata(dev);
3685 struct octeon_hcd *usb = hcd_to_octeon(hcd);
3686 unsigned long flags;
3687
3688 usb_remove_hcd(hcd);
3689 spin_lock_irqsave(&usb->lock, flags);
3690 status = cvmx_usb_shutdown(usb);
3691 spin_unlock_irqrestore(&usb->lock, flags);
3692 if (status)
3693 dev_dbg(dev, "USB shutdown failed with %d\n", status);
3694
3695 usb_put_hcd(hcd);
3696
3697 return 0;
3698}
3699
3700static const struct of_device_id octeon_usb_match[] = {
3701 {
3702 .compatible = "cavium,octeon-5750-usbc",
3703 },
3704 {},
3705};
3706MODULE_DEVICE_TABLE(of, octeon_usb_match);
3707
3708static struct platform_driver octeon_usb_driver = {
3709 .driver = {
3710 .name = "octeon-hcd",
3711 .of_match_table = octeon_usb_match,
3712 },
3713 .probe = octeon_usb_probe,
3714 .remove = octeon_usb_remove,
3715};
3716
3717static int __init octeon_usb_driver_init(void)
3718{
3719 if (usb_disabled())
3720 return 0;
3721
3722 return platform_driver_register(&octeon_usb_driver);
3723}
3724module_init(octeon_usb_driver_init);
3725
3726static void __exit octeon_usb_driver_exit(void)
3727{
3728 if (usb_disabled())
3729 return;
3730
3731 platform_driver_unregister(&octeon_usb_driver);
3732}
3733module_exit(octeon_usb_driver_exit);
3734
3735MODULE_LICENSE("GPL");
3736MODULE_AUTHOR("Cavium, Inc. <support@cavium.com>");
3737MODULE_DESCRIPTION("Cavium Inc. OCTEON USB Host driver.");
3738