1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23#include <linux/module.h>
24#include <linux/pci.h>
25#include <linux/dmapool.h>
26#include <linux/kernel.h>
27#include <linux/delay.h>
28#include <linux/ioport.h>
29#include <linux/sched.h>
30#include <linux/vmalloc.h>
31#include <linux/errno.h>
32#include <linux/init.h>
33#include <linux/hrtimer.h>
34#include <linux/list.h>
35#include <linux/interrupt.h>
36#include <linux/usb.h>
37#include <linux/usb/hcd.h>
38#include <linux/moduleparam.h>
39#include <linux/dma-mapping.h>
40#include <linux/debugfs.h>
41#include <linux/slab.h>
42
43#include <asm/byteorder.h>
44#include <asm/io.h>
45#include <asm/irq.h>
46#include <asm/unaligned.h>
47
48#if defined(CONFIG_PPC_PS3)
49#include <asm/firmware.h>
50#endif
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68#define DRIVER_AUTHOR "David Brownell"
69#define DRIVER_DESC "USB 2.0 'Enhanced' Host Controller (EHCI) Driver"
70
71static const char hcd_name [] = "ehci_hcd";
72
73
74#undef VERBOSE_DEBUG
75#undef EHCI_URB_TRACE
76
77
78#define EHCI_TUNE_CERR 3
79#define EHCI_TUNE_RL_HS 4
80#define EHCI_TUNE_RL_TT 0
81#define EHCI_TUNE_MULT_HS 1
82#define EHCI_TUNE_MULT_TT 1
83
84
85
86
87
88
89#define EHCI_TUNE_FLS 1
90
91
92static int log2_irq_thresh = 0;
93module_param (log2_irq_thresh, int, S_IRUGO);
94MODULE_PARM_DESC (log2_irq_thresh, "log2 IRQ latency, 1-64 microframes");
95
96
97static unsigned park = 0;
98module_param (park, uint, S_IRUGO);
99MODULE_PARM_DESC (park, "park setting; 1-3 back-to-back async packets");
100
101
102static bool ignore_oc = 0;
103module_param (ignore_oc, bool, S_IRUGO);
104MODULE_PARM_DESC (ignore_oc, "ignore bogus hardware overcurrent indications");
105
106#define INTR_MASK (STS_IAA | STS_FATAL | STS_PCD | STS_ERR | STS_INT)
107
108
109
110#include "ehci.h"
111#include "pci-quirks.h"
112
113
114
115
116
117
118
119
120static unsigned ehci_moschip_read_frame_index(struct ehci_hcd *ehci)
121{
122 unsigned uf;
123
124 uf = ehci_readl(ehci, &ehci->regs->frame_index);
125 if (unlikely((uf & 7) == 0))
126 uf = ehci_readl(ehci, &ehci->regs->frame_index);
127 return uf;
128}
129
130static inline unsigned ehci_read_frame_index(struct ehci_hcd *ehci)
131{
132 if (ehci->frame_index_bug)
133 return ehci_moschip_read_frame_index(ehci);
134 return ehci_readl(ehci, &ehci->regs->frame_index);
135}
136
137#include "ehci-dbg.c"
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158static int handshake (struct ehci_hcd *ehci, void __iomem *ptr,
159 u32 mask, u32 done, int usec)
160{
161 u32 result;
162
163 do {
164 result = ehci_readl(ehci, ptr);
165 if (result == ~(u32)0)
166 return -ENODEV;
167 result &= mask;
168 if (result == done)
169 return 0;
170 udelay (1);
171 usec--;
172 } while (usec > 0);
173 return -ETIMEDOUT;
174}
175
176
177static int tdi_in_host_mode (struct ehci_hcd *ehci)
178{
179 u32 tmp;
180
181 tmp = ehci_readl(ehci, &ehci->regs->usbmode);
182 return (tmp & 3) == USBMODE_CM_HC;
183}
184
185
186
187
188
189static int ehci_halt (struct ehci_hcd *ehci)
190{
191 u32 temp;
192
193 spin_lock_irq(&ehci->lock);
194
195
196 ehci_writel(ehci, 0, &ehci->regs->intr_enable);
197
198 if (ehci_is_TDI(ehci) && !tdi_in_host_mode(ehci)) {
199 spin_unlock_irq(&ehci->lock);
200 return 0;
201 }
202
203
204
205
206
207 ehci->command &= ~CMD_RUN;
208 temp = ehci_readl(ehci, &ehci->regs->command);
209 temp &= ~(CMD_RUN | CMD_IAAD);
210 ehci_writel(ehci, temp, &ehci->regs->command);
211
212 spin_unlock_irq(&ehci->lock);
213 synchronize_irq(ehci_to_hcd(ehci)->irq);
214
215 return handshake(ehci, &ehci->regs->status,
216 STS_HALT, STS_HALT, 16 * 125);
217}
218
219
220static void tdi_reset (struct ehci_hcd *ehci)
221{
222 u32 tmp;
223
224 tmp = ehci_readl(ehci, &ehci->regs->usbmode);
225 tmp |= USBMODE_CM_HC;
226
227
228
229
230 if (ehci_big_endian_mmio(ehci))
231 tmp |= USBMODE_BE;
232 ehci_writel(ehci, tmp, &ehci->regs->usbmode);
233}
234
235
236
237
238
239static int ehci_reset (struct ehci_hcd *ehci)
240{
241 int retval;
242 u32 command = ehci_readl(ehci, &ehci->regs->command);
243
244
245
246 if (ehci->debug && !dbgp_reset_prep(ehci_to_hcd(ehci)))
247 ehci->debug = NULL;
248
249 command |= CMD_RESET;
250 dbg_cmd (ehci, "reset", command);
251 ehci_writel(ehci, command, &ehci->regs->command);
252 ehci->rh_state = EHCI_RH_HALTED;
253 ehci->next_statechange = jiffies;
254 retval = handshake (ehci, &ehci->regs->command,
255 CMD_RESET, 0, 250 * 1000);
256
257 if (ehci->has_hostpc) {
258 ehci_writel(ehci, USBMODE_EX_HC | USBMODE_EX_VBPS,
259 &ehci->regs->usbmode_ex);
260 ehci_writel(ehci, TXFIFO_DEFAULT, &ehci->regs->txfill_tuning);
261 }
262 if (retval)
263 return retval;
264
265 if (ehci_is_TDI(ehci))
266 tdi_reset (ehci);
267
268 if (ehci->debug)
269 dbgp_external_startup(ehci_to_hcd(ehci));
270
271 ehci->port_c_suspend = ehci->suspended_ports =
272 ehci->resuming_ports = 0;
273 return retval;
274}
275
276
277
278
279
280static void ehci_quiesce (struct ehci_hcd *ehci)
281{
282 u32 temp;
283
284 if (ehci->rh_state != EHCI_RH_RUNNING)
285 return;
286
287
288 temp = (ehci->command << 10) & (STS_ASS | STS_PSS);
289 handshake(ehci, &ehci->regs->status, STS_ASS | STS_PSS, temp, 16 * 125);
290
291
292 spin_lock_irq(&ehci->lock);
293 ehci->command &= ~(CMD_ASE | CMD_PSE);
294 ehci_writel(ehci, ehci->command, &ehci->regs->command);
295 spin_unlock_irq(&ehci->lock);
296
297
298 handshake(ehci, &ehci->regs->status, STS_ASS | STS_PSS, 0, 16 * 125);
299}
300
301
302
303static void end_unlink_async(struct ehci_hcd *ehci);
304static void unlink_empty_async(struct ehci_hcd *ehci);
305static void unlink_empty_async_suspended(struct ehci_hcd *ehci);
306static void ehci_work(struct ehci_hcd *ehci);
307static void start_unlink_intr(struct ehci_hcd *ehci, struct ehci_qh *qh);
308static void end_unlink_intr(struct ehci_hcd *ehci, struct ehci_qh *qh);
309
310#include "ehci-timer.c"
311#include "ehci-hub.c"
312#include "ehci-mem.c"
313#include "ehci-q.c"
314#include "ehci-sched.c"
315#include "ehci-sysfs.c"
316
317
318
319
320
321
322
323static void ehci_turn_off_all_ports(struct ehci_hcd *ehci)
324{
325 int port = HCS_N_PORTS(ehci->hcs_params);
326
327 while (port--)
328 ehci_writel(ehci, PORT_RWC_BITS,
329 &ehci->regs->port_status[port]);
330}
331
332
333
334
335
336static void ehci_silence_controller(struct ehci_hcd *ehci)
337{
338 ehci_halt(ehci);
339
340 spin_lock_irq(&ehci->lock);
341 ehci->rh_state = EHCI_RH_HALTED;
342 ehci_turn_off_all_ports(ehci);
343
344
345 ehci_writel(ehci, 0, &ehci->regs->configured_flag);
346
347
348 ehci_readl(ehci, &ehci->regs->configured_flag);
349 spin_unlock_irq(&ehci->lock);
350}
351
352
353
354
355
356static void ehci_shutdown(struct usb_hcd *hcd)
357{
358 struct ehci_hcd *ehci = hcd_to_ehci(hcd);
359
360 spin_lock_irq(&ehci->lock);
361 ehci->shutdown = true;
362 ehci->rh_state = EHCI_RH_STOPPING;
363 ehci->enabled_hrtimer_events = 0;
364 spin_unlock_irq(&ehci->lock);
365
366 ehci_silence_controller(ehci);
367
368 hrtimer_cancel(&ehci->hrtimer);
369}
370
371
372
373
374
375
376
377static void ehci_work (struct ehci_hcd *ehci)
378{
379
380
381
382
383 if (ehci->scanning) {
384 ehci->need_rescan = true;
385 return;
386 }
387 ehci->scanning = true;
388
389 rescan:
390 ehci->need_rescan = false;
391 if (ehci->async_count)
392 scan_async(ehci);
393 if (ehci->intr_count > 0)
394 scan_intr(ehci);
395 if (ehci->isoc_count > 0)
396 scan_isoc(ehci);
397 if (ehci->need_rescan)
398 goto rescan;
399 ehci->scanning = false;
400
401
402
403
404
405 turn_on_io_watchdog(ehci);
406}
407
408
409
410
411static void ehci_stop (struct usb_hcd *hcd)
412{
413 struct ehci_hcd *ehci = hcd_to_ehci (hcd);
414
415 ehci_dbg (ehci, "stop\n");
416
417
418
419 spin_lock_irq(&ehci->lock);
420 ehci->enabled_hrtimer_events = 0;
421 spin_unlock_irq(&ehci->lock);
422
423 ehci_quiesce(ehci);
424 ehci_silence_controller(ehci);
425 ehci_reset (ehci);
426
427 hrtimer_cancel(&ehci->hrtimer);
428 remove_sysfs_files(ehci);
429 remove_debug_files (ehci);
430
431
432 spin_lock_irq (&ehci->lock);
433 end_free_itds(ehci);
434 spin_unlock_irq (&ehci->lock);
435 ehci_mem_cleanup (ehci);
436
437 if (ehci->amd_pll_fix == 1)
438 usb_amd_dev_put();
439
440#ifdef EHCI_STATS
441 ehci_dbg(ehci, "irq normal %ld err %ld iaa %ld (lost %ld)\n",
442 ehci->stats.normal, ehci->stats.error, ehci->stats.iaa,
443 ehci->stats.lost_iaa);
444 ehci_dbg (ehci, "complete %ld unlink %ld\n",
445 ehci->stats.complete, ehci->stats.unlink);
446#endif
447
448 dbg_status (ehci, "ehci_stop completed",
449 ehci_readl(ehci, &ehci->regs->status));
450}
451
452
453static int ehci_init(struct usb_hcd *hcd)
454{
455 struct ehci_hcd *ehci = hcd_to_ehci(hcd);
456 u32 temp;
457 int retval;
458 u32 hcc_params;
459 struct ehci_qh_hw *hw;
460
461 spin_lock_init(&ehci->lock);
462
463
464
465
466 ehci->need_io_watchdog = 1;
467
468 hrtimer_init(&ehci->hrtimer, CLOCK_MONOTONIC, HRTIMER_MODE_ABS);
469 ehci->hrtimer.function = ehci_hrtimer_func;
470 ehci->next_hrtimer_event = EHCI_HRTIMER_NO_EVENT;
471
472 hcc_params = ehci_readl(ehci, &ehci->caps->hcc_params);
473
474
475
476
477
478 ehci->uframe_periodic_max = 100;
479
480
481
482
483
484 ehci->periodic_size = DEFAULT_I_TDPS;
485 INIT_LIST_HEAD(&ehci->intr_qh_list);
486 INIT_LIST_HEAD(&ehci->cached_itd_list);
487 INIT_LIST_HEAD(&ehci->cached_sitd_list);
488
489 if (HCC_PGM_FRAMELISTLEN(hcc_params)) {
490
491 switch (EHCI_TUNE_FLS) {
492 case 0: ehci->periodic_size = 1024; break;
493 case 1: ehci->periodic_size = 512; break;
494 case 2: ehci->periodic_size = 256; break;
495 default: BUG();
496 }
497 }
498 if ((retval = ehci_mem_init(ehci, GFP_KERNEL)) < 0)
499 return retval;
500
501
502 if (HCC_ISOC_CACHE(hcc_params))
503 ehci->i_thresh = 0;
504 else
505 ehci->i_thresh = 2 + HCC_ISOC_THRES(hcc_params);
506
507
508
509
510
511
512
513
514 ehci->async->qh_next.qh = NULL;
515 hw = ehci->async->hw;
516 hw->hw_next = QH_NEXT(ehci, ehci->async->qh_dma);
517 hw->hw_info1 = cpu_to_hc32(ehci, QH_HEAD);
518#if defined(CONFIG_PPC_PS3)
519 hw->hw_info1 |= cpu_to_hc32(ehci, QH_INACTIVATE);
520#endif
521 hw->hw_token = cpu_to_hc32(ehci, QTD_STS_HALT);
522 hw->hw_qtd_next = EHCI_LIST_END(ehci);
523 ehci->async->qh_state = QH_STATE_LINKED;
524 hw->hw_alt_next = QTD_NEXT(ehci, ehci->async->dummy->qtd_dma);
525
526
527 if (log2_irq_thresh < 0 || log2_irq_thresh > 6)
528 log2_irq_thresh = 0;
529 temp = 1 << (16 + log2_irq_thresh);
530 if (HCC_PER_PORT_CHANGE_EVENT(hcc_params)) {
531 ehci->has_ppcd = 1;
532 ehci_dbg(ehci, "enable per-port change event\n");
533 temp |= CMD_PPCEE;
534 }
535 if (HCC_CANPARK(hcc_params)) {
536
537
538
539
540
541
542
543 if (park) {
544 park = min(park, (unsigned) 3);
545 temp |= CMD_PARK;
546 temp |= park << 8;
547 }
548 ehci_dbg(ehci, "park %d\n", park);
549 }
550 if (HCC_PGM_FRAMELISTLEN(hcc_params)) {
551
552 temp &= ~(3 << 2);
553 temp |= (EHCI_TUNE_FLS << 2);
554 }
555 ehci->command = temp;
556
557
558 if (!(hcd->driver->flags & HCD_LOCAL_MEM))
559 hcd->self.sg_tablesize = ~0;
560 return 0;
561}
562
563
564static int ehci_run (struct usb_hcd *hcd)
565{
566 struct ehci_hcd *ehci = hcd_to_ehci (hcd);
567 u32 temp;
568 u32 hcc_params;
569
570 hcd->uses_new_polling = 1;
571
572
573
574 ehci_writel(ehci, ehci->periodic_dma, &ehci->regs->frame_list);
575 ehci_writel(ehci, (u32)ehci->async->qh_dma, &ehci->regs->async_next);
576
577
578
579
580
581
582
583
584
585
586
587
588
589 hcc_params = ehci_readl(ehci, &ehci->caps->hcc_params);
590 if (HCC_64BIT_ADDR(hcc_params)) {
591 ehci_writel(ehci, 0, &ehci->regs->segment);
592#if 0
593
594 if (!dma_set_mask(hcd->self.controller, DMA_BIT_MASK(64)))
595 ehci_info(ehci, "enabled 64bit DMA\n");
596#endif
597 }
598
599
600
601
602 ehci->command &= ~(CMD_LRESET|CMD_IAAD|CMD_PSE|CMD_ASE|CMD_RESET);
603 ehci->command |= CMD_RUN;
604 ehci_writel(ehci, ehci->command, &ehci->regs->command);
605 dbg_cmd (ehci, "init", ehci->command);
606
607
608
609
610
611
612
613
614
615
616
617
618
619
620
621 down_write(&ehci_cf_port_reset_rwsem);
622 ehci->rh_state = EHCI_RH_RUNNING;
623 ehci_writel(ehci, FLAG_CF, &ehci->regs->configured_flag);
624 ehci_readl(ehci, &ehci->regs->command);
625 msleep(5);
626 up_write(&ehci_cf_port_reset_rwsem);
627 ehci->last_periodic_enable = ktime_get_real();
628
629 temp = HC_VERSION(ehci, ehci_readl(ehci, &ehci->caps->hc_capbase));
630 ehci_info (ehci,
631 "USB %x.%x started, EHCI %x.%02x%s\n",
632 ((ehci->sbrn & 0xf0)>>4), (ehci->sbrn & 0x0f),
633 temp >> 8, temp & 0xff,
634 ignore_oc ? ", overcurrent ignored" : "");
635
636 ehci_writel(ehci, INTR_MASK,
637 &ehci->regs->intr_enable);
638
639
640
641
642
643 create_debug_files(ehci);
644 create_sysfs_files(ehci);
645
646 return 0;
647}
648
649int ehci_setup(struct usb_hcd *hcd)
650{
651 struct ehci_hcd *ehci = hcd_to_ehci(hcd);
652 int retval;
653
654 ehci->regs = (void __iomem *)ehci->caps +
655 HC_LENGTH(ehci, ehci_readl(ehci, &ehci->caps->hc_capbase));
656 dbg_hcs_params(ehci, "reset");
657 dbg_hcc_params(ehci, "reset");
658
659
660 ehci->hcs_params = ehci_readl(ehci, &ehci->caps->hcs_params);
661
662 ehci->sbrn = HCD_USB2;
663
664
665 retval = ehci_init(hcd);
666 if (retval)
667 return retval;
668
669 retval = ehci_halt(ehci);
670 if (retval)
671 return retval;
672
673 ehci_reset(ehci);
674
675 return 0;
676}
677EXPORT_SYMBOL_GPL(ehci_setup);
678
679
680
681static irqreturn_t ehci_irq (struct usb_hcd *hcd)
682{
683 struct ehci_hcd *ehci = hcd_to_ehci (hcd);
684 u32 status, masked_status, pcd_status = 0, cmd;
685 int bh;
686
687 spin_lock (&ehci->lock);
688
689 status = ehci_readl(ehci, &ehci->regs->status);
690
691
692 if (status == ~(u32) 0) {
693 ehci_dbg (ehci, "device removed\n");
694 goto dead;
695 }
696
697
698
699
700
701 masked_status = status & (INTR_MASK | STS_FLR);
702
703
704 if (!masked_status || unlikely(ehci->rh_state == EHCI_RH_HALTED)) {
705 spin_unlock(&ehci->lock);
706 return IRQ_NONE;
707 }
708
709
710 ehci_writel(ehci, masked_status, &ehci->regs->status);
711 cmd = ehci_readl(ehci, &ehci->regs->command);
712 bh = 0;
713
714#ifdef VERBOSE_DEBUG
715
716 dbg_status (ehci, "irq", status);
717#endif
718
719
720
721
722 if (likely ((status & (STS_INT|STS_ERR)) != 0)) {
723 if (likely ((status & STS_ERR) == 0))
724 COUNT (ehci->stats.normal);
725 else
726 COUNT (ehci->stats.error);
727 bh = 1;
728 }
729
730
731 if (status & STS_IAA) {
732
733
734 ehci->enabled_hrtimer_events &= ~BIT(EHCI_HRTIMER_IAA_WATCHDOG);
735
736
737
738
739
740
741
742
743 if (ehci->next_hrtimer_event == EHCI_HRTIMER_IAA_WATCHDOG)
744 ++ehci->next_hrtimer_event;
745
746
747 if (cmd & CMD_IAAD)
748 ehci_dbg(ehci, "IAA with IAAD still set?\n");
749 if (ehci->async_iaa)
750 COUNT(ehci->stats.iaa);
751 end_unlink_async(ehci);
752 }
753
754
755 if (status & STS_PCD) {
756 unsigned i = HCS_N_PORTS (ehci->hcs_params);
757 u32 ppcd = 0;
758
759
760 pcd_status = status;
761
762
763 if (ehci->rh_state == EHCI_RH_SUSPENDED)
764 usb_hcd_resume_root_hub(hcd);
765
766
767 if (ehci->has_ppcd)
768 ppcd = status >> 16;
769
770 while (i--) {
771 int pstatus;
772
773
774 if (ehci->has_ppcd && !(ppcd & (1 << i)))
775 continue;
776 pstatus = ehci_readl(ehci,
777 &ehci->regs->port_status[i]);
778
779 if (pstatus & PORT_OWNER)
780 continue;
781 if (!(test_bit(i, &ehci->suspended_ports) &&
782 ((pstatus & PORT_RESUME) ||
783 !(pstatus & PORT_SUSPEND)) &&
784 (pstatus & PORT_PE) &&
785 ehci->reset_done[i] == 0))
786 continue;
787
788
789
790
791
792
793 ehci->reset_done[i] = jiffies + msecs_to_jiffies(25);
794 set_bit(i, &ehci->resuming_ports);
795 ehci_dbg (ehci, "port %d remote wakeup\n", i + 1);
796 usb_hcd_start_port_resume(&hcd->self, i);
797 mod_timer(&hcd->rh_timer, ehci->reset_done[i]);
798 }
799 }
800
801
802 if (unlikely ((status & STS_FATAL) != 0)) {
803 ehci_err(ehci, "fatal error\n");
804 dbg_cmd(ehci, "fatal", cmd);
805 dbg_status(ehci, "fatal", status);
806dead:
807 usb_hc_died(hcd);
808
809
810 ehci->shutdown = true;
811 ehci->rh_state = EHCI_RH_STOPPING;
812 ehci->command &= ~(CMD_RUN | CMD_ASE | CMD_PSE);
813 ehci_writel(ehci, ehci->command, &ehci->regs->command);
814 ehci_writel(ehci, 0, &ehci->regs->intr_enable);
815 ehci_handle_controller_death(ehci);
816
817
818 bh = 0;
819 }
820
821 if (bh)
822 ehci_work (ehci);
823 spin_unlock (&ehci->lock);
824 if (pcd_status)
825 usb_hcd_poll_rh_status(hcd);
826 return IRQ_HANDLED;
827}
828
829
830
831
832
833
834
835
836
837
838
839
840
841
842
843static int ehci_urb_enqueue (
844 struct usb_hcd *hcd,
845 struct urb *urb,
846 gfp_t mem_flags
847) {
848 struct ehci_hcd *ehci = hcd_to_ehci (hcd);
849 struct list_head qtd_list;
850
851 INIT_LIST_HEAD (&qtd_list);
852
853 switch (usb_pipetype (urb->pipe)) {
854 case PIPE_CONTROL:
855
856
857
858 if (urb->transfer_buffer_length > (16 * 1024))
859 return -EMSGSIZE;
860
861
862 default:
863 if (!qh_urb_transaction (ehci, urb, &qtd_list, mem_flags))
864 return -ENOMEM;
865 return submit_async(ehci, urb, &qtd_list, mem_flags);
866
867 case PIPE_INTERRUPT:
868 if (!qh_urb_transaction (ehci, urb, &qtd_list, mem_flags))
869 return -ENOMEM;
870 return intr_submit(ehci, urb, &qtd_list, mem_flags);
871
872 case PIPE_ISOCHRONOUS:
873 if (urb->dev->speed == USB_SPEED_HIGH)
874 return itd_submit (ehci, urb, mem_flags);
875 else
876 return sitd_submit (ehci, urb, mem_flags);
877 }
878}
879
880
881
882
883
884static int ehci_urb_dequeue(struct usb_hcd *hcd, struct urb *urb, int status)
885{
886 struct ehci_hcd *ehci = hcd_to_ehci (hcd);
887 struct ehci_qh *qh;
888 unsigned long flags;
889 int rc;
890
891 spin_lock_irqsave (&ehci->lock, flags);
892 rc = usb_hcd_check_unlink_urb(hcd, urb, status);
893 if (rc)
894 goto done;
895
896 switch (usb_pipetype (urb->pipe)) {
897
898
899 default:
900 qh = (struct ehci_qh *) urb->hcpriv;
901 if (!qh)
902 break;
903 switch (qh->qh_state) {
904 case QH_STATE_LINKED:
905 case QH_STATE_COMPLETING:
906 start_unlink_async(ehci, qh);
907 break;
908 case QH_STATE_UNLINK:
909 case QH_STATE_UNLINK_WAIT:
910
911 break;
912 case QH_STATE_IDLE:
913
914 qh_completions(ehci, qh);
915 break;
916 }
917 break;
918
919 case PIPE_INTERRUPT:
920 qh = (struct ehci_qh *) urb->hcpriv;
921 if (!qh)
922 break;
923 switch (qh->qh_state) {
924 case QH_STATE_LINKED:
925 case QH_STATE_COMPLETING:
926 start_unlink_intr(ehci, qh);
927 break;
928 case QH_STATE_IDLE:
929 qh_completions (ehci, qh);
930 break;
931 default:
932 ehci_dbg (ehci, "bogus qh %p state %d\n",
933 qh, qh->qh_state);
934 goto done;
935 }
936 break;
937
938 case PIPE_ISOCHRONOUS:
939
940
941
942
943 break;
944 }
945done:
946 spin_unlock_irqrestore (&ehci->lock, flags);
947 return rc;
948}
949
950
951
952
953
954static void
955ehci_endpoint_disable (struct usb_hcd *hcd, struct usb_host_endpoint *ep)
956{
957 struct ehci_hcd *ehci = hcd_to_ehci (hcd);
958 unsigned long flags;
959 struct ehci_qh *qh, *tmp;
960
961
962
963
964rescan:
965 spin_lock_irqsave (&ehci->lock, flags);
966 qh = ep->hcpriv;
967 if (!qh)
968 goto done;
969
970
971
972
973 if (qh->hw == NULL) {
974 struct ehci_iso_stream *stream = ep->hcpriv;
975
976 if (!list_empty(&stream->td_list))
977 goto idle_timeout;
978
979
980 kfree(stream);
981 goto done;
982 }
983
984 if (ehci->rh_state < EHCI_RH_RUNNING)
985 qh->qh_state = QH_STATE_IDLE;
986 switch (qh->qh_state) {
987 case QH_STATE_LINKED:
988 case QH_STATE_COMPLETING:
989 for (tmp = ehci->async->qh_next.qh;
990 tmp && tmp != qh;
991 tmp = tmp->qh_next.qh)
992 continue;
993
994
995
996 if (tmp)
997 start_unlink_async(ehci, qh);
998
999 case QH_STATE_UNLINK:
1000 case QH_STATE_UNLINK_WAIT:
1001idle_timeout:
1002 spin_unlock_irqrestore (&ehci->lock, flags);
1003 schedule_timeout_uninterruptible(1);
1004 goto rescan;
1005 case QH_STATE_IDLE:
1006 if (qh->clearing_tt)
1007 goto idle_timeout;
1008 if (list_empty (&qh->qtd_list)) {
1009 qh_destroy(ehci, qh);
1010 break;
1011 }
1012
1013 default:
1014
1015
1016
1017 ehci_err (ehci, "qh %p (#%02x) state %d%s\n",
1018 qh, ep->desc.bEndpointAddress, qh->qh_state,
1019 list_empty (&qh->qtd_list) ? "" : "(has tds)");
1020 break;
1021 }
1022 done:
1023 ep->hcpriv = NULL;
1024 spin_unlock_irqrestore (&ehci->lock, flags);
1025}
1026
1027static void
1028ehci_endpoint_reset(struct usb_hcd *hcd, struct usb_host_endpoint *ep)
1029{
1030 struct ehci_hcd *ehci = hcd_to_ehci(hcd);
1031 struct ehci_qh *qh;
1032 int eptype = usb_endpoint_type(&ep->desc);
1033 int epnum = usb_endpoint_num(&ep->desc);
1034 int is_out = usb_endpoint_dir_out(&ep->desc);
1035 unsigned long flags;
1036
1037 if (eptype != USB_ENDPOINT_XFER_BULK && eptype != USB_ENDPOINT_XFER_INT)
1038 return;
1039
1040 spin_lock_irqsave(&ehci->lock, flags);
1041 qh = ep->hcpriv;
1042
1043
1044
1045
1046
1047
1048 if (qh) {
1049 usb_settoggle(qh->dev, epnum, is_out, 0);
1050 if (!list_empty(&qh->qtd_list)) {
1051 WARN_ONCE(1, "clear_halt for a busy endpoint\n");
1052 } else if (qh->qh_state == QH_STATE_LINKED ||
1053 qh->qh_state == QH_STATE_COMPLETING) {
1054
1055
1056
1057
1058
1059 if (eptype == USB_ENDPOINT_XFER_BULK)
1060 start_unlink_async(ehci, qh);
1061 else
1062 start_unlink_intr(ehci, qh);
1063 }
1064 }
1065 spin_unlock_irqrestore(&ehci->lock, flags);
1066}
1067
1068static int ehci_get_frame (struct usb_hcd *hcd)
1069{
1070 struct ehci_hcd *ehci = hcd_to_ehci (hcd);
1071 return (ehci_read_frame_index(ehci) >> 3) % ehci->periodic_size;
1072}
1073
1074
1075
1076#ifdef CONFIG_PM
1077
1078
1079
1080
1081
1082int ehci_suspend(struct usb_hcd *hcd, bool do_wakeup)
1083{
1084 struct ehci_hcd *ehci = hcd_to_ehci(hcd);
1085
1086 if (time_before(jiffies, ehci->next_statechange))
1087 msleep(10);
1088
1089
1090
1091
1092
1093
1094 ehci_prepare_ports_for_controller_suspend(ehci, do_wakeup);
1095
1096 spin_lock_irq(&ehci->lock);
1097 ehci_writel(ehci, 0, &ehci->regs->intr_enable);
1098 (void) ehci_readl(ehci, &ehci->regs->intr_enable);
1099
1100 clear_bit(HCD_FLAG_HW_ACCESSIBLE, &hcd->flags);
1101 spin_unlock_irq(&ehci->lock);
1102
1103 return 0;
1104}
1105EXPORT_SYMBOL_GPL(ehci_suspend);
1106
1107
1108int ehci_resume(struct usb_hcd *hcd, bool hibernated)
1109{
1110 struct ehci_hcd *ehci = hcd_to_ehci(hcd);
1111
1112 if (time_before(jiffies, ehci->next_statechange))
1113 msleep(100);
1114
1115
1116 set_bit(HCD_FLAG_HW_ACCESSIBLE, &hcd->flags);
1117
1118 if (ehci->shutdown)
1119 return 0;
1120
1121
1122
1123
1124
1125
1126 if (ehci_readl(ehci, &ehci->regs->configured_flag) == FLAG_CF &&
1127 !hibernated) {
1128 int mask = INTR_MASK;
1129
1130 ehci_prepare_ports_for_controller_resume(ehci);
1131
1132 spin_lock_irq(&ehci->lock);
1133 if (ehci->shutdown)
1134 goto skip;
1135
1136 if (!hcd->self.root_hub->do_remote_wakeup)
1137 mask &= ~STS_PCD;
1138 ehci_writel(ehci, mask, &ehci->regs->intr_enable);
1139 ehci_readl(ehci, &ehci->regs->intr_enable);
1140 skip:
1141 spin_unlock_irq(&ehci->lock);
1142 return 0;
1143 }
1144
1145
1146
1147
1148
1149 usb_root_hub_lost_power(hcd->self.root_hub);
1150 (void) ehci_halt(ehci);
1151 (void) ehci_reset(ehci);
1152
1153 spin_lock_irq(&ehci->lock);
1154 if (ehci->shutdown)
1155 goto skip;
1156
1157 ehci_writel(ehci, ehci->command, &ehci->regs->command);
1158 ehci_writel(ehci, FLAG_CF, &ehci->regs->configured_flag);
1159 ehci_readl(ehci, &ehci->regs->command);
1160
1161 ehci->rh_state = EHCI_RH_SUSPENDED;
1162 spin_unlock_irq(&ehci->lock);
1163
1164 return 1;
1165}
1166EXPORT_SYMBOL_GPL(ehci_resume);
1167
1168#endif
1169
1170
1171
1172
1173
1174
1175
1176
1177static const struct hc_driver ehci_hc_driver = {
1178 .description = hcd_name,
1179 .product_desc = "EHCI Host Controller",
1180 .hcd_priv_size = sizeof(struct ehci_hcd),
1181
1182
1183
1184
1185 .irq = ehci_irq,
1186 .flags = HCD_MEMORY | HCD_USB2,
1187
1188
1189
1190
1191 .reset = ehci_setup,
1192 .start = ehci_run,
1193 .stop = ehci_stop,
1194 .shutdown = ehci_shutdown,
1195
1196
1197
1198
1199 .urb_enqueue = ehci_urb_enqueue,
1200 .urb_dequeue = ehci_urb_dequeue,
1201 .endpoint_disable = ehci_endpoint_disable,
1202 .endpoint_reset = ehci_endpoint_reset,
1203 .clear_tt_buffer_complete = ehci_clear_tt_buffer_complete,
1204
1205
1206
1207
1208 .get_frame_number = ehci_get_frame,
1209
1210
1211
1212
1213 .hub_status_data = ehci_hub_status_data,
1214 .hub_control = ehci_hub_control,
1215 .bus_suspend = ehci_bus_suspend,
1216 .bus_resume = ehci_bus_resume,
1217 .relinquish_port = ehci_relinquish_port,
1218 .port_handed_over = ehci_port_handed_over,
1219};
1220
1221void ehci_init_driver(struct hc_driver *drv,
1222 const struct ehci_driver_overrides *over)
1223{
1224
1225 *drv = ehci_hc_driver;
1226
1227 if (over) {
1228 drv->hcd_priv_size += over->extra_priv_size;
1229 if (over->reset)
1230 drv->reset = over->reset;
1231 }
1232}
1233EXPORT_SYMBOL_GPL(ehci_init_driver);
1234
1235
1236
1237MODULE_DESCRIPTION(DRIVER_DESC);
1238MODULE_AUTHOR (DRIVER_AUTHOR);
1239MODULE_LICENSE ("GPL");
1240
1241#ifdef CONFIG_USB_EHCI_FSL
1242#include "ehci-fsl.c"
1243#define PLATFORM_DRIVER ehci_fsl_driver
1244#endif
1245
1246#ifdef CONFIG_USB_EHCI_SH
1247#include "ehci-sh.c"
1248#define PLATFORM_DRIVER ehci_hcd_sh_driver
1249#endif
1250
1251#ifdef CONFIG_USB_EHCI_HCD_OMAP
1252#include "ehci-omap.c"
1253#define PLATFORM_DRIVER ehci_hcd_omap_driver
1254#endif
1255
1256#ifdef CONFIG_PPC_PS3
1257#include "ehci-ps3.c"
1258#define PS3_SYSTEM_BUS_DRIVER ps3_ehci_driver
1259#endif
1260
1261#ifdef CONFIG_USB_EHCI_HCD_PPC_OF
1262#include "ehci-ppc-of.c"
1263#define OF_PLATFORM_DRIVER ehci_hcd_ppc_of_driver
1264#endif
1265
1266#ifdef CONFIG_XPS_USB_HCD_XILINX
1267#include "ehci-xilinx-of.c"
1268#define XILINX_OF_PLATFORM_DRIVER ehci_hcd_xilinx_of_driver
1269#endif
1270
1271#ifdef CONFIG_PLAT_ORION
1272#include "ehci-orion.c"
1273#define PLATFORM_DRIVER ehci_orion_driver
1274#endif
1275
1276#ifdef CONFIG_USB_W90X900_EHCI
1277#include "ehci-w90x900.c"
1278#define PLATFORM_DRIVER ehci_hcd_w90x900_driver
1279#endif
1280
1281#ifdef CONFIG_ARCH_AT91
1282#include "ehci-atmel.c"
1283#define PLATFORM_DRIVER ehci_atmel_driver
1284#endif
1285
1286#ifdef CONFIG_USB_OCTEON_EHCI
1287#include "ehci-octeon.c"
1288#define PLATFORM_DRIVER ehci_octeon_driver
1289#endif
1290
1291#ifdef CONFIG_ARCH_VT8500
1292#include "ehci-vt8500.c"
1293#define PLATFORM_DRIVER vt8500_ehci_driver
1294#endif
1295
1296#ifdef CONFIG_PLAT_SPEAR
1297#include "ehci-spear.c"
1298#define PLATFORM_DRIVER spear_ehci_hcd_driver
1299#endif
1300
1301#ifdef CONFIG_USB_EHCI_MSM
1302#include "ehci-msm.c"
1303#define PLATFORM_DRIVER ehci_msm_driver
1304#endif
1305
1306#ifdef CONFIG_TILE_USB
1307#include "ehci-tilegx.c"
1308#define PLATFORM_DRIVER ehci_hcd_tilegx_driver
1309#endif
1310
1311#ifdef CONFIG_USB_EHCI_HCD_PMC_MSP
1312#include "ehci-pmcmsp.c"
1313#define PLATFORM_DRIVER ehci_hcd_msp_driver
1314#endif
1315
1316#ifdef CONFIG_USB_EHCI_TEGRA
1317#include "ehci-tegra.c"
1318#define PLATFORM_DRIVER tegra_ehci_driver
1319#endif
1320
1321#ifdef CONFIG_USB_EHCI_S5P
1322#include "ehci-s5p.c"
1323#define PLATFORM_DRIVER s5p_ehci_driver
1324#endif
1325
1326#ifdef CONFIG_SPARC_LEON
1327#include "ehci-grlib.c"
1328#define PLATFORM_DRIVER ehci_grlib_driver
1329#endif
1330
1331#ifdef CONFIG_USB_EHCI_MV
1332#include "ehci-mv.c"
1333#define PLATFORM_DRIVER ehci_mv_driver
1334#endif
1335
1336#ifdef CONFIG_MIPS_SEAD3
1337#include "ehci-sead3.c"
1338#define PLATFORM_DRIVER ehci_hcd_sead3_driver
1339#endif
1340
1341#if !IS_ENABLED(CONFIG_USB_EHCI_PCI) && \
1342 !IS_ENABLED(CONFIG_USB_EHCI_HCD_PLATFORM) && \
1343 !IS_ENABLED(CONFIG_USB_CHIPIDEA_HOST) && \
1344 !IS_ENABLED(CONFIG_USB_EHCI_MXC) && \
1345 !defined(PLATFORM_DRIVER) && \
1346 !defined(PS3_SYSTEM_BUS_DRIVER) && \
1347 !defined(OF_PLATFORM_DRIVER) && \
1348 !defined(XILINX_OF_PLATFORM_DRIVER)
1349#error "missing bus glue for ehci-hcd"
1350#endif
1351
1352static int __init ehci_hcd_init(void)
1353{
1354 int retval = 0;
1355
1356 if (usb_disabled())
1357 return -ENODEV;
1358
1359 printk(KERN_INFO "%s: " DRIVER_DESC "\n", hcd_name);
1360 set_bit(USB_EHCI_LOADED, &usb_hcds_loaded);
1361 if (test_bit(USB_UHCI_LOADED, &usb_hcds_loaded) ||
1362 test_bit(USB_OHCI_LOADED, &usb_hcds_loaded))
1363 printk(KERN_WARNING "Warning! ehci_hcd should always be loaded"
1364 " before uhci_hcd and ohci_hcd, not after\n");
1365
1366 pr_debug("%s: block sizes: qh %Zd qtd %Zd itd %Zd sitd %Zd\n",
1367 hcd_name,
1368 sizeof(struct ehci_qh), sizeof(struct ehci_qtd),
1369 sizeof(struct ehci_itd), sizeof(struct ehci_sitd));
1370
1371#ifdef DEBUG
1372 ehci_debug_root = debugfs_create_dir("ehci", usb_debug_root);
1373 if (!ehci_debug_root) {
1374 retval = -ENOENT;
1375 goto err_debug;
1376 }
1377#endif
1378
1379#ifdef PLATFORM_DRIVER
1380 retval = platform_driver_register(&PLATFORM_DRIVER);
1381 if (retval < 0)
1382 goto clean0;
1383#endif
1384
1385#ifdef PS3_SYSTEM_BUS_DRIVER
1386 retval = ps3_ehci_driver_register(&PS3_SYSTEM_BUS_DRIVER);
1387 if (retval < 0)
1388 goto clean2;
1389#endif
1390
1391#ifdef OF_PLATFORM_DRIVER
1392 retval = platform_driver_register(&OF_PLATFORM_DRIVER);
1393 if (retval < 0)
1394 goto clean3;
1395#endif
1396
1397#ifdef XILINX_OF_PLATFORM_DRIVER
1398 retval = platform_driver_register(&XILINX_OF_PLATFORM_DRIVER);
1399 if (retval < 0)
1400 goto clean4;
1401#endif
1402 return retval;
1403
1404#ifdef XILINX_OF_PLATFORM_DRIVER
1405
1406clean4:
1407#endif
1408#ifdef OF_PLATFORM_DRIVER
1409 platform_driver_unregister(&OF_PLATFORM_DRIVER);
1410clean3:
1411#endif
1412#ifdef PS3_SYSTEM_BUS_DRIVER
1413 ps3_ehci_driver_unregister(&PS3_SYSTEM_BUS_DRIVER);
1414clean2:
1415#endif
1416#ifdef PLATFORM_DRIVER
1417 platform_driver_unregister(&PLATFORM_DRIVER);
1418clean0:
1419#endif
1420#ifdef DEBUG
1421 debugfs_remove(ehci_debug_root);
1422 ehci_debug_root = NULL;
1423err_debug:
1424#endif
1425 clear_bit(USB_EHCI_LOADED, &usb_hcds_loaded);
1426 return retval;
1427}
1428module_init(ehci_hcd_init);
1429
1430static void __exit ehci_hcd_cleanup(void)
1431{
1432#ifdef XILINX_OF_PLATFORM_DRIVER
1433 platform_driver_unregister(&XILINX_OF_PLATFORM_DRIVER);
1434#endif
1435#ifdef OF_PLATFORM_DRIVER
1436 platform_driver_unregister(&OF_PLATFORM_DRIVER);
1437#endif
1438#ifdef PLATFORM_DRIVER
1439 platform_driver_unregister(&PLATFORM_DRIVER);
1440#endif
1441#ifdef PS3_SYSTEM_BUS_DRIVER
1442 ps3_ehci_driver_unregister(&PS3_SYSTEM_BUS_DRIVER);
1443#endif
1444#ifdef DEBUG
1445 debugfs_remove(ehci_debug_root);
1446#endif
1447 clear_bit(USB_EHCI_LOADED, &usb_hcds_loaded);
1448}
1449module_exit(ehci_hcd_cleanup);
1450