Lines Matching refs:uhci
49 #include "uhci-hcd.h"
69 * show all queues in /sys/kernel/debug/uhci/[pci_addr]
91 static void suspend_rh(struct uhci_hcd *uhci, enum uhci_rh_state new_state);
92 static void wakeup_rh(struct uhci_hcd *uhci);
93 static void uhci_get_current_frame_number(struct uhci_hcd *uhci);
98 static __hc32 uhci_frame_skel_link(struct uhci_hcd *uhci, int frame)
120 return LINK_TO_QH(uhci, uhci->skelqh[skelnum]);
123 #include "uhci-debug.c"
124 #include "uhci-q.c"
125 #include "uhci-hub.c"
130 static void finish_reset(struct uhci_hcd *uhci)
138 for (port = 0; port < uhci->rh_numports; ++port)
139 uhci_writew(uhci, 0, USBPORTSC1 + (port * 2));
141 uhci->port_c_suspend = uhci->resuming_ports = 0;
142 uhci->rh_state = UHCI_RH_RESET;
143 uhci->is_stopped = UHCI_IS_STOPPED;
144 clear_bit(HCD_FLAG_POLL_RH, &uhci_to_hcd(uhci)->flags);
151 static void uhci_hc_died(struct uhci_hcd *uhci)
153 uhci_get_current_frame_number(uhci);
154 uhci->reset_hc(uhci);
155 finish_reset(uhci);
156 uhci->dead = 1;
159 ++uhci->frame_number;
167 static void check_and_reset_hc(struct uhci_hcd *uhci)
169 if (uhci->check_and_reset_hc(uhci))
170 finish_reset(uhci);
184 static void uhci_generic_reset_hc(struct uhci_hcd *uhci)
191 uhci_writew(uhci, USBCMD_HCRESET, USBCMD);
194 if (uhci_readw(uhci, USBCMD) & USBCMD_HCRESET)
195 dev_warn(uhci_dev(uhci), "HCRESET not completed yet!\n");
200 uhci_writew(uhci, 0, USBINTR);
201 uhci_writew(uhci, 0, USBCMD);
210 static int uhci_generic_check_and_reset_hc(struct uhci_hcd *uhci)
224 cmd = uhci_readw(uhci, USBCMD);
226 dev_dbg(uhci_dev(uhci), "%s: cmd = 0x%04x\n",
231 intr = uhci_readw(uhci, USBINTR);
233 dev_dbg(uhci_dev(uhci), "%s: intr = 0x%04x\n",
240 dev_dbg(uhci_dev(uhci), "Performing full reset\n");
241 uhci_generic_reset_hc(uhci);
249 static void configure_hc(struct uhci_hcd *uhci)
252 uhci_writeb(uhci, USBSOF_DEFAULT, USBSOF);
255 uhci_writel(uhci, uhci->frame_dma_handle, USBFLBASEADD);
258 uhci_writew(uhci, uhci->frame_number & UHCI_MAX_SOF_NUMBER,
262 if (uhci->configure_hc)
263 uhci->configure_hc(uhci);
266 static int resume_detect_interrupts_are_broken(struct uhci_hcd *uhci)
273 return uhci->resume_detect_interrupts_are_broken ?
274 uhci->resume_detect_interrupts_are_broken(uhci) : 0;
277 static int global_suspend_mode_is_broken(struct uhci_hcd *uhci)
279 return uhci->global_suspend_mode_is_broken ?
280 uhci->global_suspend_mode_is_broken(uhci) : 0;
283 static void suspend_rh(struct uhci_hcd *uhci, enum uhci_rh_state new_state)
284 __releases(uhci->lock)
285 __acquires(uhci->lock)
289 struct usb_device *rhdev = uhci_to_hcd(uhci)->self.root_hub;
338 if (!wakeup_enable || global_suspend_mode_is_broken(uhci) ||
339 resume_detect_interrupts_are_broken(uhci))
342 uhci->RD_enable = !!int_enable;
343 uhci_writew(uhci, int_enable, USBINTR);
344 uhci_writew(uhci, egsm_enable | USBCMD_CF, USBCMD);
353 if (!auto_stop && !(uhci_readw(uhci, USBSTS) & USBSTS_HCH)) {
354 uhci->rh_state = UHCI_RH_SUSPENDING;
355 spin_unlock_irq(&uhci->lock);
357 spin_lock_irq(&uhci->lock);
358 if (uhci->dead)
361 if (!(uhci_readw(uhci, USBSTS) & USBSTS_HCH))
362 dev_warn(uhci_dev(uhci), "Controller not stopped yet!\n");
364 uhci_get_current_frame_number(uhci);
366 uhci->rh_state = new_state;
367 uhci->is_stopped = UHCI_IS_STOPPED;
375 set_bit(HCD_FLAG_POLL_RH, &uhci_to_hcd(uhci)->flags);
377 clear_bit(HCD_FLAG_POLL_RH, &uhci_to_hcd(uhci)->flags);
379 uhci_scan_schedule(uhci);
380 uhci_fsbr_off(uhci);
383 static void start_rh(struct uhci_hcd *uhci)
385 uhci->is_stopped = 0;
390 uhci_writew(uhci, USBCMD_RS | USBCMD_CF | USBCMD_MAXP, USBCMD);
391 uhci_writew(uhci, USBINTR_TIMEOUT | USBINTR_RESUME |
394 uhci->rh_state = UHCI_RH_RUNNING;
395 set_bit(HCD_FLAG_POLL_RH, &uhci_to_hcd(uhci)->flags);
398 static void wakeup_rh(struct uhci_hcd *uhci)
399 __releases(uhci->lock)
400 __acquires(uhci->lock)
402 dev_dbg(&uhci_to_hcd(uhci)->self.root_hub->dev,
404 uhci->rh_state == UHCI_RH_AUTO_STOPPED ?
411 if (uhci->rh_state == UHCI_RH_SUSPENDED) {
415 egsm = uhci_readw(uhci, USBCMD) & USBCMD_EGSM;
416 uhci->rh_state = UHCI_RH_RESUMING;
417 uhci_writew(uhci, USBCMD_FGR | USBCMD_CF | egsm, USBCMD);
418 spin_unlock_irq(&uhci->lock);
420 spin_lock_irq(&uhci->lock);
421 if (uhci->dead)
425 uhci_writew(uhci, USBCMD_CF, USBCMD);
428 if (uhci_readw(uhci, USBCMD) & USBCMD_FGR)
429 dev_warn(uhci_dev(uhci), "FGR not stopped yet!\n");
432 start_rh(uhci);
435 mod_timer(&uhci_to_hcd(uhci)->rh_timer, jiffies);
440 struct uhci_hcd *uhci = hcd_to_uhci(hcd);
448 status = uhci_readw(uhci, USBSTS);
451 uhci_writew(uhci, status, USBSTS); /* Clear it */
453 spin_lock(&uhci->lock);
454 if (unlikely(!uhci->is_initialized)) /* not yet configured */
459 dev_err(uhci_dev(uhci),
462 dev_err(uhci_dev(uhci),
465 if (uhci->rh_state >= UHCI_RH_RUNNING) {
466 dev_err(uhci_dev(uhci),
470 uhci_sprint_schedule(uhci, errbuf,
474 uhci_hc_died(uhci);
485 spin_unlock(&uhci->lock);
488 uhci_scan_schedule(uhci);
490 spin_unlock(&uhci->lock);
497 * Store the current frame number in uhci->frame_number if the controller
504 static void uhci_get_current_frame_number(struct uhci_hcd *uhci)
506 if (!uhci->is_stopped) {
509 delta = (uhci_readw(uhci, USBFRNUM) - uhci->frame_number) &
511 uhci->frame_number += delta;
518 static void release_uhci(struct uhci_hcd *uhci)
523 spin_lock_irq(&uhci->lock);
524 uhci->is_initialized = 0;
525 spin_unlock_irq(&uhci->lock);
527 debugfs_remove(uhci->dentry);
530 uhci_free_qh(uhci, uhci->skelqh[i]);
532 uhci_free_td(uhci, uhci->term_td);
534 dma_pool_destroy(uhci->qh_pool);
536 dma_pool_destroy(uhci->td_pool);
538 kfree(uhci->frame_cpu);
540 dma_free_coherent(uhci_dev(uhci),
541 UHCI_NUMFRAMES * sizeof(*uhci->frame),
542 uhci->frame, uhci->frame_dma_handle);
565 struct uhci_hcd *uhci = hcd_to_uhci(hcd);
575 spin_lock_init(&uhci->lock);
576 setup_timer(&uhci->fsbr_timer, uhci_fsbr_timeout,
577 (unsigned long) uhci);
578 INIT_LIST_HEAD(&uhci->idle_qh_list);
579 init_waitqueue_head(&uhci->waitqh);
584 uhci, &uhci_debug_operations);
586 dev_err(uhci_dev(uhci), "couldn't create uhci debugfs entry\n");
589 uhci->dentry = dentry;
592 uhci->frame = dma_alloc_coherent(uhci_dev(uhci),
593 UHCI_NUMFRAMES * sizeof(*uhci->frame),
594 &uhci->frame_dma_handle, GFP_KERNEL);
595 if (!uhci->frame) {
596 dev_err(uhci_dev(uhci),
600 memset(uhci->frame, 0, UHCI_NUMFRAMES * sizeof(*uhci->frame));
602 uhci->frame_cpu = kcalloc(UHCI_NUMFRAMES, sizeof(*uhci->frame_cpu),
604 if (!uhci->frame_cpu) {
605 dev_err(uhci_dev(uhci),
610 uhci->td_pool = dma_pool_create("uhci_td", uhci_dev(uhci),
612 if (!uhci->td_pool) {
613 dev_err(uhci_dev(uhci), "unable to create td dma_pool\n");
617 uhci->qh_pool = dma_pool_create("uhci_qh", uhci_dev(uhci),
619 if (!uhci->qh_pool) {
620 dev_err(uhci_dev(uhci), "unable to create qh dma_pool\n");
624 uhci->term_td = uhci_alloc_td(uhci);
625 if (!uhci->term_td) {
626 dev_err(uhci_dev(uhci), "unable to allocate terminating TD\n");
631 uhci->skelqh[i] = uhci_alloc_qh(uhci, NULL, NULL);
632 if (!uhci->skelqh[i]) {
633 dev_err(uhci_dev(uhci), "unable to allocate QH\n");
642 uhci->skelqh[i]->link = LINK_TO_QH(uhci, uhci->skel_async_qh);
643 uhci->skel_async_qh->link = UHCI_PTR_TERM(uhci);
644 uhci->skel_term_qh->link = LINK_TO_QH(uhci, uhci->skel_term_qh);
647 uhci_fill_td(uhci, uhci->term_td, 0, uhci_explen(0) |
649 uhci->term_td->link = UHCI_PTR_TERM(uhci);
650 uhci->skel_async_qh->element = uhci->skel_term_qh->element =
651 LINK_TO_TD(uhci, uhci->term_td);
660 uhci->frame[i] = uhci_frame_skel_link(uhci, i);
669 spin_lock_irq(&uhci->lock);
670 configure_hc(uhci);
671 uhci->is_initialized = 1;
672 start_rh(uhci);
673 spin_unlock_irq(&uhci->lock);
681 if (uhci->skelqh[i])
682 uhci_free_qh(uhci, uhci->skelqh[i]);
685 uhci_free_td(uhci, uhci->term_td);
688 dma_pool_destroy(uhci->qh_pool);
691 dma_pool_destroy(uhci->td_pool);
694 kfree(uhci->frame_cpu);
697 dma_free_coherent(uhci_dev(uhci),
698 UHCI_NUMFRAMES * sizeof(*uhci->frame),
699 uhci->frame, uhci->frame_dma_handle);
702 debugfs_remove(uhci->dentry);
709 struct uhci_hcd *uhci = hcd_to_uhci(hcd);
711 spin_lock_irq(&uhci->lock);
712 if (HCD_HW_ACCESSIBLE(hcd) && !uhci->dead)
713 uhci_hc_died(uhci);
714 uhci_scan_schedule(uhci);
715 spin_unlock_irq(&uhci->lock);
718 del_timer_sync(&uhci->fsbr_timer);
719 release_uhci(uhci);
725 struct uhci_hcd *uhci = hcd_to_uhci(hcd);
728 spin_lock_irq(&uhci->lock);
731 else if (uhci->dead)
740 uhci->resuming_ports) {
741 dev_dbg(uhci_dev(uhci),
745 suspend_rh(uhci, UHCI_RH_SUSPENDED);
746 spin_unlock_irq(&uhci->lock);
752 struct uhci_hcd *uhci = hcd_to_uhci(hcd);
755 spin_lock_irq(&uhci->lock);
758 else if (!uhci->dead)
759 wakeup_rh(uhci);
760 spin_unlock_irq(&uhci->lock);
770 struct uhci_hcd *uhci = hcd_to_uhci(hcd);
773 spin_lock_irq(&uhci->lock);
779 ++uhci->num_waiting;
780 spin_unlock_irq(&uhci->lock);
781 wait_event_interruptible(uhci->waitqh,
783 spin_lock_irq(&uhci->lock);
784 --uhci->num_waiting;
787 uhci_free_qh(uhci, qh);
789 spin_unlock_irq(&uhci->lock);
794 struct uhci_hcd *uhci = hcd_to_uhci(hcd);
799 frame_number = uhci->frame_number;
801 delta = (uhci_readw(uhci, USBFRNUM) - frame_number) &
809 struct uhci_hcd *uhci = hcd_to_uhci(hcd);
824 portstatus = uhci_readw(uhci, USBPORTSC1 + (port * 2));
829 dev_info(uhci_dev(uhci), "detected %d ports\n", port);
833 dev_info(uhci_dev(uhci),
844 #include "uhci-pci.c"
849 #include "uhci-grlib.c"
854 #include "uhci-platform.c"
859 #error "missing bus glue for uhci-hcd"
877 uhci_debugfs_root = debugfs_create_dir("uhci", usb_debug_root);