Lines Matching defs:ehci
98 #include "ehci.h"
111 static unsigned ehci_moschip_read_frame_index(struct ehci_hcd *ehci)
115 uf = ehci_readl(ehci, &ehci->regs->frame_index);
117 uf = ehci_readl(ehci, &ehci->regs->frame_index);
121 static inline unsigned ehci_read_frame_index(struct ehci_hcd *ehci)
123 if (ehci->frame_index_bug)
124 return ehci_moschip_read_frame_index(ehci);
125 return ehci_readl(ehci, &ehci->regs->frame_index);
128 #include "ehci-dbg.c"
149 int ehci_handshake(struct ehci_hcd *ehci, void __iomem *ptr,
155 result = ehci_readl(ehci, ptr);
169 static int tdi_in_host_mode (struct ehci_hcd *ehci)
173 tmp = ehci_readl(ehci, &ehci->regs->usbmode);
181 static int ehci_halt (struct ehci_hcd *ehci)
185 spin_lock_irq(&ehci->lock);
188 ehci_writel(ehci, 0, &ehci->regs->intr_enable);
190 if (ehci_is_TDI(ehci) && !tdi_in_host_mode(ehci)) {
191 spin_unlock_irq(&ehci->lock);
196 * This routine gets called during probe before ehci->command
199 ehci->command &= ~CMD_RUN;
200 temp = ehci_readl(ehci, &ehci->regs->command);
202 ehci_writel(ehci, temp, &ehci->regs->command);
204 spin_unlock_irq(&ehci->lock);
205 synchronize_irq(ehci_to_hcd(ehci)->irq);
207 return ehci_handshake(ehci, &ehci->regs->status,
212 static void tdi_reset (struct ehci_hcd *ehci)
216 tmp = ehci_readl(ehci, &ehci->regs->usbmode);
222 if (ehci_big_endian_mmio(ehci))
224 ehci_writel(ehci, tmp, &ehci->regs->usbmode);
231 int ehci_reset(struct ehci_hcd *ehci)
234 u32 command = ehci_readl(ehci, &ehci->regs->command);
238 if (ehci->debug && !dbgp_reset_prep(ehci_to_hcd(ehci)))
239 ehci->debug = NULL;
242 dbg_cmd (ehci, "reset", command);
243 ehci_writel(ehci, command, &ehci->regs->command);
244 ehci->rh_state = EHCI_RH_HALTED;
245 ehci->next_statechange = jiffies;
246 retval = ehci_handshake(ehci, &ehci->regs->command,
249 if (ehci->has_hostpc) {
250 ehci_writel(ehci, USBMODE_EX_HC | USBMODE_EX_VBPS,
251 &ehci->regs->usbmode_ex);
252 ehci_writel(ehci, TXFIFO_DEFAULT, &ehci->regs->txfill_tuning);
257 if (ehci_is_TDI(ehci))
258 tdi_reset (ehci);
260 if (ehci->debug)
261 dbgp_external_startup(ehci_to_hcd(ehci));
263 ehci->port_c_suspend = ehci->suspended_ports =
264 ehci->resuming_ports = 0;
273 static void ehci_quiesce (struct ehci_hcd *ehci)
277 if (ehci->rh_state != EHCI_RH_RUNNING)
281 temp = (ehci->command << 10) & (STS_ASS | STS_PSS);
282 ehci_handshake(ehci, &ehci->regs->status, STS_ASS | STS_PSS, temp,
286 spin_lock_irq(&ehci->lock);
287 ehci->command &= ~(CMD_ASE | CMD_PSE);
288 ehci_writel(ehci, ehci->command, &ehci->regs->command);
289 spin_unlock_irq(&ehci->lock);
292 ehci_handshake(ehci, &ehci->regs->status, STS_ASS | STS_PSS, 0,
298 static void end_iaa_cycle(struct ehci_hcd *ehci);
299 static void end_unlink_async(struct ehci_hcd *ehci);
300 static void unlink_empty_async(struct ehci_hcd *ehci);
301 static void ehci_work(struct ehci_hcd *ehci);
302 static void start_unlink_intr(struct ehci_hcd *ehci, struct ehci_qh *qh);
303 static void end_unlink_intr(struct ehci_hcd *ehci, struct ehci_qh *qh);
304 static int ehci_port_power(struct ehci_hcd *ehci, int portnum, bool enable);
306 #include "ehci-timer.c"
307 #include "ehci-hub.c"
308 #include "ehci-mem.c"
309 #include "ehci-q.c"
310 #include "ehci-sched.c"
311 #include "ehci-sysfs.c"
319 static void ehci_turn_off_all_ports(struct ehci_hcd *ehci)
321 int port = HCS_N_PORTS(ehci->hcs_params);
324 spin_unlock_irq(&ehci->lock);
325 ehci_port_power(ehci, port, false);
326 spin_lock_irq(&ehci->lock);
327 ehci_writel(ehci, PORT_RWC_BITS,
328 &ehci->regs->port_status[port]);
336 static void ehci_silence_controller(struct ehci_hcd *ehci)
338 ehci_halt(ehci);
340 spin_lock_irq(&ehci->lock);
341 ehci->rh_state = EHCI_RH_HALTED;
342 ehci_turn_off_all_ports(ehci);
345 ehci_writel(ehci, 0, &ehci->regs->configured_flag);
348 ehci_readl(ehci, &ehci->regs->configured_flag);
349 spin_unlock_irq(&ehci->lock);
358 struct ehci_hcd *ehci = hcd_to_ehci(hcd);
366 if (!ehci->sbrn)
369 spin_lock_irq(&ehci->lock);
370 ehci->shutdown = true;
371 ehci->rh_state = EHCI_RH_STOPPING;
372 ehci->enabled_hrtimer_events = 0;
373 spin_unlock_irq(&ehci->lock);
375 ehci_silence_controller(ehci);
377 hrtimer_cancel(&ehci->hrtimer);
384 * it calls driver completion functions, after dropping ehci->lock.
386 static void ehci_work (struct ehci_hcd *ehci)
388 /* another CPU may drop ehci->lock during a schedule scan while
392 if (ehci->scanning) {
393 ehci->need_rescan = true;
396 ehci->scanning = true;
399 ehci->need_rescan = false;
400 if (ehci->async_count)
401 scan_async(ehci);
402 if (ehci->intr_count > 0)
403 scan_intr(ehci);
404 if (ehci->isoc_count > 0)
405 scan_isoc(ehci);
406 if (ehci->need_rescan)
408 ehci->scanning = false;
414 turn_on_io_watchdog(ehci);
422 struct ehci_hcd *ehci = hcd_to_ehci (hcd);
424 ehci_dbg (ehci, "stop\n");
428 spin_lock_irq(&ehci->lock);
429 ehci->enabled_hrtimer_events = 0;
430 spin_unlock_irq(&ehci->lock);
432 ehci_quiesce(ehci);
433 ehci_silence_controller(ehci);
434 ehci_reset (ehci);
436 hrtimer_cancel(&ehci->hrtimer);
437 remove_sysfs_files(ehci);
438 remove_debug_files (ehci);
441 spin_lock_irq (&ehci->lock);
442 end_free_itds(ehci);
443 spin_unlock_irq (&ehci->lock);
444 ehci_mem_cleanup (ehci);
446 if (ehci->amd_pll_fix == 1)
449 dbg_status (ehci, "ehci_stop completed",
450 ehci_readl(ehci, &ehci->regs->status));
456 struct ehci_hcd *ehci = hcd_to_ehci(hcd);
462 spin_lock_init(&ehci->lock);
467 ehci->need_io_watchdog = 1;
469 hrtimer_init(&ehci->hrtimer, CLOCK_MONOTONIC, HRTIMER_MODE_ABS);
470 ehci->hrtimer.function = ehci_hrtimer_func;
471 ehci->next_hrtimer_event = EHCI_HRTIMER_NO_EVENT;
473 hcc_params = ehci_readl(ehci, &ehci->caps->hcc_params);
479 ehci->uframe_periodic_max = 100;
485 ehci->periodic_size = DEFAULT_I_TDPS;
486 INIT_LIST_HEAD(&ehci->async_unlink);
487 INIT_LIST_HEAD(&ehci->async_idle);
488 INIT_LIST_HEAD(&ehci->intr_unlink_wait);
489 INIT_LIST_HEAD(&ehci->intr_unlink);
490 INIT_LIST_HEAD(&ehci->intr_qh_list);
491 INIT_LIST_HEAD(&ehci->cached_itd_list);
492 INIT_LIST_HEAD(&ehci->cached_sitd_list);
493 INIT_LIST_HEAD(&ehci->tt_list);
498 case 0: ehci->periodic_size = 1024; break;
499 case 1: ehci->periodic_size = 512; break;
500 case 2: ehci->periodic_size = 256; break;
504 if ((retval = ehci_mem_init(ehci, GFP_KERNEL)) < 0)
509 ehci->i_thresh = 0;
511 ehci->i_thresh = 2 + HCC_ISOC_THRES(hcc_params);
520 ehci->async->qh_next.qh = NULL;
521 hw = ehci->async->hw;
522 hw->hw_next = QH_NEXT(ehci, ehci->async->qh_dma);
523 hw->hw_info1 = cpu_to_hc32(ehci, QH_HEAD);
525 hw->hw_info1 |= cpu_to_hc32(ehci, QH_INACTIVATE);
527 hw->hw_token = cpu_to_hc32(ehci, QTD_STS_HALT);
528 hw->hw_qtd_next = EHCI_LIST_END(ehci);
529 ehci->async->qh_state = QH_STATE_LINKED;
530 hw->hw_alt_next = QTD_NEXT(ehci, ehci->async->dummy->qtd_dma);
537 ehci->has_ppcd = 1;
538 ehci_dbg(ehci, "enable per-port change event\n");
554 ehci_dbg(ehci, "park %d\n", park);
561 ehci->command = temp;
568 ehci->old_current = ~0;
575 struct ehci_hcd *ehci = hcd_to_ehci (hcd);
584 ehci_writel(ehci, ehci->periodic_dma, &ehci->regs->frame_list);
585 ehci_writel(ehci, (u32)ehci->async->qh_dma, &ehci->regs->async_next);
588 * hcc_params controls whether ehci->regs->segment must (!!!)
599 hcc_params = ehci_readl(ehci, &ehci->caps->hcc_params);
601 ehci_writel(ehci, 0, &ehci->regs->segment);
605 ehci_info(ehci, "enabled 64bit DMA\n");
612 ehci->command &= ~(CMD_LRESET|CMD_IAAD|CMD_PSE|CMD_ASE|CMD_RESET);
613 ehci->command |= CMD_RUN;
614 ehci_writel(ehci, ehci->command, &ehci->regs->command);
615 dbg_cmd (ehci, "init", ehci->command);
632 ehci->rh_state = EHCI_RH_RUNNING;
633 ehci_writel(ehci, FLAG_CF, &ehci->regs->configured_flag);
636 ehci_readl(ehci, &ehci->regs->command); /* unblock posted writes */
642 if (ehci->is_aspeed)
643 rc = ehci_handshake(ehci, &ehci->regs->command, CMD_RUN,
646 rc = ehci_handshake(ehci, &ehci->regs->status, STS_HALT,
652 ehci_err(ehci, "USB %x.%x, controller refused to start: %d\n",
653 ((ehci->sbrn & 0xf0)>>4), (ehci->sbrn & 0x0f), rc);
657 ehci->last_periodic_enable = ktime_get_real();
659 temp = HC_VERSION(ehci, ehci_readl(ehci, &ehci->caps->hc_capbase));
660 ehci_info (ehci,
662 ((ehci->sbrn & 0xf0)>>4), (ehci->sbrn & 0x0f),
664 (ignore_oc || ehci->spurious_oc) ? ", overcurrent ignored" : "");
666 ehci_writel(ehci, INTR_MASK,
667 &ehci->regs->intr_enable); /* Turn On Interrupts */
673 create_debug_files(ehci);
674 create_sysfs_files(ehci);
681 struct ehci_hcd *ehci = hcd_to_ehci(hcd);
684 ehci->regs = (void __iomem *)ehci->caps +
685 HC_LENGTH(ehci, ehci_readl(ehci, &ehci->caps->hc_capbase));
686 dbg_hcs_params(ehci, "reset");
687 dbg_hcc_params(ehci, "reset");
690 ehci->hcs_params = ehci_readl(ehci, &ehci->caps->hcs_params);
692 ehci->sbrn = HCD_USB2;
699 retval = ehci_halt(ehci);
701 ehci_mem_cleanup(ehci);
705 ehci_reset(ehci);
715 struct ehci_hcd *ehci = hcd_to_ehci (hcd);
720 spin_lock(&ehci->lock);
723 current_status = ehci_readl(ehci, &ehci->regs->status);
728 ehci_dbg (ehci, "device removed\n");
740 if (!masked_status || unlikely(ehci->rh_state == EHCI_RH_HALTED)) {
741 spin_unlock(&ehci->lock);
746 ehci_writel(ehci, masked_status, &ehci->regs->status);
749 current_status = ehci_readl(ehci, &ehci->regs->status);
753 cmd = ehci_readl(ehci, &ehci->regs->command);
759 INCR(ehci->stats.normal);
762 if (ehci->has_ci_pec_bug)
764 INCR(ehci->stats.error);
773 ehci->enabled_hrtimer_events &= ~BIT(EHCI_HRTIMER_IAA_WATCHDOG);
782 if (ehci->next_hrtimer_event == EHCI_HRTIMER_IAA_WATCHDOG)
783 ++ehci->next_hrtimer_event;
787 ehci_dbg(ehci, "IAA with IAAD still set?\n");
788 if (ehci->iaa_in_progress)
789 INCR(ehci->stats.iaa);
790 end_iaa_cycle(ehci);
795 unsigned i = HCS_N_PORTS (ehci->hcs_params);
802 if (ehci->rh_state == EHCI_RH_SUSPENDED)
806 if (ehci->has_ppcd)
815 pstatus = ehci_readl(ehci,
816 &ehci->regs->port_status[i]);
820 if (!(test_bit(i, &ehci->suspended_ports) &&
824 ehci->reset_done[i] == 0))
831 ehci->reset_done[i] = jiffies +
833 set_bit(i, &ehci->resuming_ports);
834 ehci_dbg (ehci, "port %d remote wakeup\n", i + 1);
836 mod_timer(&hcd->rh_timer, ehci->reset_done[i]);
842 ehci_err(ehci, "fatal error\n");
843 dbg_cmd(ehci, "fatal", cmd);
844 dbg_status(ehci, "fatal", status);
849 ehci->shutdown = true;
850 ehci->rh_state = EHCI_RH_STOPPING;
851 ehci->command &= ~(CMD_RUN | CMD_ASE | CMD_PSE);
852 ehci_writel(ehci, ehci->command, &ehci->regs->command);
853 ehci_writel(ehci, 0, &ehci->regs->intr_enable);
854 ehci_handle_controller_death(ehci);
861 ehci_work (ehci);
862 spin_unlock(&ehci->lock);
887 struct ehci_hcd *ehci = hcd_to_ehci (hcd);
902 if (!qh_urb_transaction (ehci, urb, &qtd_list, mem_flags))
904 return submit_async(ehci, urb, &qtd_list, mem_flags);
907 if (!qh_urb_transaction (ehci, urb, &qtd_list, mem_flags))
909 return intr_submit(ehci, urb, &qtd_list, mem_flags);
913 return itd_submit (ehci, urb, mem_flags);
915 return sitd_submit (ehci, urb, mem_flags);
925 struct ehci_hcd *ehci = hcd_to_ehci (hcd);
930 spin_lock_irqsave (&ehci->lock, flags);
947 start_unlink_intr(ehci, qh);
949 start_unlink_async(ehci, qh);
960 qh_completions(ehci, qh);
965 spin_unlock_irqrestore (&ehci->lock, flags);
976 struct ehci_hcd *ehci = hcd_to_ehci (hcd);
984 spin_lock_irqsave (&ehci->lock, flags);
999 reserve_release_iso_bandwidth(ehci, stream, -1);
1012 start_unlink_async(ehci, qh);
1014 start_unlink_intr(ehci, qh);
1020 spin_unlock_irqrestore (&ehci->lock, flags);
1028 reserve_release_intr_bandwidth(ehci, qh, -1);
1029 qh_destroy(ehci, qh);
1037 ehci_err (ehci, "qh %p (#%02x) state %d%s\n",
1044 spin_unlock_irqrestore (&ehci->lock, flags);
1050 struct ehci_hcd *ehci = hcd_to_ehci(hcd);
1060 spin_lock_irqsave(&ehci->lock, flags);
1079 start_unlink_async(ehci, qh);
1081 start_unlink_intr(ehci, qh);
1084 spin_unlock_irqrestore(&ehci->lock, flags);
1089 struct ehci_hcd *ehci = hcd_to_ehci (hcd);
1090 return (ehci_read_frame_index(ehci) >> 3) % ehci->periodic_size;
1099 struct ehci_hcd *ehci = hcd_to_ehci(hcd);
1101 spin_lock_irq(&ehci->lock);
1103 spin_unlock_irq(&ehci->lock);
1111 static void ehci_zx_wakeup_clear(struct ehci_hcd *ehci)
1113 u32 __iomem *reg = &ehci->regs->port_status[4];
1114 u32 t1 = ehci_readl(ehci, reg);
1118 ehci_writel(ehci, t1, reg);
1119 t1 = ehci_readl(ehci, reg);
1122 ehci_writel(ehci, t1, reg);
1123 ehci_readl(ehci, reg);
1125 t1 = ehci_readl(ehci, reg);
1126 ehci_writel(ehci, t1 | PORT_CSC, reg);
1127 ehci_readl(ehci, reg);
1136 struct ehci_hcd *ehci = hcd_to_ehci(hcd);
1138 if (time_before(jiffies, ehci->next_statechange))
1146 ehci_prepare_ports_for_controller_suspend(ehci, do_wakeup);
1148 spin_lock_irq(&ehci->lock);
1149 ehci_writel(ehci, 0, &ehci->regs->intr_enable);
1150 (void) ehci_readl(ehci, &ehci->regs->intr_enable);
1153 spin_unlock_irq(&ehci->lock);
1170 struct ehci_hcd *ehci = hcd_to_ehci(hcd);
1172 if (time_before(jiffies, ehci->next_statechange))
1178 if (ehci->shutdown)
1181 if (ehci->zx_wakeup_clear_needed)
1182 ehci_zx_wakeup_clear(ehci);
1189 if (ehci_readl(ehci, &ehci->regs->configured_flag) == FLAG_CF &&
1193 ehci_prepare_ports_for_controller_resume(ehci);
1195 spin_lock_irq(&ehci->lock);
1196 if (ehci->shutdown)
1201 ehci_writel(ehci, mask, &ehci->regs->intr_enable);
1202 ehci_readl(ehci, &ehci->regs->intr_enable);
1204 spin_unlock_irq(&ehci->lock);
1213 (void) ehci_halt(ehci);
1214 (void) ehci_reset(ehci);
1216 spin_lock_irq(&ehci->lock);
1217 if (ehci->shutdown)
1220 ehci_writel(ehci, ehci->command, &ehci->regs->command);
1221 ehci_writel(ehci, FLAG_CF, &ehci->regs->configured_flag);
1222 ehci_readl(ehci, &ehci->regs->command); /* unblock posted writes */
1224 ehci->rh_state = EHCI_RH_SUSPENDED;
1225 spin_unlock_irq(&ehci->lock);
1317 #include "ehci-sh.c"
1321 #include "ehci-ps3.c"
1325 #include "ehci-ppc-of.c"
1329 #include "ehci-xilinx-of.c"
1333 #include "ehci-grlib.c"
1370 ehci_debug_root = debugfs_create_dir("ehci", usb_debug_root);