1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19#include <linux/module.h>
20#include <linux/pci.h>
21#include <linux/dmapool.h>
22#include <linux/kernel.h>
23#include <linux/delay.h>
24#include <linux/ioport.h>
25#include <linux/sched.h>
26#include <linux/slab.h>
27#include <linux/vmalloc.h>
28#include <linux/errno.h>
29#include <linux/init.h>
30#include <linux/timer.h>
31#include <linux/ktime.h>
32#include <linux/list.h>
33#include <linux/interrupt.h>
34#include <linux/usb.h>
35#include <linux/moduleparam.h>
36#include <linux/dma-mapping.h>
37#include <linux/debugfs.h>
38
39#include "../core/hcd.h"
40
41#include <asm/byteorder.h>
42#include <asm/io.h>
43#include <asm/irq.h>
44#include <asm/system.h>
45#include <asm/unaligned.h>
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63#define DRIVER_AUTHOR "David Brownell"
64#define DRIVER_DESC "USB 2.0 'Enhanced' Host Controller (EHCI) Driver"
65
66static const char hcd_name [] = "ehci_hcd";
67
68
69#undef VERBOSE_DEBUG
70#undef EHCI_URB_TRACE
71
72#ifdef DEBUG
73#define EHCI_STATS
74#endif
75
76
77#define EHCI_TUNE_CERR 3
78#define EHCI_TUNE_RL_HS 4
79#define EHCI_TUNE_RL_TT 0
80#define EHCI_TUNE_MULT_HS 1
81#define EHCI_TUNE_MULT_TT 1
82#define EHCI_TUNE_FLS 2
83
84#define EHCI_IAA_MSECS 10
85#define EHCI_IO_JIFFIES (HZ/10)
86#define EHCI_ASYNC_JIFFIES (HZ/20)
87#define EHCI_SHRINK_FRAMES 5
88
89
90static int log2_irq_thresh = 0;
91module_param (log2_irq_thresh, int, S_IRUGO);
92MODULE_PARM_DESC (log2_irq_thresh, "log2 IRQ latency, 1-64 microframes");
93
94
95static unsigned park = 0;
96module_param (park, uint, S_IRUGO);
97MODULE_PARM_DESC (park, "park setting; 1-3 back-to-back async packets");
98
99
100static int ignore_oc = 0;
101module_param (ignore_oc, bool, S_IRUGO);
102MODULE_PARM_DESC (ignore_oc, "ignore bogus hardware overcurrent indications");
103
104#define INTR_MASK (STS_IAA | STS_FATAL | STS_PCD | STS_ERR | STS_INT)
105
106
107
108#include "ehci.h"
109#include "ehci-dbg.c"
110
111
112
113static void
114timer_action(struct ehci_hcd *ehci, enum ehci_timer_action action)
115{
116
117
118
119
120 if (timer_pending(&ehci->watchdog)
121 && ((BIT(TIMER_ASYNC_SHRINK) | BIT(TIMER_ASYNC_OFF))
122 & ehci->actions))
123 return;
124
125 if (!test_and_set_bit(action, &ehci->actions)) {
126 unsigned long t;
127
128 switch (action) {
129 case TIMER_IO_WATCHDOG:
130 if (!ehci->need_io_watchdog)
131 return;
132 t = EHCI_IO_JIFFIES;
133 break;
134 case TIMER_ASYNC_OFF:
135 t = EHCI_ASYNC_JIFFIES;
136 break;
137
138 default:
139
140
141
142 t = DIV_ROUND_UP(EHCI_SHRINK_FRAMES * HZ, 1000) + 1;
143 break;
144 }
145 mod_timer(&ehci->watchdog, t + jiffies);
146 }
147}
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168static int handshake (struct ehci_hcd *ehci, void __iomem *ptr,
169 u32 mask, u32 done, int usec)
170{
171 u32 result;
172
173 do {
174 result = ehci_readl(ehci, ptr);
175 if (result == ~(u32)0)
176 return -ENODEV;
177 result &= mask;
178 if (result == done)
179 return 0;
180 udelay (1);
181 usec--;
182 } while (usec > 0);
183 return -ETIMEDOUT;
184}
185
186
187static int ehci_halt (struct ehci_hcd *ehci)
188{
189 u32 temp = ehci_readl(ehci, &ehci->regs->status);
190
191
192 ehci_writel(ehci, 0, &ehci->regs->intr_enable);
193
194 if ((temp & STS_HALT) != 0)
195 return 0;
196
197 temp = ehci_readl(ehci, &ehci->regs->command);
198 temp &= ~CMD_RUN;
199 ehci_writel(ehci, temp, &ehci->regs->command);
200 return handshake (ehci, &ehci->regs->status,
201 STS_HALT, STS_HALT, 16 * 125);
202}
203
204static int handshake_on_error_set_halt(struct ehci_hcd *ehci, void __iomem *ptr,
205 u32 mask, u32 done, int usec)
206{
207 int error;
208
209 error = handshake(ehci, ptr, mask, done, usec);
210 if (error) {
211 ehci_halt(ehci);
212 ehci_to_hcd(ehci)->state = HC_STATE_HALT;
213 ehci_err(ehci, "force halt; handhake %p %08x %08x -> %d\n",
214 ptr, mask, done, error);
215 }
216
217 return error;
218}
219
220
221static void tdi_reset (struct ehci_hcd *ehci)
222{
223 u32 __iomem *reg_ptr;
224 u32 tmp;
225
226 reg_ptr = (u32 __iomem *)(((u8 __iomem *)ehci->regs) + USBMODE);
227 tmp = ehci_readl(ehci, reg_ptr);
228 tmp |= USBMODE_CM_HC;
229
230
231
232
233 if (ehci_big_endian_mmio(ehci))
234 tmp |= USBMODE_BE;
235 ehci_writel(ehci, tmp, reg_ptr);
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())
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_to_hcd(ehci)->state = HC_STATE_HALT;
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 (u32 __iomem *)(((u8 *)ehci->regs) + USBMODE_EX));
260 ehci_writel(ehci, TXFIFO_DEFAULT,
261 (u32 __iomem *)(((u8 *)ehci->regs) + TXFILLTUNING));
262 }
263 if (retval)
264 return retval;
265
266 if (ehci_is_TDI(ehci))
267 tdi_reset (ehci);
268
269 if (ehci->debug)
270 dbgp_external_startup();
271
272 return retval;
273}
274
275
276static void ehci_quiesce (struct ehci_hcd *ehci)
277{
278 u32 temp;
279
280#ifdef DEBUG
281 if (!HC_IS_RUNNING (ehci_to_hcd(ehci)->state))
282 BUG ();
283#endif
284
285
286 temp = ehci_readl(ehci, &ehci->regs->command) << 10;
287 temp &= STS_ASS | STS_PSS;
288 if (handshake_on_error_set_halt(ehci, &ehci->regs->status,
289 STS_ASS | STS_PSS, temp, 16 * 125))
290 return;
291
292
293 temp = ehci_readl(ehci, &ehci->regs->command);
294 temp &= ~(CMD_ASE | CMD_IAAD | CMD_PSE);
295 ehci_writel(ehci, temp, &ehci->regs->command);
296
297
298 handshake_on_error_set_halt(ehci, &ehci->regs->status,
299 STS_ASS | STS_PSS, 0, 16 * 125);
300}
301
302
303
304static void end_unlink_async(struct ehci_hcd *ehci);
305static void ehci_work(struct ehci_hcd *ehci);
306
307#include "ehci-hub.c"
308#include "ehci-mem.c"
309#include "ehci-q.c"
310#include "ehci-sched.c"
311
312
313
314static void ehci_iaa_watchdog(unsigned long param)
315{
316 struct ehci_hcd *ehci = (struct ehci_hcd *) param;
317 unsigned long flags;
318
319 spin_lock_irqsave (&ehci->lock, flags);
320
321
322
323
324
325
326 if (ehci->reclaim
327 && !timer_pending(&ehci->iaa_watchdog)
328 && HC_IS_RUNNING(ehci_to_hcd(ehci)->state)) {
329 u32 cmd, status;
330
331
332
333
334
335
336
337 cmd = ehci_readl(ehci, &ehci->regs->command);
338 if (cmd & CMD_IAAD)
339 ehci_writel(ehci, cmd & ~CMD_IAAD,
340 &ehci->regs->command);
341
342
343
344
345
346
347
348 status = ehci_readl(ehci, &ehci->regs->status);
349 if ((status & STS_IAA) || !(cmd & CMD_IAAD)) {
350 COUNT (ehci->stats.lost_iaa);
351 ehci_writel(ehci, STS_IAA, &ehci->regs->status);
352 }
353
354 ehci_vdbg(ehci, "IAA watchdog: status %x cmd %x\n",
355 status, cmd);
356 end_unlink_async(ehci);
357 }
358
359 spin_unlock_irqrestore(&ehci->lock, flags);
360}
361
362static void ehci_watchdog(unsigned long param)
363{
364 struct ehci_hcd *ehci = (struct ehci_hcd *) param;
365 unsigned long flags;
366
367 spin_lock_irqsave(&ehci->lock, flags);
368
369
370 if (test_bit (TIMER_ASYNC_OFF, &ehci->actions))
371 start_unlink_async (ehci, ehci->async);
372
373
374 ehci_work (ehci);
375
376 spin_unlock_irqrestore (&ehci->lock, flags);
377}
378
379
380
381
382
383static void ehci_turn_off_all_ports(struct ehci_hcd *ehci)
384{
385 int port = HCS_N_PORTS(ehci->hcs_params);
386
387 while (port--)
388 ehci_writel(ehci, PORT_RWC_BITS,
389 &ehci->regs->port_status[port]);
390}
391
392
393
394
395
396static void ehci_silence_controller(struct ehci_hcd *ehci)
397{
398 ehci_halt(ehci);
399 ehci_turn_off_all_ports(ehci);
400
401
402 ehci_writel(ehci, 0, &ehci->regs->configured_flag);
403
404
405 ehci_readl(ehci, &ehci->regs->configured_flag);
406}
407
408
409
410
411
412static void ehci_shutdown(struct usb_hcd *hcd)
413{
414 struct ehci_hcd *ehci = hcd_to_ehci(hcd);
415
416 del_timer_sync(&ehci->watchdog);
417 del_timer_sync(&ehci->iaa_watchdog);
418
419 spin_lock_irq(&ehci->lock);
420 ehci_silence_controller(ehci);
421 spin_unlock_irq(&ehci->lock);
422}
423
424static void ehci_port_power (struct ehci_hcd *ehci, int is_on)
425{
426 unsigned port;
427
428 if (!HCS_PPC (ehci->hcs_params))
429 return;
430
431 ehci_dbg (ehci, "...power%s ports...\n", is_on ? "up" : "down");
432 for (port = HCS_N_PORTS (ehci->hcs_params); port > 0; )
433 (void) ehci_hub_control(ehci_to_hcd(ehci),
434 is_on ? SetPortFeature : ClearPortFeature,
435 USB_PORT_FEAT_POWER,
436 port--, NULL, 0);
437
438 ehci_readl(ehci, &ehci->regs->command);
439 msleep(20);
440}
441
442
443
444
445
446
447
448static void ehci_work (struct ehci_hcd *ehci)
449{
450 timer_action_done (ehci, TIMER_IO_WATCHDOG);
451
452
453
454
455
456 if (ehci->scanning)
457 return;
458 ehci->scanning = 1;
459 scan_async (ehci);
460 if (ehci->next_uframe != -1)
461 scan_periodic (ehci);
462 ehci->scanning = 0;
463
464
465
466
467
468 if (HC_IS_RUNNING (ehci_to_hcd(ehci)->state) &&
469 (ehci->async->qh_next.ptr != NULL ||
470 ehci->periodic_sched != 0))
471 timer_action (ehci, TIMER_IO_WATCHDOG);
472}
473
474
475
476
477static void ehci_stop (struct usb_hcd *hcd)
478{
479 struct ehci_hcd *ehci = hcd_to_ehci (hcd);
480
481 ehci_dbg (ehci, "stop\n");
482
483
484 del_timer_sync (&ehci->watchdog);
485 del_timer_sync(&ehci->iaa_watchdog);
486
487 spin_lock_irq(&ehci->lock);
488 if (HC_IS_RUNNING (hcd->state))
489 ehci_quiesce (ehci);
490
491 ehci_silence_controller(ehci);
492 ehci_reset (ehci);
493 spin_unlock_irq(&ehci->lock);
494
495 remove_companion_file(ehci);
496 remove_debug_files (ehci);
497
498
499 spin_lock_irq (&ehci->lock);
500 if (ehci->async)
501 ehci_work (ehci);
502 spin_unlock_irq (&ehci->lock);
503 ehci_mem_cleanup (ehci);
504
505#ifdef EHCI_STATS
506 ehci_dbg (ehci, "irq normal %ld err %ld reclaim %ld (lost %ld)\n",
507 ehci->stats.normal, ehci->stats.error, ehci->stats.reclaim,
508 ehci->stats.lost_iaa);
509 ehci_dbg (ehci, "complete %ld unlink %ld\n",
510 ehci->stats.complete, ehci->stats.unlink);
511#endif
512
513 dbg_status (ehci, "ehci_stop completed",
514 ehci_readl(ehci, &ehci->regs->status));
515}
516
517
518static int ehci_init(struct usb_hcd *hcd)
519{
520 struct ehci_hcd *ehci = hcd_to_ehci(hcd);
521 u32 temp;
522 int retval;
523 u32 hcc_params;
524 struct ehci_qh_hw *hw;
525
526 spin_lock_init(&ehci->lock);
527
528
529
530
531 ehci->need_io_watchdog = 1;
532 init_timer(&ehci->watchdog);
533 ehci->watchdog.function = ehci_watchdog;
534 ehci->watchdog.data = (unsigned long) ehci;
535
536 init_timer(&ehci->iaa_watchdog);
537 ehci->iaa_watchdog.function = ehci_iaa_watchdog;
538 ehci->iaa_watchdog.data = (unsigned long) ehci;
539
540
541
542
543
544 ehci->periodic_size = DEFAULT_I_TDPS;
545 INIT_LIST_HEAD(&ehci->cached_itd_list);
546 if ((retval = ehci_mem_init(ehci, GFP_KERNEL)) < 0)
547 return retval;
548
549
550 hcc_params = ehci_readl(ehci, &ehci->caps->hcc_params);
551 if (HCC_ISOC_CACHE(hcc_params))
552 ehci->i_thresh = 8;
553 else
554 ehci->i_thresh = 2 + HCC_ISOC_THRES(hcc_params);
555
556 ehci->reclaim = NULL;
557 ehci->next_uframe = -1;
558 ehci->clock_frame = -1;
559
560
561
562
563
564
565
566
567 ehci->async->qh_next.qh = NULL;
568 hw = ehci->async->hw;
569 hw->hw_next = QH_NEXT(ehci, ehci->async->qh_dma);
570 hw->hw_info1 = cpu_to_hc32(ehci, QH_HEAD);
571 hw->hw_token = cpu_to_hc32(ehci, QTD_STS_HALT);
572 hw->hw_qtd_next = EHCI_LIST_END(ehci);
573 ehci->async->qh_state = QH_STATE_LINKED;
574 hw->hw_alt_next = QTD_NEXT(ehci, ehci->async->dummy->qtd_dma);
575
576
577 if (log2_irq_thresh < 0 || log2_irq_thresh > 6)
578 log2_irq_thresh = 0;
579 temp = 1 << (16 + log2_irq_thresh);
580 if (HCC_CANPARK(hcc_params)) {
581
582
583
584
585
586
587
588 if (park) {
589 park = min(park, (unsigned) 3);
590 temp |= CMD_PARK;
591 temp |= park << 8;
592 }
593 ehci_dbg(ehci, "park %d\n", park);
594 }
595 if (HCC_PGM_FRAMELISTLEN(hcc_params)) {
596
597 temp &= ~(3 << 2);
598 temp |= (EHCI_TUNE_FLS << 2);
599 switch (EHCI_TUNE_FLS) {
600 case 0: ehci->periodic_size = 1024; break;
601 case 1: ehci->periodic_size = 512; break;
602 case 2: ehci->periodic_size = 256; break;
603 default: BUG();
604 }
605 }
606 ehci->command = temp;
607
608 return 0;
609}
610
611
612static int ehci_run (struct usb_hcd *hcd)
613{
614 struct ehci_hcd *ehci = hcd_to_ehci (hcd);
615 int retval;
616 u32 temp;
617 u32 hcc_params;
618
619 hcd->uses_new_polling = 1;
620 hcd->poll_rh = 0;
621
622
623 if ((retval = ehci_reset(ehci)) != 0) {
624 ehci_mem_cleanup(ehci);
625 return retval;
626 }
627 ehci_writel(ehci, ehci->periodic_dma, &ehci->regs->frame_list);
628 ehci_writel(ehci, (u32)ehci->async->qh_dma, &ehci->regs->async_next);
629
630
631
632
633
634
635
636
637
638
639
640
641
642 hcc_params = ehci_readl(ehci, &ehci->caps->hcc_params);
643 if (HCC_64BIT_ADDR(hcc_params)) {
644 ehci_writel(ehci, 0, &ehci->regs->segment);
645#if 0
646
647 if (!dma_set_mask(hcd->self.controller, DMA_BIT_MASK(64)))
648 ehci_info(ehci, "enabled 64bit DMA\n");
649#endif
650 }
651
652
653
654
655 ehci->command &= ~(CMD_LRESET|CMD_IAAD|CMD_PSE|CMD_ASE|CMD_RESET);
656 ehci->command |= CMD_RUN;
657 ehci_writel(ehci, ehci->command, &ehci->regs->command);
658 dbg_cmd (ehci, "init", ehci->command);
659
660
661
662
663
664
665
666
667
668
669
670
671
672
673
674 down_write(&ehci_cf_port_reset_rwsem);
675 hcd->state = HC_STATE_RUNNING;
676 ehci_writel(ehci, FLAG_CF, &ehci->regs->configured_flag);
677 ehci_readl(ehci, &ehci->regs->command);
678 msleep(5);
679 up_write(&ehci_cf_port_reset_rwsem);
680 ehci->last_periodic_enable = ktime_get_real();
681
682 temp = HC_VERSION(ehci_readl(ehci, &ehci->caps->hc_capbase));
683 ehci_info (ehci,
684 "USB %x.%x started, EHCI %x.%02x%s\n",
685 ((ehci->sbrn & 0xf0)>>4), (ehci->sbrn & 0x0f),
686 temp >> 8, temp & 0xff,
687 ignore_oc ? ", overcurrent ignored" : "");
688
689 ehci_writel(ehci, INTR_MASK,
690 &ehci->regs->intr_enable);
691
692
693
694
695
696 create_debug_files(ehci);
697 create_companion_file(ehci);
698
699 return 0;
700}
701
702
703
704static irqreturn_t ehci_irq (struct usb_hcd *hcd)
705{
706 struct ehci_hcd *ehci = hcd_to_ehci (hcd);
707 u32 status, masked_status, pcd_status = 0, cmd;
708 int bh;
709
710 spin_lock (&ehci->lock);
711
712 status = ehci_readl(ehci, &ehci->regs->status);
713
714
715 if (status == ~(u32) 0) {
716 ehci_dbg (ehci, "device removed\n");
717 goto dead;
718 }
719
720 masked_status = status & INTR_MASK;
721 if (!masked_status) {
722 spin_unlock(&ehci->lock);
723 return IRQ_NONE;
724 }
725
726
727 ehci_writel(ehci, masked_status, &ehci->regs->status);
728 cmd = ehci_readl(ehci, &ehci->regs->command);
729 bh = 0;
730
731#ifdef VERBOSE_DEBUG
732
733 dbg_status (ehci, "irq", status);
734#endif
735
736
737
738
739 if (likely ((status & (STS_INT|STS_ERR)) != 0)) {
740 if (likely ((status & STS_ERR) == 0))
741 COUNT (ehci->stats.normal);
742 else
743 COUNT (ehci->stats.error);
744 bh = 1;
745 }
746
747
748 if (status & STS_IAA) {
749
750 if (cmd & CMD_IAAD) {
751 ehci_writel(ehci, cmd & ~CMD_IAAD,
752 &ehci->regs->command);
753 ehci_dbg(ehci, "IAA with IAAD still set?\n");
754 }
755 if (ehci->reclaim) {
756 COUNT(ehci->stats.reclaim);
757 end_unlink_async(ehci);
758 } else
759 ehci_dbg(ehci, "IAA with nothing to reclaim?\n");
760 }
761
762
763 if (status & STS_PCD) {
764 unsigned i = HCS_N_PORTS (ehci->hcs_params);
765
766
767 pcd_status = status;
768
769
770 if (!(cmd & CMD_RUN))
771 usb_hcd_resume_root_hub(hcd);
772
773 while (i--) {
774 int pstatus = ehci_readl(ehci,
775 &ehci->regs->port_status [i]);
776
777 if (pstatus & PORT_OWNER)
778 continue;
779 if (!(test_bit(i, &ehci->suspended_ports) &&
780 ((pstatus & PORT_RESUME) ||
781 !(pstatus & PORT_SUSPEND)) &&
782 (pstatus & PORT_PE) &&
783 ehci->reset_done[i] == 0))
784 continue;
785
786
787
788
789
790 ehci->reset_done [i] = jiffies + msecs_to_jiffies (20);
791 ehci_dbg (ehci, "port %d remote wakeup\n", i + 1);
792 mod_timer(&hcd->rh_timer, ehci->reset_done[i]);
793 }
794 }
795
796
797 if (unlikely ((status & STS_FATAL) != 0)) {
798 ehci_err(ehci, "fatal error\n");
799 dbg_cmd(ehci, "fatal", cmd);
800 dbg_status(ehci, "fatal", status);
801 ehci_halt(ehci);
802dead:
803 ehci_reset(ehci);
804 ehci_writel(ehci, 0, &ehci->regs->configured_flag);
805
806
807
808 bh = 1;
809 }
810
811 if (bh)
812 ehci_work (ehci);
813 spin_unlock (&ehci->lock);
814 if (pcd_status)
815 usb_hcd_poll_rh_status(hcd);
816 return IRQ_HANDLED;
817}
818
819
820
821
822
823
824
825
826
827
828
829
830
831
832
833static int ehci_urb_enqueue (
834 struct usb_hcd *hcd,
835 struct urb *urb,
836 gfp_t mem_flags
837) {
838 struct ehci_hcd *ehci = hcd_to_ehci (hcd);
839 struct list_head qtd_list;
840
841 INIT_LIST_HEAD (&qtd_list);
842
843 switch (usb_pipetype (urb->pipe)) {
844 case PIPE_CONTROL:
845
846
847
848 if (urb->transfer_buffer_length > (16 * 1024))
849 return -EMSGSIZE;
850
851
852 default:
853 if (!qh_urb_transaction (ehci, urb, &qtd_list, mem_flags))
854 return -ENOMEM;
855 return submit_async(ehci, urb, &qtd_list, mem_flags);
856
857 case PIPE_INTERRUPT:
858 if (!qh_urb_transaction (ehci, urb, &qtd_list, mem_flags))
859 return -ENOMEM;
860 return intr_submit(ehci, urb, &qtd_list, mem_flags);
861
862 case PIPE_ISOCHRONOUS:
863 if (urb->dev->speed == USB_SPEED_HIGH)
864 return itd_submit (ehci, urb, mem_flags);
865 else
866 return sitd_submit (ehci, urb, mem_flags);
867 }
868}
869
870static void unlink_async (struct ehci_hcd *ehci, struct ehci_qh *qh)
871{
872
873 if (!HC_IS_RUNNING(ehci_to_hcd(ehci)->state) && ehci->reclaim)
874 end_unlink_async(ehci);
875
876
877
878
879
880 if (qh->qh_state != QH_STATE_LINKED) {
881 if (qh->qh_state == QH_STATE_COMPLETING)
882 qh->needs_rescan = 1;
883 return;
884 }
885
886
887 if (ehci->reclaim) {
888 struct ehci_qh *last;
889
890 for (last = ehci->reclaim;
891 last->reclaim;
892 last = last->reclaim)
893 continue;
894 qh->qh_state = QH_STATE_UNLINK_WAIT;
895 last->reclaim = qh;
896
897
898 } else
899 start_unlink_async (ehci, qh);
900}
901
902
903
904
905
906static int ehci_urb_dequeue(struct usb_hcd *hcd, struct urb *urb, int status)
907{
908 struct ehci_hcd *ehci = hcd_to_ehci (hcd);
909 struct ehci_qh *qh;
910 unsigned long flags;
911 int rc;
912
913 spin_lock_irqsave (&ehci->lock, flags);
914 rc = usb_hcd_check_unlink_urb(hcd, urb, status);
915 if (rc)
916 goto done;
917
918 switch (usb_pipetype (urb->pipe)) {
919
920
921 default:
922 qh = (struct ehci_qh *) urb->hcpriv;
923 if (!qh)
924 break;
925 switch (qh->qh_state) {
926 case QH_STATE_LINKED:
927 case QH_STATE_COMPLETING:
928 unlink_async(ehci, qh);
929 break;
930 case QH_STATE_UNLINK:
931 case QH_STATE_UNLINK_WAIT:
932
933 break;
934 case QH_STATE_IDLE:
935
936 qh_completions(ehci, qh);
937 break;
938 }
939 break;
940
941 case PIPE_INTERRUPT:
942 qh = (struct ehci_qh *) urb->hcpriv;
943 if (!qh)
944 break;
945 switch (qh->qh_state) {
946 case QH_STATE_LINKED:
947 case QH_STATE_COMPLETING:
948 intr_deschedule (ehci, qh);
949 break;
950 case QH_STATE_IDLE:
951 qh_completions (ehci, qh);
952 break;
953 default:
954 ehci_dbg (ehci, "bogus qh %p state %d\n",
955 qh, qh->qh_state);
956 goto done;
957 }
958 break;
959
960 case PIPE_ISOCHRONOUS:
961
962
963
964
965 break;
966 }
967done:
968 spin_unlock_irqrestore (&ehci->lock, flags);
969 return rc;
970}
971
972
973
974
975
976static void
977ehci_endpoint_disable (struct usb_hcd *hcd, struct usb_host_endpoint *ep)
978{
979 struct ehci_hcd *ehci = hcd_to_ehci (hcd);
980 unsigned long flags;
981 struct ehci_qh *qh, *tmp;
982
983
984
985
986rescan:
987 spin_lock_irqsave (&ehci->lock, flags);
988 qh = ep->hcpriv;
989 if (!qh)
990 goto done;
991
992
993
994
995 if (qh->hw->hw_info1 == 0) {
996 ehci_vdbg (ehci, "iso delay\n");
997 goto idle_timeout;
998 }
999
1000 if (!HC_IS_RUNNING (hcd->state))
1001 qh->qh_state = QH_STATE_IDLE;
1002 switch (qh->qh_state) {
1003 case QH_STATE_LINKED:
1004 case QH_STATE_COMPLETING:
1005 for (tmp = ehci->async->qh_next.qh;
1006 tmp && tmp != qh;
1007 tmp = tmp->qh_next.qh)
1008 continue;
1009
1010 if (!tmp)
1011 goto nogood;
1012 unlink_async (ehci, qh);
1013
1014 case QH_STATE_UNLINK:
1015 case QH_STATE_UNLINK_WAIT:
1016idle_timeout:
1017 spin_unlock_irqrestore (&ehci->lock, flags);
1018 schedule_timeout_uninterruptible(1);
1019 goto rescan;
1020 case QH_STATE_IDLE:
1021 if (qh->clearing_tt)
1022 goto idle_timeout;
1023 if (list_empty (&qh->qtd_list)) {
1024 qh_put (qh);
1025 break;
1026 }
1027
1028 default:
1029nogood:
1030
1031
1032
1033 ehci_err (ehci, "qh %p (#%02x) state %d%s\n",
1034 qh, ep->desc.bEndpointAddress, qh->qh_state,
1035 list_empty (&qh->qtd_list) ? "" : "(has tds)");
1036 break;
1037 }
1038 ep->hcpriv = NULL;
1039done:
1040 spin_unlock_irqrestore (&ehci->lock, flags);
1041 return;
1042}
1043
1044static void
1045ehci_endpoint_reset(struct usb_hcd *hcd, struct usb_host_endpoint *ep)
1046{
1047 struct ehci_hcd *ehci = hcd_to_ehci(hcd);
1048 struct ehci_qh *qh;
1049 int eptype = usb_endpoint_type(&ep->desc);
1050 int epnum = usb_endpoint_num(&ep->desc);
1051 int is_out = usb_endpoint_dir_out(&ep->desc);
1052 unsigned long flags;
1053
1054 if (eptype != USB_ENDPOINT_XFER_BULK && eptype != USB_ENDPOINT_XFER_INT)
1055 return;
1056
1057 spin_lock_irqsave(&ehci->lock, flags);
1058 qh = ep->hcpriv;
1059
1060
1061
1062
1063
1064
1065 if (qh) {
1066 usb_settoggle(qh->dev, epnum, is_out, 0);
1067 if (!list_empty(&qh->qtd_list)) {
1068 WARN_ONCE(1, "clear_halt for a busy endpoint\n");
1069 } else if (qh->qh_state == QH_STATE_LINKED ||
1070 qh->qh_state == QH_STATE_COMPLETING) {
1071
1072
1073
1074
1075
1076 if (eptype == USB_ENDPOINT_XFER_BULK)
1077 unlink_async(ehci, qh);
1078 else
1079 intr_deschedule(ehci, qh);
1080 }
1081 }
1082 spin_unlock_irqrestore(&ehci->lock, flags);
1083}
1084
1085static int ehci_get_frame (struct usb_hcd *hcd)
1086{
1087 struct ehci_hcd *ehci = hcd_to_ehci (hcd);
1088 return (ehci_readl(ehci, &ehci->regs->frame_index) >> 3) %
1089 ehci->periodic_size;
1090}
1091
1092
1093
1094MODULE_DESCRIPTION(DRIVER_DESC);
1095MODULE_AUTHOR (DRIVER_AUTHOR);
1096MODULE_LICENSE ("GPL");
1097
1098#ifdef CONFIG_PCI
1099#include "ehci-pci.c"
1100#define PCI_DRIVER ehci_pci_driver
1101#endif
1102
1103#ifdef CONFIG_USB_EHCI_FSL
1104#include "ehci-fsl.c"
1105#define PLATFORM_DRIVER ehci_fsl_driver
1106#endif
1107
1108#ifdef CONFIG_SOC_AU1200
1109#include "ehci-au1xxx.c"
1110#define PLATFORM_DRIVER ehci_hcd_au1xxx_driver
1111#endif
1112
1113#ifdef CONFIG_PPC_PS3
1114#include "ehci-ps3.c"
1115#define PS3_SYSTEM_BUS_DRIVER ps3_ehci_driver
1116#endif
1117
1118#ifdef CONFIG_USB_EHCI_HCD_PPC_OF
1119#include "ehci-ppc-of.c"
1120#define OF_PLATFORM_DRIVER ehci_hcd_ppc_of_driver
1121#endif
1122
1123#ifdef CONFIG_PLAT_ORION
1124#include "ehci-orion.c"
1125#define PLATFORM_DRIVER ehci_orion_driver
1126#endif
1127
1128#ifdef CONFIG_ARCH_IXP4XX
1129#include "ehci-ixp4xx.c"
1130#define PLATFORM_DRIVER ixp4xx_ehci_driver
1131#endif
1132
1133#ifdef CONFIG_USB_W90X900_EHCI
1134#include "ehci-w90x900.c"
1135#define PLATFORM_DRIVER ehci_hcd_w90x900_driver
1136#endif
1137
1138#ifdef CONFIG_ARCH_AT91
1139#include "ehci-atmel.c"
1140#define PLATFORM_DRIVER ehci_atmel_driver
1141#endif
1142
1143#if !defined(PCI_DRIVER) && !defined(PLATFORM_DRIVER) && \
1144 !defined(PS3_SYSTEM_BUS_DRIVER) && !defined(OF_PLATFORM_DRIVER)
1145#error "missing bus glue for ehci-hcd"
1146#endif
1147
1148static int __init ehci_hcd_init(void)
1149{
1150 int retval = 0;
1151
1152 if (usb_disabled())
1153 return -ENODEV;
1154
1155 printk(KERN_INFO "%s: " DRIVER_DESC "\n", hcd_name);
1156 set_bit(USB_EHCI_LOADED, &usb_hcds_loaded);
1157 if (test_bit(USB_UHCI_LOADED, &usb_hcds_loaded) ||
1158 test_bit(USB_OHCI_LOADED, &usb_hcds_loaded))
1159 printk(KERN_WARNING "Warning! ehci_hcd should always be loaded"
1160 " before uhci_hcd and ohci_hcd, not after\n");
1161
1162 pr_debug("%s: block sizes: qh %Zd qtd %Zd itd %Zd sitd %Zd\n",
1163 hcd_name,
1164 sizeof(struct ehci_qh), sizeof(struct ehci_qtd),
1165 sizeof(struct ehci_itd), sizeof(struct ehci_sitd));
1166
1167#ifdef DEBUG
1168 ehci_debug_root = debugfs_create_dir("ehci", usb_debug_root);
1169 if (!ehci_debug_root) {
1170 retval = -ENOENT;
1171 goto err_debug;
1172 }
1173#endif
1174
1175#ifdef PLATFORM_DRIVER
1176 retval = platform_driver_register(&PLATFORM_DRIVER);
1177 if (retval < 0)
1178 goto clean0;
1179#endif
1180
1181#ifdef PCI_DRIVER
1182 retval = pci_register_driver(&PCI_DRIVER);
1183 if (retval < 0)
1184 goto clean1;
1185#endif
1186
1187#ifdef PS3_SYSTEM_BUS_DRIVER
1188 retval = ps3_ehci_driver_register(&PS3_SYSTEM_BUS_DRIVER);
1189 if (retval < 0)
1190 goto clean2;
1191#endif
1192
1193#ifdef OF_PLATFORM_DRIVER
1194 retval = of_register_platform_driver(&OF_PLATFORM_DRIVER);
1195 if (retval < 0)
1196 goto clean3;
1197#endif
1198 return retval;
1199
1200#ifdef OF_PLATFORM_DRIVER
1201
1202clean3:
1203#endif
1204#ifdef PS3_SYSTEM_BUS_DRIVER
1205 ps3_ehci_driver_unregister(&PS3_SYSTEM_BUS_DRIVER);
1206clean2:
1207#endif
1208#ifdef PCI_DRIVER
1209 pci_unregister_driver(&PCI_DRIVER);
1210clean1:
1211#endif
1212#ifdef PLATFORM_DRIVER
1213 platform_driver_unregister(&PLATFORM_DRIVER);
1214clean0:
1215#endif
1216#ifdef DEBUG
1217 debugfs_remove(ehci_debug_root);
1218 ehci_debug_root = NULL;
1219err_debug:
1220#endif
1221 clear_bit(USB_EHCI_LOADED, &usb_hcds_loaded);
1222 return retval;
1223}
1224module_init(ehci_hcd_init);
1225
1226static void __exit ehci_hcd_cleanup(void)
1227{
1228#ifdef OF_PLATFORM_DRIVER
1229 of_unregister_platform_driver(&OF_PLATFORM_DRIVER);
1230#endif
1231#ifdef PLATFORM_DRIVER
1232 platform_driver_unregister(&PLATFORM_DRIVER);
1233#endif
1234#ifdef PCI_DRIVER
1235 pci_unregister_driver(&PCI_DRIVER);
1236#endif
1237#ifdef PS3_SYSTEM_BUS_DRIVER
1238 ps3_ehci_driver_unregister(&PS3_SYSTEM_BUS_DRIVER);
1239#endif
1240#ifdef DEBUG
1241 debugfs_remove(ehci_debug_root);
1242#endif
1243 clear_bit(USB_EHCI_LOADED, &usb_hcds_loaded);
1244}
1245module_exit(ehci_hcd_cleanup);
1246
1247