Lines Matching defs:uhci
50 #include "uhci-hcd.h"
70 * show all queues in /sys/kernel/debug/uhci/[pci_addr]
92 static void suspend_rh(struct uhci_hcd *uhci, enum uhci_rh_state new_state);
93 static void wakeup_rh(struct uhci_hcd *uhci);
94 static void uhci_get_current_frame_number(struct uhci_hcd *uhci);
99 static __hc32 uhci_frame_skel_link(struct uhci_hcd *uhci, int frame)
121 return LINK_TO_QH(uhci, uhci->skelqh[skelnum]);
124 #include "uhci-debug.c"
125 #include "uhci-q.c"
126 #include "uhci-hub.c"
131 static void finish_reset(struct uhci_hcd *uhci)
139 for (port = 0; port < uhci->rh_numports; ++port)
140 uhci_writew(uhci, 0, USBPORTSC1 + (port * 2));
142 uhci->port_c_suspend = uhci->resuming_ports = 0;
143 uhci->rh_state = UHCI_RH_RESET;
144 uhci->is_stopped = UHCI_IS_STOPPED;
145 clear_bit(HCD_FLAG_POLL_RH, &uhci_to_hcd(uhci)->flags);
152 static void uhci_hc_died(struct uhci_hcd *uhci)
154 uhci_get_current_frame_number(uhci);
155 uhci->reset_hc(uhci);
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(uhci))
171 finish_reset(uhci);
185 static void uhci_generic_reset_hc(struct uhci_hcd *uhci)
192 uhci_writew(uhci, USBCMD_HCRESET, USBCMD);
195 if (uhci_readw(uhci, USBCMD) & USBCMD_HCRESET)
196 dev_warn(uhci_dev(uhci), "HCRESET not completed yet!\n");
201 uhci_writew(uhci, 0, USBINTR);
202 uhci_writew(uhci, 0, USBCMD);
211 static int uhci_generic_check_and_reset_hc(struct uhci_hcd *uhci)
225 cmd = uhci_readw(uhci, USBCMD);
227 dev_dbg(uhci_dev(uhci), "%s: cmd = 0x%04x\n",
232 intr = uhci_readw(uhci, USBINTR);
234 dev_dbg(uhci_dev(uhci), "%s: intr = 0x%04x\n",
241 dev_dbg(uhci_dev(uhci), "Performing full reset\n");
242 uhci_generic_reset_hc(uhci);
250 static void configure_hc(struct uhci_hcd *uhci)
253 uhci_writeb(uhci, USBSOF_DEFAULT, USBSOF);
256 uhci_writel(uhci, uhci->frame_dma_handle, USBFLBASEADD);
259 uhci_writew(uhci, uhci->frame_number & UHCI_MAX_SOF_NUMBER,
263 if (uhci->configure_hc)
264 uhci->configure_hc(uhci);
267 static int resume_detect_interrupts_are_broken(struct uhci_hcd *uhci)
275 if (ignore_oc || uhci_is_aspeed(uhci))
278 return uhci->resume_detect_interrupts_are_broken ?
279 uhci->resume_detect_interrupts_are_broken(uhci) : 0;
282 static int global_suspend_mode_is_broken(struct uhci_hcd *uhci)
284 return uhci->global_suspend_mode_is_broken ?
285 uhci->global_suspend_mode_is_broken(uhci) : 0;
288 static void suspend_rh(struct uhci_hcd *uhci, enum uhci_rh_state new_state)
289 __releases(uhci->lock)
290 __acquires(uhci->lock)
294 struct usb_device *rhdev = uhci_to_hcd(uhci)->self.root_hub;
343 if (!wakeup_enable || global_suspend_mode_is_broken(uhci) ||
344 resume_detect_interrupts_are_broken(uhci))
347 uhci->RD_enable = !!int_enable;
348 uhci_writew(uhci, int_enable, USBINTR);
349 uhci_writew(uhci, egsm_enable | USBCMD_CF, USBCMD);
358 if (!auto_stop && !(uhci_readw(uhci, USBSTS) & USBSTS_HCH)) {
359 uhci->rh_state = UHCI_RH_SUSPENDING;
360 spin_unlock_irq(&uhci->lock);
362 spin_lock_irq(&uhci->lock);
363 if (uhci->dead)
366 if (!(uhci_readw(uhci, USBSTS) & USBSTS_HCH))
367 dev_warn(uhci_dev(uhci), "Controller not stopped yet!\n");
369 uhci_get_current_frame_number(uhci);
371 uhci->rh_state = new_state;
372 uhci->is_stopped = UHCI_IS_STOPPED;
380 set_bit(HCD_FLAG_POLL_RH, &uhci_to_hcd(uhci)->flags);
382 clear_bit(HCD_FLAG_POLL_RH, &uhci_to_hcd(uhci)->flags);
384 uhci_scan_schedule(uhci);
385 uhci_fsbr_off(uhci);
388 static void start_rh(struct uhci_hcd *uhci)
390 uhci->is_stopped = 0;
396 if (uhci_is_aspeed(uhci))
397 uhci_writew(uhci, uhci_readw(uhci, USBSTS), USBSTS);
402 uhci_writew(uhci, USBCMD_RS | USBCMD_CF | USBCMD_MAXP, USBCMD);
403 uhci_writew(uhci, USBINTR_TIMEOUT | USBINTR_RESUME |
406 uhci->rh_state = UHCI_RH_RUNNING;
407 set_bit(HCD_FLAG_POLL_RH, &uhci_to_hcd(uhci)->flags);
410 static void wakeup_rh(struct uhci_hcd *uhci)
411 __releases(uhci->lock)
412 __acquires(uhci->lock)
414 dev_dbg(&uhci_to_hcd(uhci)->self.root_hub->dev,
416 uhci->rh_state == UHCI_RH_AUTO_STOPPED ?
423 if (uhci->rh_state == UHCI_RH_SUSPENDED) {
427 egsm = uhci_readw(uhci, USBCMD) & USBCMD_EGSM;
428 uhci->rh_state = UHCI_RH_RESUMING;
429 uhci_writew(uhci, USBCMD_FGR | USBCMD_CF | egsm, USBCMD);
430 spin_unlock_irq(&uhci->lock);
432 spin_lock_irq(&uhci->lock);
433 if (uhci->dead)
437 uhci_writew(uhci, USBCMD_CF, USBCMD);
440 if (uhci_readw(uhci, USBCMD) & USBCMD_FGR)
441 dev_warn(uhci_dev(uhci), "FGR not stopped yet!\n");
444 start_rh(uhci);
447 mod_timer(&uhci_to_hcd(uhci)->rh_timer, jiffies);
452 struct uhci_hcd *uhci = hcd_to_uhci(hcd);
460 status = uhci_readw(uhci, USBSTS);
463 uhci_writew(uhci, status, USBSTS); /* Clear it */
465 spin_lock(&uhci->lock);
466 if (unlikely(!uhci->is_initialized)) /* not yet configured */
471 dev_err(uhci_dev(uhci),
474 dev_err(uhci_dev(uhci),
477 if (uhci->rh_state >= UHCI_RH_RUNNING) {
478 dev_err(uhci_dev(uhci),
482 uhci_sprint_schedule(uhci, errbuf,
486 uhci_hc_died(uhci);
497 spin_unlock(&uhci->lock);
500 uhci_scan_schedule(uhci);
502 spin_unlock(&uhci->lock);
509 * Store the current frame number in uhci->frame_number if the controller
516 static void uhci_get_current_frame_number(struct uhci_hcd *uhci)
518 if (!uhci->is_stopped) {
521 delta = (uhci_readw(uhci, USBFRNUM) - uhci->frame_number) &
523 uhci->frame_number += delta;
530 static void release_uhci(struct uhci_hcd *uhci)
535 spin_lock_irq(&uhci->lock);
536 uhci->is_initialized = 0;
537 spin_unlock_irq(&uhci->lock);
539 debugfs_remove(uhci->dentry);
542 uhci_free_qh(uhci, uhci->skelqh[i]);
544 uhci_free_td(uhci, uhci->term_td);
546 dma_pool_destroy(uhci->qh_pool);
548 dma_pool_destroy(uhci->td_pool);
550 kfree(uhci->frame_cpu);
552 dma_free_coherent(uhci_dev(uhci),
553 UHCI_NUMFRAMES * sizeof(*uhci->frame),
554 uhci->frame, uhci->frame_dma_handle);
577 struct uhci_hcd *uhci = hcd_to_uhci(hcd);
587 spin_lock_init(&uhci->lock);
588 timer_setup(&uhci->fsbr_timer, uhci_fsbr_timeout, 0);
589 INIT_LIST_HEAD(&uhci->idle_qh_list);
590 init_waitqueue_head(&uhci->waitqh);
593 uhci->dentry = debugfs_create_file(hcd->self.bus_name,
595 uhci_debugfs_root, uhci,
599 uhci->frame = dma_alloc_coherent(uhci_dev(uhci),
600 UHCI_NUMFRAMES * sizeof(*uhci->frame),
601 &uhci->frame_dma_handle, GFP_KERNEL);
602 if (!uhci->frame) {
603 dev_err(uhci_dev(uhci),
608 uhci->frame_cpu = kcalloc(UHCI_NUMFRAMES, sizeof(*uhci->frame_cpu),
610 if (!uhci->frame_cpu)
613 uhci->td_pool = dma_pool_create("uhci_td", uhci_dev(uhci),
615 if (!uhci->td_pool) {
616 dev_err(uhci_dev(uhci), "unable to create td dma_pool\n");
620 uhci->qh_pool = dma_pool_create("uhci_qh", uhci_dev(uhci),
622 if (!uhci->qh_pool) {
623 dev_err(uhci_dev(uhci), "unable to create qh dma_pool\n");
627 uhci->term_td = uhci_alloc_td(uhci);
628 if (!uhci->term_td) {
629 dev_err(uhci_dev(uhci), "unable to allocate terminating TD\n");
634 uhci->skelqh[i] = uhci_alloc_qh(uhci, NULL, NULL);
635 if (!uhci->skelqh[i]) {
636 dev_err(uhci_dev(uhci), "unable to allocate QH\n");
645 uhci->skelqh[i]->link = LINK_TO_QH(uhci, uhci->skel_async_qh);
646 uhci->skel_async_qh->link = UHCI_PTR_TERM(uhci);
647 uhci->skel_term_qh->link = LINK_TO_QH(uhci, uhci->skel_term_qh);
650 uhci_fill_td(uhci, uhci->term_td, 0, uhci_explen(0) |
652 uhci->term_td->link = UHCI_PTR_TERM(uhci);
653 uhci->skel_async_qh->element = uhci->skel_term_qh->element =
654 LINK_TO_TD(uhci, uhci->term_td);
663 uhci->frame[i] = uhci_frame_skel_link(uhci, i);
672 spin_lock_irq(&uhci->lock);
673 configure_hc(uhci);
674 uhci->is_initialized = 1;
675 start_rh(uhci);
676 spin_unlock_irq(&uhci->lock);
684 if (uhci->skelqh[i])
685 uhci_free_qh(uhci, uhci->skelqh[i]);
688 uhci_free_td(uhci, uhci->term_td);
691 dma_pool_destroy(uhci->qh_pool);
694 dma_pool_destroy(uhci->td_pool);
697 kfree(uhci->frame_cpu);
700 dma_free_coherent(uhci_dev(uhci),
701 UHCI_NUMFRAMES * sizeof(*uhci->frame),
702 uhci->frame, uhci->frame_dma_handle);
705 debugfs_remove(uhci->dentry);
712 struct uhci_hcd *uhci = hcd_to_uhci(hcd);
714 spin_lock_irq(&uhci->lock);
715 if (HCD_HW_ACCESSIBLE(hcd) && !uhci->dead)
716 uhci_hc_died(uhci);
717 uhci_scan_schedule(uhci);
718 spin_unlock_irq(&uhci->lock);
721 del_timer_sync(&uhci->fsbr_timer);
722 release_uhci(uhci);
728 struct uhci_hcd *uhci = hcd_to_uhci(hcd);
731 spin_lock_irq(&uhci->lock);
734 else if (uhci->dead)
743 uhci->resuming_ports) {
744 dev_dbg(uhci_dev(uhci),
748 suspend_rh(uhci, UHCI_RH_SUSPENDED);
749 spin_unlock_irq(&uhci->lock);
755 struct uhci_hcd *uhci = hcd_to_uhci(hcd);
758 spin_lock_irq(&uhci->lock);
761 else if (!uhci->dead)
762 wakeup_rh(uhci);
763 spin_unlock_irq(&uhci->lock);
773 struct uhci_hcd *uhci = hcd_to_uhci(hcd);
776 spin_lock_irq(&uhci->lock);
782 ++uhci->num_waiting;
783 spin_unlock_irq(&uhci->lock);
784 wait_event_interruptible(uhci->waitqh,
786 spin_lock_irq(&uhci->lock);
787 --uhci->num_waiting;
790 uhci_free_qh(uhci, qh);
792 spin_unlock_irq(&uhci->lock);
797 struct uhci_hcd *uhci = hcd_to_uhci(hcd);
802 frame_number = uhci->frame_number;
804 delta = (uhci_readw(uhci, USBFRNUM) - frame_number) &
812 struct uhci_hcd *uhci = hcd_to_uhci(hcd);
827 portstatus = uhci_readw(uhci, USBPORTSC1 + (port * 2));
832 dev_info(uhci_dev(uhci), "detected %d ports\n", port);
836 dev_info(uhci_dev(uhci),
847 #include "uhci-pci.c"
852 #include "uhci-grlib.c"
857 #include "uhci-platform.c"
862 #error "missing bus glue for uhci-hcd"
880 uhci_debugfs_root = debugfs_create_dir("uhci", usb_debug_root);