Lines Matching refs:uhci
50 #include "uhci-hcd.h"
70 * show all queues in /sys/kernel/debug/uhci/[pci_addr]
89 static void suspend_rh(struct uhci_hcd *uhci, enum uhci_rh_state new_state);
90 static void wakeup_rh(struct uhci_hcd *uhci);
91 static void uhci_get_current_frame_number(struct uhci_hcd *uhci);
96 static __le32 uhci_frame_skel_link(struct uhci_hcd *uhci, int frame)
118 return LINK_TO_QH(uhci->skelqh[skelnum]);
121 #include "uhci-debug.c"
122 #include "uhci-q.c"
123 #include "uhci-hub.c"
128 static void finish_reset(struct uhci_hcd *uhci)
136 for (port = 0; port < uhci->rh_numports; ++port)
137 outw(0, uhci->io_addr + USBPORTSC1 + (port * 2));
139 uhci->port_c_suspend = uhci->resuming_ports = 0;
140 uhci->rh_state = UHCI_RH_RESET;
141 uhci->is_stopped = UHCI_IS_STOPPED;
142 uhci_to_hcd(uhci)->state = HC_STATE_HALT;
143 clear_bit(HCD_FLAG_POLL_RH, &uhci_to_hcd(uhci)->flags);
145 uhci->dead = 0; /* Full reset resurrects the controller */
152 static void uhci_hc_died(struct uhci_hcd *uhci)
154 uhci_get_current_frame_number(uhci);
155 uhci_reset_hc(to_pci_dev(uhci_dev(uhci)), uhci->io_addr);
156 finish_reset(uhci);
157 uhci->dead = 1;
160 ++uhci->frame_number;
168 static void check_and_reset_hc(struct uhci_hcd *uhci)
170 if (uhci_check_and_reset_hc(to_pci_dev(uhci_dev(uhci)), uhci->io_addr))
171 finish_reset(uhci);
177 static void configure_hc(struct uhci_hcd *uhci)
179 struct pci_dev *pdev = to_pci_dev(uhci_dev(uhci));
182 outb(USBSOF_DEFAULT, uhci->io_addr + USBSOF);
185 outl(uhci->frame_dma_handle, uhci->io_addr + USBFLBASEADD);
188 outw(uhci->frame_number & UHCI_MAX_SOF_NUMBER,
189 uhci->io_addr + USBFRNUM);
192 uhci_to_hcd(uhci)->state = HC_STATE_SUSPENDED;
204 static int resume_detect_interrupts_are_broken(struct uhci_hcd *uhci)
213 switch (to_pci_dev(uhci_dev(uhci))->vendor) {
231 for (port = 0; port < uhci->rh_numports; ++port) {
232 if (inw(uhci->io_addr + USBPORTSC1 + port * 2) &
241 static int global_suspend_mode_is_broken(struct uhci_hcd *uhci)
253 for (port = 0; port < uhci->rh_numports; ++port) {
254 if (inw(uhci->io_addr + USBPORTSC1 + port * 2) &
263 static void suspend_rh(struct uhci_hcd *uhci, enum uhci_rh_state new_state)
264 __releases(uhci->lock)
265 __acquires(uhci->lock)
269 struct usb_device *rhdev = uhci_to_hcd(uhci)->self.root_hub;
279 uhci->RD_enable = 1;
307 if (!wakeup_enable || global_suspend_mode_is_broken(uhci))
319 if (!wakeup_enable || resume_detect_interrupts_are_broken(uhci) ||
321 uhci->RD_enable = int_enable = 0;
323 outw(int_enable, uhci->io_addr + USBINTR);
324 outw(egsm_enable | USBCMD_CF, uhci->io_addr + USBCMD);
333 if (!auto_stop && !(inw(uhci->io_addr + USBSTS) & USBSTS_HCH)) {
334 uhci->rh_state = UHCI_RH_SUSPENDING;
335 spin_unlock_irq(&uhci->lock);
337 spin_lock_irq(&uhci->lock);
338 if (uhci->dead)
341 if (!(inw(uhci->io_addr + USBSTS) & USBSTS_HCH))
342 dev_warn(uhci_dev(uhci), "Controller not stopped yet!\n");
344 uhci_get_current_frame_number(uhci);
346 uhci->rh_state = new_state;
347 uhci->is_stopped = UHCI_IS_STOPPED;
353 set_bit(HCD_FLAG_POLL_RH, &uhci_to_hcd(uhci)->flags);
355 clear_bit(HCD_FLAG_POLL_RH, &uhci_to_hcd(uhci)->flags);
357 uhci_scan_schedule(uhci);
358 uhci_fsbr_off(uhci);
361 static void start_rh(struct uhci_hcd *uhci)
363 uhci_to_hcd(uhci)->state = HC_STATE_RUNNING;
364 uhci->is_stopped = 0;
369 outw(USBCMD_RS | USBCMD_CF | USBCMD_MAXP, uhci->io_addr + USBCMD);
371 uhci->io_addr + USBINTR);
373 uhci->rh_state = UHCI_RH_RUNNING;
374 set_bit(HCD_FLAG_POLL_RH, &uhci_to_hcd(uhci)->flags);
377 static void wakeup_rh(struct uhci_hcd *uhci)
378 __releases(uhci->lock)
379 __acquires(uhci->lock)
381 dev_dbg(&uhci_to_hcd(uhci)->self.root_hub->dev,
383 uhci->rh_state == UHCI_RH_AUTO_STOPPED ?
390 if (uhci->rh_state == UHCI_RH_SUSPENDED) {
394 egsm = inw(uhci->io_addr + USBCMD) & USBCMD_EGSM;
395 uhci->rh_state = UHCI_RH_RESUMING;
396 outw(USBCMD_FGR | USBCMD_CF | egsm, uhci->io_addr + USBCMD);
397 spin_unlock_irq(&uhci->lock);
399 spin_lock_irq(&uhci->lock);
400 if (uhci->dead)
404 outw(USBCMD_CF, uhci->io_addr + USBCMD);
407 if (inw(uhci->io_addr + USBCMD) & USBCMD_FGR)
408 dev_warn(uhci_dev(uhci), "FGR not stopped yet!\n");
411 start_rh(uhci);
414 mod_timer(&uhci_to_hcd(uhci)->rh_timer, jiffies);
419 struct uhci_hcd *uhci = hcd_to_uhci(hcd);
427 status = inw(uhci->io_addr + USBSTS);
430 outw(status, uhci->io_addr + USBSTS); /* Clear it */
434 dev_err(uhci_dev(uhci), "host system error, "
437 dev_err(uhci_dev(uhci), "host controller process "
440 spin_lock(&uhci->lock);
441 if (uhci->rh_state >= UHCI_RH_RUNNING) {
442 dev_err(uhci_dev(uhci),
447 uhci_sprint_schedule(uhci,
451 uhci_hc_died(uhci);
457 spin_unlock(&uhci->lock);
464 spin_lock(&uhci->lock);
465 uhci_scan_schedule(uhci);
466 spin_unlock(&uhci->lock);
473 * Store the current frame number in uhci->frame_number if the controller
480 static void uhci_get_current_frame_number(struct uhci_hcd *uhci)
482 if (!uhci->is_stopped) {
485 delta = (inw(uhci->io_addr + USBFRNUM) - uhci->frame_number) &
487 uhci->frame_number += delta;
494 static void release_uhci(struct uhci_hcd *uhci)
499 spin_lock_irq(&uhci->lock);
500 uhci->is_initialized = 0;
501 spin_unlock_irq(&uhci->lock);
503 debugfs_remove(uhci->dentry);
507 uhci_free_qh(uhci, uhci->skelqh[i]);
509 uhci_free_td(uhci, uhci->term_td);
511 dma_pool_destroy(uhci->qh_pool);
513 dma_pool_destroy(uhci->td_pool);
515 kfree(uhci->frame_cpu);
517 dma_free_coherent(uhci_dev(uhci),
518 UHCI_NUMFRAMES * sizeof(*uhci->frame),
519 uhci->frame, uhci->frame_dma_handle);
524 struct uhci_hcd *uhci = hcd_to_uhci(hcd);
528 uhci->io_addr = (unsigned long) hcd->rsrc_start;
541 portstatus = inw(uhci->io_addr + USBPORTSC1 + (port * 2));
546 dev_info(uhci_dev(uhci), "detected %d ports\n", port);
550 dev_info(uhci_dev(uhci), "port count misdetected? "
554 uhci->rh_numports = port;
559 check_and_reset_hc(uhci);
597 struct uhci_hcd *uhci = hcd_to_uhci(hcd);
604 spin_lock_init(&uhci->lock);
605 setup_timer(&uhci->fsbr_timer, uhci_fsbr_timeout,
606 (unsigned long) uhci);
607 INIT_LIST_HEAD(&uhci->idle_qh_list);
608 init_waitqueue_head(&uhci->waitqh);
613 uhci, &uhci_debug_operations);
615 dev_err(uhci_dev(uhci), "couldn't create uhci debugfs entry\n");
618 uhci->dentry = dentry;
621 uhci->frame = dma_alloc_coherent(uhci_dev(uhci),
622 UHCI_NUMFRAMES * sizeof(*uhci->frame),
623 &uhci->frame_dma_handle, 0);
624 if (!uhci->frame) {
625 dev_err(uhci_dev(uhci), "unable to allocate "
629 memset(uhci->frame, 0, UHCI_NUMFRAMES * sizeof(*uhci->frame));
631 uhci->frame_cpu = kcalloc(UHCI_NUMFRAMES, sizeof(*uhci->frame_cpu),
633 if (!uhci->frame_cpu) {
634 dev_err(uhci_dev(uhci), "unable to allocate "
639 uhci->td_pool = dma_pool_create("uhci_td", uhci_dev(uhci),
641 if (!uhci->td_pool) {
642 dev_err(uhci_dev(uhci), "unable to create td dma_pool\n");
646 uhci->qh_pool = dma_pool_create("uhci_qh", uhci_dev(uhci),
648 if (!uhci->qh_pool) {
649 dev_err(uhci_dev(uhci), "unable to create qh dma_pool\n");
653 uhci->term_td = uhci_alloc_td(uhci);
654 if (!uhci->term_td) {
655 dev_err(uhci_dev(uhci), "unable to allocate terminating TD\n");
660 uhci->skelqh[i] = uhci_alloc_qh(uhci, NULL, NULL);
661 if (!uhci->skelqh[i]) {
662 dev_err(uhci_dev(uhci), "unable to allocate QH\n");
671 uhci->skelqh[i]->link = LINK_TO_QH(uhci->skel_async_qh);
672 uhci->skel_async_qh->link = UHCI_PTR_TERM;
673 uhci->skel_term_qh->link = LINK_TO_QH(uhci->skel_term_qh);
675 uhci_fill_td(uhci->term_td, 0, uhci_explen(0) |
677 uhci->term_td->link = UHCI_PTR_TERM;
678 uhci->skel_async_qh->element = uhci->skel_term_qh->element =
679 LINK_TO_TD(uhci->term_td);
688 uhci->frame[i] = uhci_frame_skel_link(uhci, i);
697 configure_hc(uhci);
698 uhci->is_initialized = 1;
699 spin_lock_irq(&uhci->lock);
700 start_rh(uhci);
701 spin_unlock_irq(&uhci->lock);
709 if (uhci->skelqh[i])
710 uhci_free_qh(uhci, uhci->skelqh[i]);
713 uhci_free_td(uhci, uhci->term_td);
716 dma_pool_destroy(uhci->qh_pool);
719 dma_pool_destroy(uhci->td_pool);
722 kfree(uhci->frame_cpu);
725 dma_free_coherent(uhci_dev(uhci),
726 UHCI_NUMFRAMES * sizeof(*uhci->frame),
727 uhci->frame, uhci->frame_dma_handle);
730 debugfs_remove(uhci->dentry);
737 struct uhci_hcd *uhci = hcd_to_uhci(hcd);
739 spin_lock_irq(&uhci->lock);
740 if (HCD_HW_ACCESSIBLE(hcd) && !uhci->dead)
741 uhci_hc_died(uhci);
742 uhci_scan_schedule(uhci);
743 spin_unlock_irq(&uhci->lock);
746 del_timer_sync(&uhci->fsbr_timer);
747 release_uhci(uhci);
753 struct uhci_hcd *uhci = hcd_to_uhci(hcd);
756 spin_lock_irq(&uhci->lock);
759 else if (uhci->dead)
768 uhci->resuming_ports) {
769 dev_dbg(uhci_dev(uhci), "suspend failed because a port "
773 suspend_rh(uhci, UHCI_RH_SUSPENDED);
774 spin_unlock_irq(&uhci->lock);
780 struct uhci_hcd *uhci = hcd_to_uhci(hcd);
783 spin_lock_irq(&uhci->lock);
786 else if (!uhci->dead)
787 wakeup_rh(uhci);
788 spin_unlock_irq(&uhci->lock);
794 struct uhci_hcd *uhci = hcd_to_uhci(hcd);
795 struct pci_dev *pdev = to_pci_dev(uhci_dev(uhci));
798 dev_dbg(uhci_dev(uhci), "%s\n", __func__);
800 spin_lock_irq(&uhci->lock);
801 if (!HCD_HW_ACCESSIBLE(hcd) || uhci->dead)
804 if (uhci->rh_state > UHCI_RH_SUSPENDED) {
805 dev_warn(uhci_dev(uhci), "Root hub isn't suspended!\n");
826 spin_unlock_irq(&uhci->lock);
832 struct uhci_hcd *uhci = hcd_to_uhci(hcd);
834 dev_dbg(uhci_dev(uhci), "%s\n", __func__);
841 spin_lock_irq(&uhci->lock);
845 uhci_hc_died(uhci);
851 check_and_reset_hc(uhci);
854 configure_hc(uhci);
857 if (uhci->rh_state == UHCI_RH_RESET)
860 spin_unlock_irq(&uhci->lock);
865 if (!uhci->RD_enable && hcd->self.root_hub->do_remote_wakeup)
878 struct uhci_hcd *uhci = hcd_to_uhci(hcd);
881 spin_lock_irq(&uhci->lock);
887 ++uhci->num_waiting;
888 spin_unlock_irq(&uhci->lock);
889 wait_event_interruptible(uhci->waitqh,
891 spin_lock_irq(&uhci->lock);
892 --uhci->num_waiting;
895 uhci_free_qh(uhci, qh);
897 spin_unlock_irq(&uhci->lock);
902 struct uhci_hcd *uhci = hcd_to_uhci(hcd);
907 frame_number = uhci->frame_number;
909 delta = (inw(uhci->io_addr + USBFRNUM) - frame_number) &
985 uhci_debugfs_root = debugfs_create_dir("uhci", usb_debug_root);