Lines Matching refs:ahcd
11 * [ uhci code and gregs ahcd fragments ]
69 static void admhc_dump(struct admhcd *ahcd, int verbose);
70 static int admhc_init(struct admhcd *ahcd);
87 struct admhcd *ahcd = hcd_to_admhcd(hcd);
96 spin_lock_irqsave(&ahcd->lock, flags);
97 urb_print(ahcd, urb, "ENQEUE", usb_pipein(pipe), -EINPROGRESS);
98 spin_unlock_irqrestore(&ahcd->lock, flags);
102 ed = ed_get(ahcd, urb->ep, urb->dev, pipe, urb->interval);
145 urb_priv = urb_priv_alloc(ahcd, td_cnt, mem_flags);
151 spin_lock_irqsave(&ahcd->lock, flags);
168 ret = ed_schedule(ahcd, ed);
174 u16 frame = admhc_frame_no(ahcd);
194 td_submit_urb(ahcd, urb);
197 admhc_dump_ed(ahcd, "admhc_urb_enqueue", urb_priv->ed, 1);
202 urb_priv_free(ahcd, urb_priv);
204 spin_unlock_irqrestore(&ahcd->lock, flags);
217 struct admhcd *ahcd = hcd_to_admhcd(hcd);
221 spin_lock_irqsave(&ahcd->lock, flags);
224 urb_print(ahcd, urb, "DEQUEUE", 1, status);
240 start_ed_unlink(ahcd, urb_priv->ed);
248 finish_urb(ahcd, urb, status);
250 spin_unlock_irqrestore(&ahcd->lock, flags);
264 struct admhcd *ahcd = hcd_to_admhcd(hcd);
276 spin_lock_irqsave(&ahcd->lock, flags);
277 admhc_dump_ed(ahcd, "EP-DISABLE", ed, 1);
278 spin_unlock_irqrestore(&ahcd->lock, flags);
282 spin_lock_irqsave(&ahcd->lock, flags);
287 finish_unlinks(ahcd, 0);
294 admhc_warn(ahcd, "IRQ INTR_SOFI lossage\n");
297 spin_unlock_irqrestore(&ahcd->lock, flags);
302 td_free(ahcd, ed->dummy);
303 ed_free(ahcd, ed);
311 admhc_err(ahcd, "leak ed %p (#%02x) state %d%s\n",
314 td_free(ahcd, ed->dummy);
320 spin_unlock_irqrestore(&ahcd->lock, flags);
325 struct admhcd *ahcd = hcd_to_admhcd(hcd);
327 return admhc_frame_no(ahcd);
330 static void admhc_usb_reset(struct admhcd *ahcd)
333 ahcd->hc_control = admhc_readl(ahcd, &ahcd->regs->control);
334 ahcd->hc_control &= OHCI_CTRL_RWC;
335 admhc_writel(ahcd, ahcd->hc_control, &ahcd->regs->control);
338 ahcd->host_control = ADMHC_BUSS_RESET;
339 admhc_writel(ahcd, ahcd->host_control, &ahcd->regs->host_control);
350 struct admhcd *ahcd;
352 ahcd = hcd_to_admhcd(hcd);
353 admhc_intr_disable(ahcd, ADMHC_INTR_MIE);
354 admhc_dma_disable(ahcd);
355 admhc_usb_reset(ahcd);
357 admhc_writel_flush(ahcd);
364 static void admhc_eds_cleanup(struct admhcd *ahcd)
366 if (ahcd->ed_tails[PIPE_INTERRUPT]) {
367 ed_free(ahcd, ahcd->ed_tails[PIPE_INTERRUPT]);
368 ahcd->ed_tails[PIPE_INTERRUPT] = NULL;
371 if (ahcd->ed_tails[PIPE_ISOCHRONOUS]) {
372 ed_free(ahcd, ahcd->ed_tails[PIPE_ISOCHRONOUS]);
373 ahcd->ed_tails[PIPE_ISOCHRONOUS] = NULL;
376 if (ahcd->ed_tails[PIPE_CONTROL]) {
377 ed_free(ahcd, ahcd->ed_tails[PIPE_CONTROL]);
378 ahcd->ed_tails[PIPE_CONTROL] = NULL;
381 if (ahcd->ed_tails[PIPE_BULK]) {
382 ed_free(ahcd, ahcd->ed_tails[PIPE_BULK]);
383 ahcd->ed_tails[PIPE_BULK] = NULL;
386 ahcd->ed_head = NULL;
391 static int admhc_eds_init(struct admhcd *ahcd)
395 ed = ed_create(ahcd, PIPE_INTERRUPT, ED_DUMMY_INFO);
399 ahcd->ed_tails[PIPE_INTERRUPT] = ed;
401 ed = ed_create(ahcd, PIPE_ISOCHRONOUS, ED_DUMMY_INFO);
405 ahcd->ed_tails[PIPE_ISOCHRONOUS] = ed;
406 ed->ed_prev = ahcd->ed_tails[PIPE_INTERRUPT];
407 ahcd->ed_tails[PIPE_INTERRUPT]->ed_next = ed;
408 ahcd->ed_tails[PIPE_INTERRUPT]->hwNextED = cpu_to_hc32(ahcd, ed->dma);
410 ed = ed_create(ahcd, PIPE_CONTROL, ED_DUMMY_INFO);
414 ahcd->ed_tails[PIPE_CONTROL] = ed;
415 ed->ed_prev = ahcd->ed_tails[PIPE_ISOCHRONOUS];
416 ahcd->ed_tails[PIPE_ISOCHRONOUS]->ed_next = ed;
417 ahcd->ed_tails[PIPE_ISOCHRONOUS]->hwNextED = cpu_to_hc32(ahcd, ed->dma);
419 ed = ed_create(ahcd, PIPE_BULK, ED_DUMMY_INFO);
423 ahcd->ed_tails[PIPE_BULK] = ed;
424 ed->ed_prev = ahcd->ed_tails[PIPE_CONTROL];
425 ahcd->ed_tails[PIPE_CONTROL]->ed_next = ed;
426 ahcd->ed_tails[PIPE_CONTROL]->hwNextED = cpu_to_hc32(ahcd, ed->dma);
428 ahcd->ed_head = ahcd->ed_tails[PIPE_INTERRUPT];
431 admhc_dump_ed(ahcd, "ed intr", ahcd->ed_tails[PIPE_INTERRUPT], 1);
432 admhc_dump_ed(ahcd, "ed isoc", ahcd->ed_tails[PIPE_ISOCHRONOUS], 1);
433 admhc_dump_ed(ahcd, "ed ctrl", ahcd->ed_tails[PIPE_CONTROL], 1);
434 admhc_dump_ed(ahcd, "ed bulk", ahcd->ed_tails[PIPE_BULK], 1);
440 admhc_eds_cleanup(ahcd);
446 static int admhc_init(struct admhcd *ahcd)
448 struct usb_hcd *hcd = admhcd_to_hcd(ahcd);
451 admhc_disable(ahcd);
452 ahcd->regs = hcd->regs;
455 admhc_intr_disable(ahcd, ADMHC_INTR_MIE);
458 if (ahcd->num_ports == 0)
459 ahcd->num_ports = admhc_read_rhdesc(ahcd) & ADMHC_RH_NUMP;
461 ret = admhc_mem_init(ahcd);
466 ret = admhc_eds_init(ahcd);
470 create_debug_files(ahcd);
485 static int admhc_run(struct admhcd *ahcd)
488 int first = ahcd->fminterval == 0;
489 struct usb_hcd *hcd = admhcd_to_hcd(ahcd);
491 admhc_disable(ahcd);
495 val = admhc_readl(ahcd, &ahcd->regs->fminterval);
496 ahcd->fminterval = val & ADMHC_SFI_FI_MASK;
497 if (ahcd->fminterval != FI)
498 admhc_dbg(ahcd, "fminterval delta %d\n",
499 ahcd->fminterval - FI);
500 ahcd->fminterval |=
501 (FSLDP(ahcd->fminterval) << ADMHC_SFI_FSLDP_SHIFT);
512 if ((ahcd->hc_control & OHCI_CTRL_RWC) != 0)
516 switch (ahcd->host_control & ADMHC_HC_BUSS) {
523 ahcd->host_control = ADMHC_BUSS_RESUME;
528 ahcd->host_control = ADMHC_BUSS_RESET;
532 admhc_writel(ahcd, ahcd->host_control, &ahcd->regs->host_control);
535 admhc_writel_flush(ahcd);
538 val = admhc_read_rhdesc(ahcd);
541 for (val = 0; val < ahcd->num_ports; val++)
542 admhc_write_portstatus(ahcd, val, ADMHC_PS_CPP);
545 admhc_writel_flush(ahcd);
548 spin_lock_irq(&ahcd->lock);
550 admhc_writel(ahcd, ADMHC_CTRL_SR, &ahcd->regs->gencontrol);
552 while ((admhc_readl(ahcd, &ahcd->regs->gencontrol) & ADMHC_CTRL_SR) != 0) {
554 spin_unlock_irq(&ahcd->lock);
555 admhc_err(ahcd, "USB HC reset timed out!\n");
562 admhc_writel(ahcd, ADMHC_CTRL_UHFE, &ahcd->regs->gencontrol);
565 admhc_writel(ahcd, (u32)ahcd->ed_head->dma, &ahcd->regs->hosthead);
567 periodic_reinit(ahcd);
575 admhc_writel(ahcd, RH_HS_DRWE, &ahcd->regs->roothub.status);
577 /* FIXME roothub_write_status (ahcd, ADMHC_RH_DRWE); */
581 admhc_intr_ack(ahcd, ~0);
582 admhc_intr_enable(ahcd, ADMHC_INTR_INIT);
584 admhc_writel(ahcd, ADMHC_RH_NPS | ADMHC_RH_LPSC, &ahcd->regs->rhdesc);
587 admhc_writel_flush(ahcd);
590 ahcd->host_control = ADMHC_BUSS_OPER;
591 admhc_writel(ahcd, ahcd->host_control, &ahcd->regs->host_control);
594 while ((admhc_readl(ahcd, &ahcd->regs->host_control)
597 spin_unlock_irq(&ahcd->lock);
598 admhc_err(ahcd, "unable to setup operational mode!\n");
606 ahcd->next_statechange = jiffies + STATECHANGE_DELAY;
610 admhc_dma_enable(ahcd);
613 while ((admhc_readl(ahcd, &ahcd->regs->host_control)
616 spin_unlock_irq(&ahcd->lock);
617 admhc_err(ahcd, "unable to enable DMA!\n");
618 admhc_dump(ahcd, 1);
626 spin_unlock_irq(&ahcd->lock);
639 struct admhcd *ahcd = hcd_to_admhcd(hcd);
640 struct admhcd_regs __iomem *regs = ahcd->regs;
643 ints = admhc_readl(ahcd, ®s->int_status);
649 ints &= admhc_readl(ahcd, ®s->int_enable);
653 admhc_disable(ahcd);
654 admhc_err(ahcd, "Fatal Error, controller disabled\n");
655 admhc_dump(ahcd, 1);
656 admhc_usb_reset(ahcd);
660 admhc_intr_disable(ahcd, ADMHC_INTR_BABI);
661 admhc_intr_ack(ahcd, ADMHC_INTR_BABI);
662 admhc_err(ahcd, "Babble Detected\n");
666 admhc_vdbg(ahcd, "Root Hub Status Change\n");
667 ahcd->next_statechange = jiffies + STATECHANGE_DELAY;
668 admhc_intr_ack(ahcd, ADMHC_INTR_RESI | ADMHC_INTR_INSM);
678 admhc_intr_disable(ahcd, ADMHC_INTR_INSM);
685 admhc_vdbg(ahcd, "Resume Detect\n");
686 admhc_intr_ack(ahcd, ADMHC_INTR_RESI);
688 if (ahcd->autostop) {
689 spin_lock(&ahcd->lock);
690 admhc_rh_resume(ahcd);
691 spin_unlock(&ahcd->lock);
697 admhc_vdbg(ahcd, "Transfer Descriptor Complete\n");
698 admhc_intr_ack(ahcd, ADMHC_INTR_TDC);
700 admhc_intr_disable(ahcd, ADMHC_INTR_TDC);
701 spin_lock(&ahcd->lock);
702 admhc_td_complete(ahcd);
703 spin_unlock(&ahcd->lock);
705 admhc_intr_enable(ahcd, ADMHC_INTR_TDC);
710 admhc_vdbg(ahcd, "Schedule Overrun\n");
714 spin_lock(&ahcd->lock);
715 if (ahcd->ed_rm_list)
716 finish_unlinks(ahcd, admhc_frame_no(ahcd));
718 if ((ints & ADMHC_INTR_SOFI) != 0 && !ahcd->ed_rm_list
720 admhc_intr_disable(ahcd, ADMHC_INTR_SOFI);
721 spin_unlock(&ahcd->lock);
724 admhc_vdbg(ahcd, "Start Of Frame\n");
725 spin_lock(&ahcd->lock);
728 finish_unlinks(ahcd, admhc_frameno(ahcd));
733 if ((ahcd->ed_rm_list == NULL) ||
739 admhc_intr_disable(ahcd, ADMHC_INTR_SOFI);
741 spin_unlock(&ahcd->lock);
746 admhc_intr_ack(ahcd, ints);
747 admhc_intr_enable(ahcd, ADMHC_INTR_MIE);
748 admhc_writel_flush(ahcd);
758 struct admhcd *ahcd = hcd_to_admhcd(hcd);
760 admhc_dump(ahcd, 1);
764 admhc_usb_reset(ahcd);
765 admhc_intr_disable(ahcd, ADMHC_INTR_MIE);
770 remove_debug_files(ahcd);
771 admhc_eds_cleanup(ahcd);
772 admhc_mem_cleanup(ahcd);