Lines Matching refs:ehci
122 #include "ehci.h"
123 #include "ehci-dbg.c"
128 timer_action(struct ehci_hcd *ehci, enum ehci_timer_action action)
134 if (timer_pending(&ehci->watchdog)
136 & ehci->actions))
139 if (!test_and_set_bit(action, &ehci->actions)) {
144 if (!ehci->need_io_watchdog)
159 mod_timer(&ehci->watchdog, t + jiffies);
182 static int handshake (struct ehci_hcd *ehci, void __iomem *ptr,
188 result = ehci_readl(ehci, ptr);
201 static int ehci_halt (struct ehci_hcd *ehci)
203 u32 temp = ehci_readl(ehci, &ehci->regs->status);
206 ehci_writel(ehci, 0, &ehci->regs->intr_enable);
211 temp = ehci_readl(ehci, &ehci->regs->command);
213 ehci_writel(ehci, temp, &ehci->regs->command);
214 return handshake (ehci, &ehci->regs->status,
218 static int handshake_on_error_set_halt(struct ehci_hcd *ehci, void __iomem *ptr,
223 error = handshake(ehci, ptr, mask, done, usec);
225 ehci_halt(ehci);
226 ehci_to_hcd(ehci)->state = HC_STATE_HALT;
227 ehci_err(ehci, "force halt; handshake %p %08x %08x -> %d\n",
235 static void tdi_reset (struct ehci_hcd *ehci)
240 reg_ptr = (u32 __iomem *)(((u8 __iomem *)ehci->regs) + USBMODE);
241 tmp = ehci_readl(ehci, reg_ptr);
255 if (ehci_big_endian_mmio(ehci))
258 ehci_writel(ehci, tmp, reg_ptr);
262 static int ehci_reset (struct ehci_hcd *ehci)
265 u32 command = ehci_readl(ehci, &ehci->regs->command);
269 if (ehci->debug && !dbgp_reset_prep())
270 ehci->debug = NULL;
273 dbg_cmd (ehci, "reset", command);
274 ehci_writel(ehci, command, &ehci->regs->command);
275 ehci_to_hcd(ehci)->state = HC_STATE_HALT;
276 ehci->next_statechange = jiffies;
277 retval = handshake (ehci, &ehci->regs->command,
280 if (ehci->has_hostpc) {
281 ehci_writel(ehci, USBMODE_EX_HC | USBMODE_EX_VBPS,
282 (u32 __iomem *)(((u8 *)ehci->regs) + USBMODE_EX));
283 ehci_writel(ehci, TXFIFO_DEFAULT,
284 (u32 __iomem *)(((u8 *)ehci->regs) + TXFILLTUNING));
289 if (ehci_is_TDI(ehci))
290 tdi_reset (ehci);
292 if (ehci->debug)
299 static void ehci_quiesce (struct ehci_hcd *ehci)
304 if (!HC_IS_RUNNING (ehci_to_hcd(ehci)->state))
309 temp = ehci_readl(ehci, &ehci->regs->command) << 10;
311 if (handshake_on_error_set_halt(ehci, &ehci->regs->status,
316 temp = ehci_readl(ehci, &ehci->regs->command);
318 ehci_writel(ehci, temp, &ehci->regs->command);
321 handshake_on_error_set_halt(ehci, &ehci->regs->status,
327 static void end_unlink_async(struct ehci_hcd *ehci);
328 static void ehci_work(struct ehci_hcd *ehci);
330 #include "ehci-hub.c"
331 #include "ehci-lpm.c"
332 #include "ehci-mem.c"
333 #include "ehci-q.c"
334 #include "ehci-sched.c"
340 struct ehci_hcd *ehci = (struct ehci_hcd *) param;
343 spin_lock_irqsave (&ehci->lock, flags);
350 if (ehci->reclaim
351 && !timer_pending(&ehci->iaa_watchdog)
352 && HC_IS_RUNNING(ehci_to_hcd(ehci)->state)) {
361 cmd = ehci_readl(ehci, &ehci->regs->command);
363 ehci_writel(ehci, cmd & ~CMD_IAAD,
364 &ehci->regs->command);
372 status = ehci_readl(ehci, &ehci->regs->status);
374 COUNT (ehci->stats.lost_iaa);
375 ehci_writel(ehci, STS_IAA, &ehci->regs->status);
378 ehci_vdbg(ehci, "IAA watchdog: status %x cmd %x\n",
380 end_unlink_async(ehci);
383 spin_unlock_irqrestore(&ehci->lock, flags);
388 struct ehci_hcd *ehci = (struct ehci_hcd *) param;
391 spin_lock_irqsave(&ehci->lock, flags);
394 if (test_bit (TIMER_ASYNC_OFF, &ehci->actions))
395 start_unlink_async (ehci, ehci->async);
397 /* ehci could run by timer, without IRQs ... */
398 ehci_work (ehci);
400 spin_unlock_irqrestore (&ehci->lock, flags);
407 static void ehci_turn_off_all_ports(struct ehci_hcd *ehci)
409 int port = HCS_N_PORTS(ehci->hcs_params);
412 ehci_writel(ehci, PORT_RWC_BITS,
413 &ehci->regs->port_status[port]);
418 * Should be called with ehci->lock held.
420 static void ehci_silence_controller(struct ehci_hcd *ehci)
422 ehci_halt(ehci);
423 ehci_turn_off_all_ports(ehci);
426 ehci_writel(ehci, 0, &ehci->regs->configured_flag);
429 ehci_readl(ehci, &ehci->regs->configured_flag);
438 struct ehci_hcd *ehci = hcd_to_ehci(hcd);
440 del_timer_sync(&ehci->watchdog);
441 del_timer_sync(&ehci->iaa_watchdog);
443 spin_lock_irq(&ehci->lock);
444 ehci_silence_controller(ehci);
445 spin_unlock_irq(&ehci->lock);
448 static void ehci_port_power (struct ehci_hcd *ehci, int is_on)
452 if (!HCS_PPC (ehci->hcs_params))
455 ehci_dbg (ehci, "...power%s ports...\n", is_on ? "up" : "down");
456 for (port = HCS_N_PORTS (ehci->hcs_params); port > 0; )
457 (void) ehci_hub_control(ehci_to_hcd(ehci),
462 ehci_readl(ehci, &ehci->regs->command);
470 * it calls driver completion functions, after dropping ehci->lock.
472 static void ehci_work (struct ehci_hcd *ehci)
474 timer_action_done (ehci, TIMER_IO_WATCHDOG);
476 /* another CPU may drop ehci->lock during a schedule scan while
480 if (ehci->scanning)
482 ehci->scanning = 1;
483 scan_async (ehci);
484 if (ehci->next_uframe != -1)
485 scan_periodic (ehci);
486 ehci->scanning = 0;
492 if (HC_IS_RUNNING (ehci_to_hcd(ehci)->state) &&
493 (ehci->async->qh_next.ptr != NULL ||
494 ehci->periodic_sched != 0))
495 timer_action (ehci, TIMER_IO_WATCHDOG);
503 struct ehci_hcd *ehci = hcd_to_ehci (hcd);
505 ehci_dbg (ehci, "stop\n");
508 del_timer_sync (&ehci->watchdog);
509 del_timer_sync(&ehci->iaa_watchdog);
511 spin_lock_irq(&ehci->lock);
513 ehci_quiesce (ehci);
515 ehci_silence_controller(ehci);
516 ehci_reset (ehci);
517 spin_unlock_irq(&ehci->lock);
519 remove_companion_file(ehci);
520 remove_debug_files (ehci);
523 spin_lock_irq (&ehci->lock);
524 if (ehci->async)
525 ehci_work (ehci);
526 spin_unlock_irq (&ehci->lock);
527 ehci_mem_cleanup (ehci);
535 ehci_dbg (ehci, "irq normal %ld err %ld reclaim %ld (lost %ld)\n",
536 ehci->stats.normal, ehci->stats.error, ehci->stats.reclaim,
537 ehci->stats.lost_iaa);
538 ehci_dbg (ehci, "complete %ld unlink %ld\n",
539 ehci->stats.complete, ehci->stats.unlink);
542 dbg_status (ehci, "ehci_stop completed",
543 ehci_readl(ehci, &ehci->regs->status));
549 struct ehci_hcd *ehci = hcd_to_ehci(hcd);
555 spin_lock_init(&ehci->lock);
560 ehci->need_io_watchdog = 1;
561 init_timer(&ehci->watchdog);
562 ehci->watchdog.function = ehci_watchdog;
563 ehci->watchdog.data = (unsigned long) ehci;
565 init_timer(&ehci->iaa_watchdog);
566 ehci->iaa_watchdog.function = ehci_iaa_watchdog;
567 ehci->iaa_watchdog.data = (unsigned long) ehci;
569 hcc_params = ehci_readl(ehci, &ehci->caps->hcc_params);
575 ehci->periodic_size = DEFAULT_I_TDPS;
576 INIT_LIST_HEAD(&ehci->cached_itd_list);
577 INIT_LIST_HEAD(&ehci->cached_sitd_list);
582 case 0: ehci->periodic_size = 1024; break;
583 case 1: ehci->periodic_size = 512; break;
584 case 2: ehci->periodic_size = 256; break;
588 if ((retval = ehci_mem_init(ehci, GFP_KERNEL)) < 0)
593 ehci->i_thresh = 2 + 8;
595 ehci->i_thresh = 2 + HCC_ISOC_THRES(hcc_params);
597 ehci->reclaim = NULL;
598 ehci->next_uframe = -1;
599 ehci->clock_frame = -1;
608 ehci->async->qh_next.qh = NULL;
609 hw = ehci->async->hw;
610 hw->hw_next = QH_NEXT(ehci, ehci->async->qh_dma);
611 hw->hw_info1 = cpu_to_hc32(ehci, QH_HEAD);
612 hw->hw_token = cpu_to_hc32(ehci, QTD_STS_HALT);
613 hw->hw_qtd_next = EHCI_LIST_END(ehci);
614 ehci->async->qh_state = QH_STATE_LINKED;
615 hw->hw_alt_next = QTD_NEXT(ehci, ehci->async->dummy->qtd_dma);
622 ehci->has_ppcd = 1;
623 ehci_dbg(ehci, "enable per-port change event\n");
639 ehci_dbg(ehci, "park %d\n", park);
648 ehci_dbg(ehci, "support lpm\n");
649 ehci->has_lpm = 1;
651 ehci_dbg(ehci, "hird %d invalid, use default 0",
657 ehci->command = temp;
668 struct ehci_hcd *ehci = hcd_to_ehci (hcd);
676 if ((retval = ehci_reset(ehci)) != 0) {
677 ehci_mem_cleanup(ehci);
680 ehci_writel(ehci, ehci->periodic_dma, &ehci->regs->frame_list);
681 ehci_writel(ehci, (u32)ehci->async->qh_dma, &ehci->regs->async_next);
684 * hcc_params controls whether ehci->regs->segment must (!!!)
695 hcc_params = ehci_readl(ehci, &ehci->caps->hcc_params);
697 ehci_writel(ehci, 0, &ehci->regs->segment);
703 ehci->command &= ~(CMD_LRESET|CMD_IAAD|CMD_PSE|CMD_ASE|CMD_RESET);
704 ehci->command |= CMD_RUN;
705 ehci_writel(ehci, ehci->command, &ehci->regs->command);
706 dbg_cmd (ehci, "init", ehci->command);
724 ehci_writel(ehci, FLAG_CF, &ehci->regs->configured_flag);
725 ehci_readl(ehci, &ehci->regs->command); /* unblock posted writes */
728 ehci->last_periodic_enable = ktime_get_real();
730 temp = HC_VERSION(ehci_readl(ehci, &ehci->caps->hc_capbase));
731 ehci_info (ehci,
733 ((ehci->sbrn & 0xf0)>>4), (ehci->sbrn & 0x0f),
737 ehci_writel(ehci, INTR_MASK,
738 &ehci->regs->intr_enable); /* Turn On Interrupts */
744 create_debug_files(ehci);
745 create_companion_file(ehci);
754 struct ehci_hcd *ehci = hcd_to_ehci (hcd);
758 spin_lock (&ehci->lock);
760 status = ehci_readl(ehci, &ehci->regs->status);
764 ehci_dbg (ehci, "device removed\n");
770 spin_unlock(&ehci->lock);
775 ehci_writel(ehci, masked_status, &ehci->regs->status);
776 cmd = ehci_readl(ehci, &ehci->regs->command);
781 dbg_status (ehci, "irq", status);
789 COUNT (ehci->stats.normal);
791 COUNT (ehci->stats.error);
799 ehci_writel(ehci, cmd & ~CMD_IAAD,
800 &ehci->regs->command);
801 ehci_dbg(ehci, "IAA with IAAD still set?\n");
803 if (ehci->reclaim) {
804 COUNT(ehci->stats.reclaim);
805 end_unlink_async(ehci);
807 ehci_dbg(ehci, "IAA with nothing to reclaim?\n");
812 unsigned i = HCS_N_PORTS (ehci->hcs_params);
823 if (ehci->has_ppcd)
830 if (ehci->has_ppcd && !(ppcd & (1 << i)))
832 pstatus = ehci_readl(ehci,
833 &ehci->regs->port_status[i]);
837 if (!(test_bit(i, &ehci->suspended_ports) &&
841 ehci->reset_done[i] == 0))
849 ehci->reset_done[i] = jiffies + msecs_to_jiffies(25);
850 ehci_dbg (ehci, "port %d remote wakeup\n", i + 1);
851 mod_timer(&hcd->rh_timer, ehci->reset_done[i]);
857 ehci_err(ehci, "fatal error\n");
858 dbg_cmd(ehci, "fatal", cmd);
859 dbg_status(ehci, "fatal", status);
860 ehci_halt(ehci);
862 ehci_reset(ehci);
863 ehci_writel(ehci, 0, &ehci->regs->configured_flag);
871 ehci_work (ehci);
872 spin_unlock (&ehci->lock);
897 struct ehci_hcd *ehci = hcd_to_ehci (hcd);
912 if (!qh_urb_transaction (ehci, urb, &qtd_list, mem_flags))
914 return submit_async(ehci, urb, &qtd_list, mem_flags);
917 if (!qh_urb_transaction (ehci, urb, &qtd_list, mem_flags))
919 return intr_submit(ehci, urb, &qtd_list, mem_flags);
923 return itd_submit (ehci, urb, mem_flags);
925 return sitd_submit (ehci, urb, mem_flags);
929 static void unlink_async (struct ehci_hcd *ehci, struct ehci_qh *qh)
932 if (!HC_IS_RUNNING(ehci_to_hcd(ehci)->state) && ehci->reclaim)
933 end_unlink_async(ehci);
946 if (ehci->reclaim) {
949 for (last = ehci->reclaim;
958 start_unlink_async (ehci, qh);
967 struct ehci_hcd *ehci = hcd_to_ehci (hcd);
972 spin_lock_irqsave (&ehci->lock, flags);
987 unlink_async(ehci, qh);
995 qh_completions(ehci, qh);
1007 intr_deschedule (ehci, qh);
1010 qh_completions (ehci, qh);
1013 ehci_dbg (ehci, "bogus qh %p state %d\n",
1027 spin_unlock_irqrestore (&ehci->lock, flags);
1038 struct ehci_hcd *ehci = hcd_to_ehci (hcd);
1046 spin_lock_irqsave (&ehci->lock, flags);
1055 ehci_vdbg (ehci, "iso delay\n");
1064 for (tmp = ehci->async->qh_next.qh;
1072 unlink_async(ehci, qh);
1077 spin_unlock_irqrestore (&ehci->lock, flags);
1092 ehci_err (ehci, "qh %p (#%02x) state %d%s\n",
1099 spin_unlock_irqrestore (&ehci->lock, flags);
1106 struct ehci_hcd *ehci = hcd_to_ehci(hcd);
1116 spin_lock_irqsave(&ehci->lock, flags);
1136 unlink_async(ehci, qh);
1138 intr_deschedule(ehci, qh);
1141 spin_unlock_irqrestore(&ehci->lock, flags);
1146 struct ehci_hcd *ehci = hcd_to_ehci (hcd);
1147 return (ehci_readl(ehci, &ehci->regs->frame_index) >> 3) %
1148 ehci->periodic_size;
1158 #include "ehci-pci.c"
1163 #include "ehci-fsl.c"
1168 #include "ehci-mxc.c"
1173 #include "ehci-au1xxx.c"
1178 #include "ehci-omap.c"
1183 #include "ehci-ps3.c"
1188 #include "ehci-ppc-of.c"
1193 #include "ehci-xilinx-of.c"
1198 #include "ehci-orion.c"
1203 #include "ehci-ixp4xx.c"
1208 #include "ehci-w90x900.c"
1213 #include "ehci-atmel.c"
1218 #include "ehci-mips.c"
1225 #error "missing bus glue for ehci-hcd"
1248 ehci_debug_root = debugfs_create_dir("ehci", usb_debug_root);