Searched refs:uhci (Results 1 - 16 of 16) sorted by relevance

/linux-4.1.27/drivers/usb/host/
H A Duhci-hcd.c49 #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) uhci_frame_skel_link() argument
120 return LINK_TO_QH(uhci, uhci->skelqh[skelnum]); uhci_frame_skel_link()
123 #include "uhci-debug.c"
124 #include "uhci-q.c"
125 #include "uhci-hub.c"
130 static void finish_reset(struct uhci_hcd *uhci) finish_reset() argument
138 for (port = 0; port < uhci->rh_numports; ++port) finish_reset()
139 uhci_writew(uhci, 0, USBPORTSC1 + (port * 2)); finish_reset()
141 uhci->port_c_suspend = uhci->resuming_ports = 0; finish_reset()
142 uhci->rh_state = UHCI_RH_RESET; finish_reset()
143 uhci->is_stopped = UHCI_IS_STOPPED; finish_reset()
144 clear_bit(HCD_FLAG_POLL_RH, &uhci_to_hcd(uhci)->flags); finish_reset()
151 static void uhci_hc_died(struct uhci_hcd *uhci) uhci_hc_died() argument
153 uhci_get_current_frame_number(uhci); uhci_hc_died()
154 uhci->reset_hc(uhci); uhci_hc_died()
155 finish_reset(uhci); uhci_hc_died()
156 uhci->dead = 1; uhci_hc_died()
159 ++uhci->frame_number; uhci_hc_died()
167 static void check_and_reset_hc(struct uhci_hcd *uhci) check_and_reset_hc() argument
169 if (uhci->check_and_reset_hc(uhci)) check_and_reset_hc()
170 finish_reset(uhci); check_and_reset_hc()
184 static void uhci_generic_reset_hc(struct uhci_hcd *uhci) uhci_generic_reset_hc() argument
191 uhci_writew(uhci, USBCMD_HCRESET, USBCMD); uhci_generic_reset_hc()
194 if (uhci_readw(uhci, USBCMD) & USBCMD_HCRESET) uhci_generic_reset_hc()
195 dev_warn(uhci_dev(uhci), "HCRESET not completed yet!\n"); uhci_generic_reset_hc()
200 uhci_writew(uhci, 0, USBINTR); uhci_generic_reset_hc()
201 uhci_writew(uhci, 0, USBCMD); uhci_generic_reset_hc()
210 static int uhci_generic_check_and_reset_hc(struct uhci_hcd *uhci) uhci_generic_check_and_reset_hc() argument
224 cmd = uhci_readw(uhci, USBCMD); uhci_generic_check_and_reset_hc()
226 dev_dbg(uhci_dev(uhci), "%s: cmd = 0x%04x\n", uhci_generic_check_and_reset_hc()
231 intr = uhci_readw(uhci, USBINTR); uhci_generic_check_and_reset_hc()
233 dev_dbg(uhci_dev(uhci), "%s: intr = 0x%04x\n", uhci_generic_check_and_reset_hc()
240 dev_dbg(uhci_dev(uhci), "Performing full reset\n"); uhci_generic_check_and_reset_hc()
241 uhci_generic_reset_hc(uhci); uhci_generic_check_and_reset_hc()
249 static void configure_hc(struct uhci_hcd *uhci) configure_hc() argument
252 uhci_writeb(uhci, USBSOF_DEFAULT, USBSOF); configure_hc()
255 uhci_writel(uhci, uhci->frame_dma_handle, USBFLBASEADD); configure_hc()
258 uhci_writew(uhci, uhci->frame_number & UHCI_MAX_SOF_NUMBER, configure_hc()
262 if (uhci->configure_hc) configure_hc()
263 uhci->configure_hc(uhci); configure_hc()
266 static int resume_detect_interrupts_are_broken(struct uhci_hcd *uhci) resume_detect_interrupts_are_broken() argument
273 return uhci->resume_detect_interrupts_are_broken ? resume_detect_interrupts_are_broken()
274 uhci->resume_detect_interrupts_are_broken(uhci) : 0; resume_detect_interrupts_are_broken()
277 static int global_suspend_mode_is_broken(struct uhci_hcd *uhci) global_suspend_mode_is_broken() argument
279 return uhci->global_suspend_mode_is_broken ? global_suspend_mode_is_broken()
280 uhci->global_suspend_mode_is_broken(uhci) : 0; global_suspend_mode_is_broken()
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); variable
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); variable
380 uhci_fsbr_off(uhci); variable
383 static void start_rh(struct uhci_hcd *uhci) start_rh() argument
385 uhci->is_stopped = 0; start_rh()
390 uhci_writew(uhci, USBCMD_RS | USBCMD_CF | USBCMD_MAXP, USBCMD); start_rh()
391 uhci_writew(uhci, USBINTR_TIMEOUT | USBINTR_RESUME | start_rh()
394 uhci->rh_state = UHCI_RH_RUNNING; start_rh()
395 set_bit(HCD_FLAG_POLL_RH, &uhci_to_hcd(uhci)->flags); start_rh()
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); variable
435 mod_timer(&uhci_to_hcd(uhci)->rh_timer, jiffies);
440 struct uhci_hcd *uhci = hcd_to_uhci(hcd); uhci_irq() local
448 status = uhci_readw(uhci, USBSTS); uhci_irq()
451 uhci_writew(uhci, status, USBSTS); /* Clear it */ uhci_irq()
453 spin_lock(&uhci->lock); uhci_irq()
454 if (unlikely(!uhci->is_initialized)) /* not yet configured */ uhci_irq()
459 dev_err(uhci_dev(uhci), uhci_irq()
462 dev_err(uhci_dev(uhci), uhci_irq()
465 if (uhci->rh_state >= UHCI_RH_RUNNING) { uhci_irq()
466 dev_err(uhci_dev(uhci), uhci_irq()
470 uhci_sprint_schedule(uhci, errbuf, uhci_irq()
474 uhci_hc_died(uhci); uhci_irq()
485 spin_unlock(&uhci->lock); uhci_irq()
488 uhci_scan_schedule(uhci); uhci_irq()
490 spin_unlock(&uhci->lock); uhci_irq()
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) uhci_get_current_frame_number() argument
506 if (!uhci->is_stopped) { uhci_get_current_frame_number()
509 delta = (uhci_readw(uhci, USBFRNUM) - uhci->frame_number) & uhci_get_current_frame_number()
511 uhci->frame_number += delta; uhci_get_current_frame_number()
518 static void release_uhci(struct uhci_hcd *uhci) release_uhci() argument
523 spin_lock_irq(&uhci->lock); release_uhci()
524 uhci->is_initialized = 0; release_uhci()
525 spin_unlock_irq(&uhci->lock); release_uhci()
527 debugfs_remove(uhci->dentry); release_uhci()
530 uhci_free_qh(uhci, uhci->skelqh[i]); release_uhci()
532 uhci_free_td(uhci, uhci->term_td); release_uhci()
534 dma_pool_destroy(uhci->qh_pool); release_uhci()
536 dma_pool_destroy(uhci->td_pool); release_uhci()
538 kfree(uhci->frame_cpu); release_uhci()
540 dma_free_coherent(uhci_dev(uhci), release_uhci()
541 UHCI_NUMFRAMES * sizeof(*uhci->frame), release_uhci()
542 uhci->frame, uhci->frame_dma_handle); release_uhci()
565 struct uhci_hcd *uhci = hcd_to_uhci(hcd); uhci_start() local
575 spin_lock_init(&uhci->lock); uhci_start()
576 setup_timer(&uhci->fsbr_timer, uhci_fsbr_timeout, uhci_start()
577 (unsigned long) uhci); uhci_start()
578 INIT_LIST_HEAD(&uhci->idle_qh_list); uhci_start()
579 init_waitqueue_head(&uhci->waitqh); uhci_start()
584 uhci, &uhci_debug_operations); uhci_start()
586 dev_err(uhci_dev(uhci), "couldn't create uhci debugfs entry\n"); uhci_start()
589 uhci->dentry = dentry; uhci_start()
592 uhci->frame = dma_alloc_coherent(uhci_dev(uhci), uhci_start()
593 UHCI_NUMFRAMES * sizeof(*uhci->frame), uhci_start()
594 &uhci->frame_dma_handle, GFP_KERNEL); uhci_start()
595 if (!uhci->frame) { uhci_start()
596 dev_err(uhci_dev(uhci), uhci_start()
600 memset(uhci->frame, 0, UHCI_NUMFRAMES * sizeof(*uhci->frame)); uhci_start()
602 uhci->frame_cpu = kcalloc(UHCI_NUMFRAMES, sizeof(*uhci->frame_cpu), uhci_start()
604 if (!uhci->frame_cpu) { uhci_start()
605 dev_err(uhci_dev(uhci), uhci_start()
610 uhci->td_pool = dma_pool_create("uhci_td", uhci_dev(uhci), uhci_start()
612 if (!uhci->td_pool) { uhci_start()
613 dev_err(uhci_dev(uhci), "unable to create td dma_pool\n"); uhci_start()
617 uhci->qh_pool = dma_pool_create("uhci_qh", uhci_dev(uhci), uhci_start()
619 if (!uhci->qh_pool) { uhci_start()
620 dev_err(uhci_dev(uhci), "unable to create qh dma_pool\n"); uhci_start()
624 uhci->term_td = uhci_alloc_td(uhci); uhci_start()
625 if (!uhci->term_td) { uhci_start()
626 dev_err(uhci_dev(uhci), "unable to allocate terminating TD\n"); uhci_start()
631 uhci->skelqh[i] = uhci_alloc_qh(uhci, NULL, NULL); uhci_start()
632 if (!uhci->skelqh[i]) { uhci_start()
633 dev_err(uhci_dev(uhci), "unable to allocate QH\n"); uhci_start()
642 uhci->skelqh[i]->link = LINK_TO_QH(uhci, uhci->skel_async_qh); uhci_start()
643 uhci->skel_async_qh->link = UHCI_PTR_TERM(uhci); uhci_start()
644 uhci->skel_term_qh->link = LINK_TO_QH(uhci, uhci->skel_term_qh); uhci_start()
647 uhci_fill_td(uhci, uhci->term_td, 0, uhci_explen(0) | uhci_start()
649 uhci->term_td->link = UHCI_PTR_TERM(uhci); uhci_start()
650 uhci->skel_async_qh->element = uhci->skel_term_qh->element = uhci_start()
651 LINK_TO_TD(uhci, uhci->term_td); uhci_start()
660 uhci->frame[i] = uhci_frame_skel_link(uhci, i); uhci_start()
669 spin_lock_irq(&uhci->lock); uhci_start()
670 configure_hc(uhci); uhci_start()
671 uhci->is_initialized = 1; uhci_start()
672 start_rh(uhci); uhci_start()
673 spin_unlock_irq(&uhci->lock); uhci_start()
681 if (uhci->skelqh[i]) uhci_start()
682 uhci_free_qh(uhci, uhci->skelqh[i]); uhci_start()
685 uhci_free_td(uhci, uhci->term_td); uhci_start()
688 dma_pool_destroy(uhci->qh_pool); uhci_start()
691 dma_pool_destroy(uhci->td_pool); uhci_start()
694 kfree(uhci->frame_cpu); uhci_start()
697 dma_free_coherent(uhci_dev(uhci), uhci_start()
698 UHCI_NUMFRAMES * sizeof(*uhci->frame), uhci_start()
699 uhci->frame, uhci->frame_dma_handle); uhci_start()
702 debugfs_remove(uhci->dentry); uhci_start()
709 struct uhci_hcd *uhci = hcd_to_uhci(hcd); uhci_stop() local
711 spin_lock_irq(&uhci->lock); uhci_stop()
712 if (HCD_HW_ACCESSIBLE(hcd) && !uhci->dead) uhci_stop()
713 uhci_hc_died(uhci); uhci_stop()
714 uhci_scan_schedule(uhci); uhci_stop()
715 spin_unlock_irq(&uhci->lock); uhci_stop()
718 del_timer_sync(&uhci->fsbr_timer); uhci_stop()
719 release_uhci(uhci); uhci_stop()
725 struct uhci_hcd *uhci = hcd_to_uhci(hcd); uhci_rh_suspend() local
728 spin_lock_irq(&uhci->lock); uhci_rh_suspend()
731 else if (uhci->dead) uhci_rh_suspend()
740 uhci->resuming_ports) { uhci_rh_suspend()
741 dev_dbg(uhci_dev(uhci), uhci_rh_suspend()
745 suspend_rh(uhci, UHCI_RH_SUSPENDED); uhci_rh_suspend()
746 spin_unlock_irq(&uhci->lock); uhci_rh_suspend()
752 struct uhci_hcd *uhci = hcd_to_uhci(hcd); uhci_rh_resume() local
755 spin_lock_irq(&uhci->lock); uhci_rh_resume()
758 else if (!uhci->dead) uhci_rh_resume()
759 wakeup_rh(uhci); uhci_rh_resume()
760 spin_unlock_irq(&uhci->lock); uhci_rh_resume()
770 struct uhci_hcd *uhci = hcd_to_uhci(hcd); uhci_hcd_endpoint_disable() local
773 spin_lock_irq(&uhci->lock); uhci_hcd_endpoint_disable()
779 ++uhci->num_waiting; uhci_hcd_endpoint_disable()
780 spin_unlock_irq(&uhci->lock); uhci_hcd_endpoint_disable()
781 wait_event_interruptible(uhci->waitqh, uhci_hcd_endpoint_disable()
783 spin_lock_irq(&uhci->lock); uhci_hcd_endpoint_disable()
784 --uhci->num_waiting; uhci_hcd_endpoint_disable()
787 uhci_free_qh(uhci, qh); uhci_hcd_endpoint_disable()
789 spin_unlock_irq(&uhci->lock); uhci_hcd_endpoint_disable()
794 struct uhci_hcd *uhci = hcd_to_uhci(hcd); uhci_hcd_get_frame_number() local
799 frame_number = uhci->frame_number; uhci_hcd_get_frame_number()
801 delta = (uhci_readw(uhci, USBFRNUM) - frame_number) & uhci_hcd_get_frame_number()
809 struct uhci_hcd *uhci = hcd_to_uhci(hcd); uhci_count_ports() local
824 portstatus = uhci_readw(uhci, USBPORTSC1 + (port * 2)); uhci_count_ports()
829 dev_info(uhci_dev(uhci), "detected %d ports\n", port); uhci_count_ports()
833 dev_info(uhci_dev(uhci), uhci_count_ports()
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); uhci_hcd_init()
H A Duhci-hub.c43 static int any_ports_active(struct uhci_hcd *uhci) any_ports_active() argument
47 for (port = 0; port < uhci->rh_numports; ++port) { any_ports_active()
48 if ((uhci_readw(uhci, USBPORTSC1 + port * 2) & any_ports_active()
50 test_bit(port, &uhci->port_c_suspend)) any_ports_active()
56 static inline int get_hub_status_data(struct uhci_hcd *uhci, char *buf) get_hub_status_data() argument
71 for (port = 0; port < uhci->rh_numports; ++port) { get_hub_status_data()
72 if ((uhci_readw(uhci, USBPORTSC1 + port * 2) & mask) || get_hub_status_data()
73 test_bit(port, &uhci->port_c_suspend)) get_hub_status_data()
80 status = uhci_readw(uhci, port_addr); \
84 uhci_writew(uhci, status, port_addr)
87 status = uhci_readw(uhci, port_addr); \
90 uhci_writew(uhci, status, port_addr)
95 static void uhci_finish_suspend(struct uhci_hcd *uhci, int port, uhci_finish_suspend() argument
101 if (uhci_readw(uhci, port_addr) & SUSPEND_BITS) { uhci_finish_suspend()
103 if (test_bit(port, &uhci->resuming_ports)) uhci_finish_suspend()
104 set_bit(port, &uhci->port_c_suspend); uhci_finish_suspend()
112 if (!(uhci_readw(uhci, port_addr) & SUSPEND_BITS)) uhci_finish_suspend()
117 clear_bit(port, &uhci->resuming_ports); uhci_finish_suspend()
118 usb_hcd_end_port_resume(&uhci_to_hcd(uhci)->self, port); uhci_finish_suspend()
124 static void wait_for_HP(struct uhci_hcd *uhci, unsigned long port_addr) wait_for_HP() argument
129 if (uhci_readw(uhci, port_addr) & USBPORTSC_CSC) wait_for_HP()
136 static void uhci_check_ports(struct uhci_hcd *uhci) uhci_check_ports() argument
142 for (port = 0; port < uhci->rh_numports; ++port) { uhci_check_ports()
144 status = uhci_readw(uhci, port_addr); uhci_check_ports()
146 if (time_after_eq(jiffies, uhci->ports_timeout)) { uhci_check_ports()
152 if (uhci->wait_for_hp) uhci_check_ports()
153 wait_for_HP(uhci, port_addr); uhci_check_ports()
164 if (!test_bit(port, &uhci->resuming_ports)) { uhci_check_ports()
167 set_bit(port, &uhci->resuming_ports); uhci_check_ports()
168 uhci->ports_timeout = jiffies + uhci_check_ports()
171 &uhci_to_hcd(uhci)->self, port); uhci_check_ports()
175 mod_timer(&uhci_to_hcd(uhci)->rh_timer, uhci_check_ports()
176 uhci->ports_timeout); uhci_check_ports()
178 uhci->ports_timeout)) { uhci_check_ports()
179 uhci_finish_suspend(uhci, port, port_addr); uhci_check_ports()
187 struct uhci_hcd *uhci = hcd_to_uhci(hcd); uhci_hub_status_data() local
191 spin_lock_irqsave(&uhci->lock, flags); uhci_hub_status_data()
193 uhci_scan_schedule(uhci); uhci_hub_status_data()
194 if (!HCD_HW_ACCESSIBLE(hcd) || uhci->dead) uhci_hub_status_data()
196 uhci_check_ports(uhci); uhci_hub_status_data()
198 status = get_hub_status_data(uhci, buf); uhci_hub_status_data()
200 switch (uhci->rh_state) { uhci_hub_status_data()
203 if (status || uhci->resuming_ports) { uhci_hub_status_data()
212 wakeup_rh(uhci); uhci_hub_status_data()
217 if (!any_ports_active(uhci)) { uhci_hub_status_data()
218 uhci->rh_state = UHCI_RH_RUNNING_NODEVS; uhci_hub_status_data()
219 uhci->auto_stop_time = jiffies + HZ; uhci_hub_status_data()
225 if (any_ports_active(uhci)) uhci_hub_status_data()
226 uhci->rh_state = UHCI_RH_RUNNING; uhci_hub_status_data()
227 else if (time_after_eq(jiffies, uhci->auto_stop_time) && uhci_hub_status_data()
228 !uhci->wait_for_hp) uhci_hub_status_data()
229 suspend_rh(uhci, UHCI_RH_AUTO_STOPPED); uhci_hub_status_data()
237 spin_unlock_irqrestore(&uhci->lock, flags); uhci_hub_status_data()
245 struct uhci_hcd *uhci = hcd_to_uhci(hcd); uhci_hub_control() local
252 if (!HCD_HW_ACCESSIBLE(hcd) || uhci->dead) uhci_hub_control()
255 spin_lock_irqsave(&uhci->lock, flags); uhci_hub_control()
263 if (port >= uhci->rh_numports) uhci_hub_control()
266 uhci_check_ports(uhci); uhci_hub_control()
267 status = uhci_readw(uhci, port_addr); uhci_hub_control()
273 if (uhci->oc_low) uhci_hub_control()
285 if (test_bit(port, &uhci->port_c_suspend)) { uhci_hub_control()
289 if (test_bit(port, &uhci->resuming_ports)) uhci_hub_control()
309 dev_dbg(uhci_dev(uhci), "port %d portsc %04x,%02x\n", uhci_hub_control()
327 if (port >= uhci->rh_numports) uhci_hub_control()
338 uhci_finish_suspend(uhci, port, port_addr); uhci_hub_control()
341 uhci->ports_timeout = jiffies + uhci_hub_control()
352 if (port >= uhci->rh_numports) uhci_hub_control()
360 uhci_finish_suspend(uhci, port, port_addr); uhci_hub_control()
366 if (!(uhci_readw(uhci, port_addr) & USBPORTSC_SUSP)) { uhci_hub_control()
369 uhci_finish_suspend(uhci, port, port_addr); uhci_hub_control()
371 &uhci->resuming_ports)) { uhci_hub_control()
378 if (!(uhci_readw(uhci, port_addr) & uhci_hub_control()
380 uhci_finish_suspend(uhci, port, uhci_hub_control()
384 uhci->ports_timeout = jiffies + uhci_hub_control()
389 clear_bit(port, &uhci->port_c_suspend); uhci_hub_control()
411 buf[2] = uhci->rh_numports; uhci_hub_control()
417 spin_unlock_irqrestore(&uhci->lock, flags); uhci_hub_control()
H A Duhci-pci.c4 * Extracted from uhci-hcd.c:
26 static void uhci_pci_reset_hc(struct uhci_hcd *uhci) uhci_pci_reset_hc() argument
28 uhci_reset_hc(to_pci_dev(uhci_dev(uhci)), uhci->io_addr); uhci_pci_reset_hc()
37 static int uhci_pci_check_and_reset_hc(struct uhci_hcd *uhci) uhci_pci_check_and_reset_hc() argument
39 return uhci_check_and_reset_hc(to_pci_dev(uhci_dev(uhci)), uhci_pci_check_and_reset_hc()
40 uhci->io_addr); uhci_pci_check_and_reset_hc()
45 * This function is called at the end of configure_hc in uhci-hcd.c.
47 static void uhci_pci_configure_hc(struct uhci_hcd *uhci) uhci_pci_configure_hc() argument
49 struct pci_dev *pdev = to_pci_dev(uhci_dev(uhci)); uhci_pci_configure_hc()
59 static int uhci_pci_resume_detect_interrupts_are_broken(struct uhci_hcd *uhci) uhci_pci_resume_detect_interrupts_are_broken() argument
63 switch (to_pci_dev(uhci_dev(uhci))->vendor) { uhci_pci_resume_detect_interrupts_are_broken()
81 for (port = 0; port < uhci->rh_numports; ++port) { uhci_pci_resume_detect_interrupts_are_broken()
82 if (inw(uhci->io_addr + USBPORTSC1 + port * 2) & uhci_pci_resume_detect_interrupts_are_broken()
91 static int uhci_pci_global_suspend_mode_is_broken(struct uhci_hcd *uhci) uhci_pci_global_suspend_mode_is_broken() argument
103 for (port = 0; port < uhci->rh_numports; ++port) { uhci_pci_global_suspend_mode_is_broken()
104 if (inw(uhci->io_addr + USBPORTSC1 + port * 2) & uhci_pci_global_suspend_mode_is_broken()
115 struct uhci_hcd *uhci = hcd_to_uhci(hcd); uhci_pci_init() local
117 uhci->io_addr = (unsigned long) hcd->rsrc_start; uhci_pci_init()
119 uhci->rh_numports = uhci_count_ports(hcd); uhci_pci_init()
125 if (to_pci_dev(uhci_dev(uhci))->vendor == PCI_VENDOR_ID_VIA) uhci_pci_init()
126 uhci->oc_low = 1; uhci_pci_init()
129 if (to_pci_dev(uhci_dev(uhci))->vendor == PCI_VENDOR_ID_HP) uhci_pci_init()
130 uhci->wait_for_hp = 1; uhci_pci_init()
133 uhci->reset_hc = uhci_pci_reset_hc; uhci_pci_init()
134 uhci->check_and_reset_hc = uhci_pci_check_and_reset_hc; uhci_pci_init()
135 uhci->configure_hc = uhci_pci_configure_hc; uhci_pci_init()
136 uhci->resume_detect_interrupts_are_broken = uhci_pci_init()
138 uhci->global_suspend_mode_is_broken = uhci_pci_init()
145 check_and_reset_hc(uhci); uhci_pci_init()
169 struct uhci_hcd *uhci = hcd_to_uhci(hcd); uhci_pci_suspend() local
170 struct pci_dev *pdev = to_pci_dev(uhci_dev(uhci)); uhci_pci_suspend()
173 dev_dbg(uhci_dev(uhci), "%s\n", __func__); uhci_pci_suspend()
175 spin_lock_irq(&uhci->lock); uhci_pci_suspend()
176 if (!HCD_HW_ACCESSIBLE(hcd) || uhci->dead) uhci_pci_suspend()
194 spin_unlock_irq(&uhci->lock); uhci_pci_suspend()
208 struct uhci_hcd *uhci = hcd_to_uhci(hcd); uhci_pci_resume() local
210 dev_dbg(uhci_dev(uhci), "%s\n", __func__); uhci_pci_resume()
217 spin_lock_irq(&uhci->lock); uhci_pci_resume()
221 uhci->reset_hc(uhci); uhci_pci_resume()
222 finish_reset(uhci); uhci_pci_resume()
229 check_and_reset_hc(uhci); uhci_pci_resume()
231 configure_hc(uhci); uhci_pci_resume()
234 if (uhci->rh_state == UHCI_RH_RESET) uhci_pci_resume()
237 spin_unlock_irq(&uhci->lock); uhci_pci_resume()
242 if (!uhci->RD_enable && hcd->self.root_hub->do_remote_wakeup) uhci_pci_resume()
H A Duhci-debug.c17 #include "uhci-hcd.h"
42 static int uhci_show_td(struct uhci_hcd *uhci, struct uhci_td *td, char *buf, uhci_show_td() argument
49 status = td_status(uhci, td); uhci_show_td()
51 hc32_to_cpu(uhci, td->link)); uhci_show_td()
68 token = td_token(uhci, td); uhci_show_td()
91 out += sprintf(out, "(buf=%08x)\n", hc32_to_cpu(uhci, td->buffer)); uhci_show_td()
99 static int uhci_show_urbp(struct uhci_hcd *uhci, struct urb_priv *urbp, uhci_show_urbp() argument
142 out += uhci_show_td(uhci, td, out, uhci_show_urbp()
147 if (td_status(uhci, td) & TD_CTRL_ACTIVE) uhci_show_urbp()
164 static int uhci_show_qh(struct uhci_hcd *uhci, uhci_show_qh() argument
182 hc32_to_cpu(uhci, qh->link), uhci_show_qh()
183 hc32_to_cpu(uhci, element)); uhci_show_qh()
195 if (element & UHCI_PTR_QH(uhci)) uhci_show_qh()
198 if (element & UHCI_PTR_DEPTH(uhci)) uhci_show_qh()
201 if (element & cpu_to_hc32(uhci, 8)) uhci_show_qh()
204 if (!(element & ~(UHCI_PTR_QH(uhci) | UHCI_PTR_DEPTH(uhci)))) uhci_show_qh()
212 if (qh == uhci->skel_async_qh) { uhci_show_qh()
213 out += uhci_show_td(uhci, uhci->term_td, out, uhci_show_qh()
224 if (element != LINK_TO_TD(uhci, td)) uhci_show_qh()
230 out += uhci_show_urbp(uhci, urbp, out, uhci_show_qh()
248 out += uhci_show_td(uhci, qh->dummy_td, out, uhci_show_qh()
278 static int uhci_show_root_hub_state(struct uhci_hcd *uhci, char *buf) uhci_show_root_hub_state() argument
282 switch (uhci->rh_state) { uhci_show_root_hub_state()
301 rh_state, uhci->fsbr_is_on); uhci_show_root_hub_state()
304 static int uhci_show_status(struct uhci_hcd *uhci, char *buf, int len) uhci_show_status() argument
313 usbcmd = uhci_readw(uhci, USBCMD); uhci_show_status()
314 usbstat = uhci_readw(uhci, USBSTS); uhci_show_status()
315 usbint = uhci_readw(uhci, USBINTR); uhci_show_status()
316 usbfrnum = uhci_readw(uhci, USBFRNUM); uhci_show_status()
317 flbaseadd = uhci_readl(uhci, USBFLBASEADD); uhci_show_status()
318 sof = uhci_readb(uhci, USBSOF); uhci_show_status()
319 portsc1 = uhci_readw(uhci, USBPORTSC1); uhci_show_status()
320 portsc2 = uhci_readw(uhci, USBPORTSC2); uhci_show_status()
364 uhci->frame_number, uhci->frame_number & 1023, uhci_show_status()
365 uhci->last_iso_frame, uhci->last_iso_frame & 1023); uhci_show_status()
373 static int uhci_sprint_schedule(struct uhci_hcd *uhci, char *buf, int len) uhci_sprint_schedule() argument
389 out += uhci_show_root_hub_state(uhci, out); uhci_sprint_schedule()
393 out += uhci_show_status(uhci, out, len - (out - buf)); uhci_sprint_schedule()
399 out += sprintf(out, "\t%d", uhci->load[i]); uhci_sprint_schedule()
404 uhci->total_load, uhci_sprint_schedule()
405 uhci_to_hcd(uhci)->self.bandwidth_int_reqs, uhci_sprint_schedule()
406 uhci_to_hcd(uhci)->self.bandwidth_isoc_reqs); uhci_sprint_schedule()
419 td = uhci->frame_cpu[i]; uhci_sprint_schedule()
420 link = uhci->frame[i]; uhci_sprint_schedule()
426 i, hc32_to_cpu(uhci, link)); uhci_sprint_schedule()
435 if (link != LINK_TO_TD(uhci, td)) { uhci_sprint_schedule()
445 out += uhci_show_td(uhci, td, out, uhci_sprint_schedule()
454 qh_dma = uhci_frame_skel_link(uhci, i); uhci_sprint_schedule()
460 i, hc32_to_cpu(uhci, link)); uhci_sprint_schedule()
465 hc32_to_cpu(uhci, qh_dma)); uhci_sprint_schedule()
485 qh = uhci->skelqh[i]; uhci_sprint_schedule()
487 out += uhci_show_qh(uhci, qh, out, len - (out - buf), 4); uhci_sprint_schedule()
493 if (qh_element(qh) != LINK_TO_TD(uhci, uhci->term_td)) { uhci_sprint_schedule()
501 link = LINK_TO_QH(uhci, uhci->skel_term_qh); uhci_sprint_schedule()
512 out += uhci_show_qh(uhci, qh, out, uhci_sprint_schedule()
518 fsbr_link = LINK_TO_QH(uhci, qh); uhci_sprint_schedule()
523 link = UHCI_PTR_TERM(uhci); uhci_sprint_schedule()
527 link = LINK_TO_QH(uhci, uhci->skel_async_qh); uhci_sprint_schedule()
528 else if (!uhci->fsbr_is_on) uhci_sprint_schedule()
531 link = LINK_TO_QH(uhci, uhci->skel_term_qh); uhci_sprint_schedule()
559 struct uhci_hcd *uhci = inode->i_private; uhci_debug_open() local
574 spin_lock_irqsave(&uhci->lock, flags); uhci_debug_open()
575 if (uhci->is_initialized) uhci_debug_open()
576 up->size = uhci_sprint_schedule(uhci, up->data, uhci_debug_open()
578 spin_unlock_irqrestore(&uhci->lock, flags); uhci_debug_open()
643 static inline int uhci_show_qh(struct uhci_hcd *uhci, uhci_show_qh() argument
649 static inline int uhci_sprint_schedule(struct uhci_hcd *uhci, uhci_sprint_schedule() argument
H A Duhci-q.c28 static void uhci_set_next_interrupt(struct uhci_hcd *uhci) uhci_set_next_interrupt() argument
30 if (uhci->is_stopped) uhci_set_next_interrupt()
31 mod_timer(&uhci_to_hcd(uhci)->rh_timer, jiffies); uhci_set_next_interrupt()
32 uhci->term_td->status |= cpu_to_hc32(uhci, TD_CTRL_IOC); uhci_set_next_interrupt()
35 static inline void uhci_clear_next_interrupt(struct uhci_hcd *uhci) uhci_clear_next_interrupt() argument
37 uhci->term_td->status &= ~cpu_to_hc32(uhci, TD_CTRL_IOC); uhci_clear_next_interrupt()
46 static void uhci_fsbr_on(struct uhci_hcd *uhci) uhci_fsbr_on() argument
53 uhci->fsbr_is_on = 1; uhci_fsbr_on()
54 lqh = list_entry(uhci->skel_async_qh->node.prev, uhci_fsbr_on()
56 lqh->link = LINK_TO_QH(uhci, uhci->skel_term_qh); uhci_fsbr_on()
59 static void uhci_fsbr_off(struct uhci_hcd *uhci) uhci_fsbr_off() argument
65 uhci->fsbr_is_on = 0; uhci_fsbr_off()
66 lqh = list_entry(uhci->skel_async_qh->node.prev, uhci_fsbr_off()
68 lqh->link = UHCI_PTR_TERM(uhci); uhci_fsbr_off()
71 static void uhci_add_fsbr(struct uhci_hcd *uhci, struct urb *urb) uhci_add_fsbr() argument
79 static void uhci_urbp_wants_fsbr(struct uhci_hcd *uhci, struct urb_priv *urbp) uhci_urbp_wants_fsbr() argument
82 uhci->fsbr_is_wanted = 1; uhci_urbp_wants_fsbr()
83 if (!uhci->fsbr_is_on) uhci_urbp_wants_fsbr()
84 uhci_fsbr_on(uhci); uhci_urbp_wants_fsbr()
85 else if (uhci->fsbr_expiring) { uhci_urbp_wants_fsbr()
86 uhci->fsbr_expiring = 0; uhci_urbp_wants_fsbr()
87 del_timer(&uhci->fsbr_timer); uhci_urbp_wants_fsbr()
94 struct uhci_hcd *uhci = (struct uhci_hcd *) _uhci; uhci_fsbr_timeout() local
97 spin_lock_irqsave(&uhci->lock, flags); uhci_fsbr_timeout()
98 if (uhci->fsbr_expiring) { uhci_fsbr_timeout()
99 uhci->fsbr_expiring = 0; uhci_fsbr_timeout()
100 uhci_fsbr_off(uhci); uhci_fsbr_timeout()
102 spin_unlock_irqrestore(&uhci->lock, flags); uhci_fsbr_timeout()
106 static struct uhci_td *uhci_alloc_td(struct uhci_hcd *uhci) uhci_alloc_td() argument
111 td = dma_pool_alloc(uhci->td_pool, GFP_ATOMIC, &dma_handle); uhci_alloc_td()
124 static void uhci_free_td(struct uhci_hcd *uhci, struct uhci_td *td) uhci_free_td() argument
127 dev_WARN(uhci_dev(uhci), "td %p still in list!\n", td); uhci_free_td()
129 dev_WARN(uhci_dev(uhci), "td %p still in fl_list!\n", td); uhci_free_td()
131 dma_pool_free(uhci->td_pool, td, td->dma_handle); uhci_free_td()
134 static inline void uhci_fill_td(struct uhci_hcd *uhci, struct uhci_td *td, uhci_fill_td() argument
137 td->status = cpu_to_hc32(uhci, status); uhci_fill_td()
138 td->token = cpu_to_hc32(uhci, token); uhci_fill_td()
139 td->buffer = cpu_to_hc32(uhci, buffer); uhci_fill_td()
155 static inline void uhci_insert_td_in_frame_list(struct uhci_hcd *uhci, uhci_insert_td_in_frame_list() argument
163 if (uhci->frame_cpu[framenum]) { uhci_insert_td_in_frame_list()
166 ftd = uhci->frame_cpu[framenum]; uhci_insert_td_in_frame_list()
173 ltd->link = LINK_TO_TD(uhci, td); uhci_insert_td_in_frame_list()
175 td->link = uhci->frame[framenum]; uhci_insert_td_in_frame_list()
177 uhci->frame[framenum] = LINK_TO_TD(uhci, td); uhci_insert_td_in_frame_list()
178 uhci->frame_cpu[framenum] = td; uhci_insert_td_in_frame_list()
182 static inline void uhci_remove_td_from_frame_list(struct uhci_hcd *uhci, uhci_remove_td_from_frame_list() argument
191 if (uhci->frame_cpu[td->frame] == td) { uhci_remove_td_from_frame_list()
193 uhci->frame[td->frame] = td->link; uhci_remove_td_from_frame_list()
194 uhci->frame_cpu[td->frame] = NULL; uhci_remove_td_from_frame_list()
201 uhci->frame[td->frame] = LINK_TO_TD(uhci, ntd); uhci_remove_td_from_frame_list()
202 uhci->frame_cpu[td->frame] = ntd; uhci_remove_td_from_frame_list()
215 static inline void uhci_remove_tds_from_frame(struct uhci_hcd *uhci, uhci_remove_tds_from_frame() argument
222 ftd = uhci->frame_cpu[framenum]; uhci_remove_tds_from_frame()
225 uhci->frame[framenum] = ltd->link; uhci_remove_tds_from_frame()
226 uhci->frame_cpu[framenum] = NULL; uhci_remove_tds_from_frame()
236 static void uhci_unlink_isochronous_tds(struct uhci_hcd *uhci, struct urb *urb) uhci_unlink_isochronous_tds() argument
242 uhci_remove_td_from_frame_list(uhci, td); uhci_unlink_isochronous_tds()
245 static struct uhci_qh *uhci_alloc_qh(struct uhci_hcd *uhci, uhci_alloc_qh() argument
251 qh = dma_pool_alloc(uhci->qh_pool, GFP_ATOMIC, &dma_handle); uhci_alloc_qh()
258 qh->element = UHCI_PTR_TERM(uhci); uhci_alloc_qh()
259 qh->link = UHCI_PTR_TERM(uhci); uhci_alloc_qh()
267 qh->dummy_td = uhci_alloc_td(uhci); uhci_alloc_qh()
269 dma_pool_free(uhci->qh_pool, qh, dma_handle); uhci_alloc_qh()
293 static void uhci_free_qh(struct uhci_hcd *uhci, struct uhci_qh *qh) uhci_free_qh() argument
297 dev_WARN(uhci_dev(uhci), "qh %p list not empty!\n", qh); uhci_free_qh()
303 uhci_free_td(uhci, qh->dummy_td); uhci_free_qh()
305 dma_pool_free(uhci->qh_pool, qh, qh->dma_handle); uhci_free_qh()
315 static int uhci_cleanup_queue(struct uhci_hcd *uhci, struct uhci_qh *qh, uhci_cleanup_queue() argument
327 ret = (uhci->frame_number + uhci->is_stopped != uhci_cleanup_queue()
351 if (qh_element(qh) == UHCI_PTR_TERM(uhci)) uhci_cleanup_queue()
353 qh->element = UHCI_PTR_TERM(uhci); uhci_cleanup_queue()
363 qh->initial_toggle = uhci_toggle(td_token(uhci, td)); uhci_cleanup_queue()
373 static void uhci_fixup_toggles(struct uhci_hcd *uhci, struct uhci_qh *qh, uhci_fixup_toggles() argument
388 else if (qh_element(qh) != UHCI_PTR_TERM(uhci)) uhci_fixup_toggles()
400 if (toggle > 1 || uhci_toggle(td_token(uhci, td)) == toggle) { uhci_fixup_toggles()
403 toggle = uhci_toggle(td_token(uhci, td)) ^ 1; uhci_fixup_toggles()
408 td->token ^= cpu_to_hc32(uhci, uhci_fixup_toggles()
425 static inline void link_iso(struct uhci_hcd *uhci, struct uhci_qh *qh) link_iso() argument
427 list_add_tail(&qh->node, &uhci->skel_iso_qh->node); link_iso()
436 static void link_interrupt(struct uhci_hcd *uhci, struct uhci_qh *qh) link_interrupt() argument
440 list_add_tail(&qh->node, &uhci->skelqh[qh->skel]->node); link_interrupt()
445 pqh->link = LINK_TO_QH(uhci, qh); link_interrupt()
452 static void link_async(struct uhci_hcd *uhci, struct uhci_qh *qh) link_async() argument
460 list_for_each_entry_reverse(pqh, &uhci->skel_async_qh->node, node) { link_async()
469 link_to_new_qh = LINK_TO_QH(uhci, qh); link_async()
475 uhci->skel_term_qh->link = link_to_new_qh; link_async()
481 static void uhci_activate_qh(struct uhci_hcd *uhci, struct uhci_qh *qh) uhci_activate_qh() argument
487 if (qh_element(qh) == UHCI_PTR_TERM(uhci)) { uhci_activate_qh()
493 qh->element = LINK_TO_TD(uhci, td); uhci_activate_qh()
506 if (qh == uhci->next_qh) uhci_activate_qh()
507 uhci->next_qh = list_entry(qh->node.next, struct uhci_qh, uhci_activate_qh()
512 link_iso(uhci, qh); uhci_activate_qh()
514 link_interrupt(uhci, qh); uhci_activate_qh()
516 link_async(uhci, qh); uhci_activate_qh()
522 static void unlink_interrupt(struct uhci_hcd *uhci, struct uhci_qh *qh) unlink_interrupt() argument
534 static void unlink_async(struct uhci_hcd *uhci, struct uhci_qh *qh) unlink_async() argument
545 uhci->skel_term_qh->link = link_to_next_qh; unlink_async()
552 static void uhci_unlink_qh(struct uhci_hcd *uhci, struct uhci_qh *qh) uhci_unlink_qh() argument
563 unlink_interrupt(uhci, qh); uhci_unlink_qh()
565 unlink_async(uhci, qh); uhci_unlink_qh()
567 uhci_get_current_frame_number(uhci); uhci_unlink_qh()
568 qh->unlink_frame = uhci->frame_number; uhci_unlink_qh()
571 if (list_empty(&uhci->skel_unlink_qh->node) || uhci->is_stopped) uhci_unlink_qh()
572 uhci_set_next_interrupt(uhci); uhci_unlink_qh()
575 if (qh == uhci->next_qh) uhci_unlink_qh()
576 uhci->next_qh = list_entry(qh->node.next, struct uhci_qh, uhci_unlink_qh()
578 list_move_tail(&qh->node, &uhci->skel_unlink_qh->node); uhci_unlink_qh()
587 static void uhci_make_qh_idle(struct uhci_hcd *uhci, struct uhci_qh *qh) uhci_make_qh_idle() argument
591 if (qh == uhci->next_qh) uhci_make_qh_idle()
592 uhci->next_qh = list_entry(qh->node.next, struct uhci_qh, uhci_make_qh_idle()
594 list_move(&qh->node, &uhci->idle_qh_list); uhci_make_qh_idle()
599 uhci_free_td(uhci, qh->post_td); uhci_make_qh_idle()
604 if (uhci->num_waiting) uhci_make_qh_idle()
605 wake_up_all(&uhci->waitqh); uhci_make_qh_idle()
611 static int uhci_highest_load(struct uhci_hcd *uhci, int phase, int period) uhci_highest_load() argument
613 int highest_load = uhci->load[phase]; uhci_highest_load()
616 highest_load = max_t(int, highest_load, uhci->load[phase]); uhci_highest_load()
624 static int uhci_check_bandwidth(struct uhci_hcd *uhci, struct uhci_qh *qh) uhci_check_bandwidth() argument
631 minimax_load = uhci_highest_load(uhci, qh->phase, qh->period); uhci_check_bandwidth()
637 minimax_load = uhci_highest_load(uhci, qh->phase, qh->period); uhci_check_bandwidth()
639 load = uhci_highest_load(uhci, phase, qh->period); uhci_check_bandwidth()
649 dev_dbg(uhci_dev(uhci), "bandwidth allocation failed: " uhci_check_bandwidth()
660 static void uhci_reserve_bandwidth(struct uhci_hcd *uhci, struct uhci_qh *qh) uhci_reserve_bandwidth() argument
667 uhci->load[i] += load; uhci_reserve_bandwidth()
668 uhci->total_load += load; uhci_reserve_bandwidth()
670 uhci_to_hcd(uhci)->self.bandwidth_allocated = uhci_reserve_bandwidth()
671 uhci->total_load / MAX_PHASE; uhci_reserve_bandwidth()
674 ++uhci_to_hcd(uhci)->self.bandwidth_int_reqs; uhci_reserve_bandwidth()
678 ++uhci_to_hcd(uhci)->self.bandwidth_isoc_reqs; uhci_reserve_bandwidth()
683 dev_dbg(uhci_dev(uhci), uhci_reserve_bandwidth()
693 static void uhci_release_bandwidth(struct uhci_hcd *uhci, struct uhci_qh *qh) uhci_release_bandwidth() argument
700 uhci->load[i] -= load; uhci_release_bandwidth()
701 uhci->total_load -= load; uhci_release_bandwidth()
703 uhci_to_hcd(uhci)->self.bandwidth_allocated = uhci_release_bandwidth()
704 uhci->total_load / MAX_PHASE; uhci_release_bandwidth()
707 --uhci_to_hcd(uhci)->self.bandwidth_int_reqs; uhci_release_bandwidth()
711 --uhci_to_hcd(uhci)->self.bandwidth_isoc_reqs; uhci_release_bandwidth()
716 dev_dbg(uhci_dev(uhci), uhci_release_bandwidth()
723 static inline struct urb_priv *uhci_alloc_urb_priv(struct uhci_hcd *uhci, uhci_alloc_urb_priv() argument
741 static void uhci_free_urb_priv(struct uhci_hcd *uhci, uhci_free_urb_priv() argument
747 dev_WARN(uhci_dev(uhci), "urb %p still on QH's list!\n", uhci_free_urb_priv()
752 uhci_free_td(uhci, td); uhci_free_urb_priv()
761 * <status> is (td_status(uhci, td) & 0xF60000), a.k.a.
762 * uhci_status_bits(td_status(uhci, td)).
790 static int uhci_submit_control(struct uhci_hcd *uhci, struct urb *urb, uhci_submit_control() argument
815 uhci_fill_td(uhci, td, status, destination | uhci_explen(8), uhci_submit_control()
845 td = uhci_alloc_td(uhci); uhci_submit_control()
848 *plink = LINK_TO_TD(uhci, td); uhci_submit_control()
854 uhci_fill_td(uhci, td, status, uhci_submit_control()
865 td = uhci_alloc_td(uhci); uhci_submit_control()
868 *plink = LINK_TO_TD(uhci, td); uhci_submit_control()
875 uhci_fill_td(uhci, td, status | TD_CTRL_IOC, uhci_submit_control()
882 td = uhci_alloc_td(uhci); uhci_submit_control()
885 *plink = LINK_TO_TD(uhci, td); uhci_submit_control()
887 uhci_fill_td(uhci, td, 0, USB_PID_OUT | uhci_explen(0), 0); uhci_submit_control()
889 qh->dummy_td->status |= cpu_to_hc32(uhci, TD_CTRL_ACTIVE); uhci_submit_control()
901 uhci_add_fsbr(uhci, urb); uhci_submit_control()
916 static int uhci_submit_common(struct uhci_hcd *uhci, struct urb *urb, uhci_submit_common() argument
975 td = uhci_alloc_td(uhci); uhci_submit_common()
978 *plink = LINK_TO_TD(uhci, td); uhci_submit_common()
981 uhci_fill_td(uhci, td, status, uhci_submit_common()
1011 td = uhci_alloc_td(uhci); uhci_submit_common()
1014 *plink = LINK_TO_TD(uhci, td); uhci_submit_common()
1017 uhci_fill_td(uhci, td, status, uhci_submit_common()
1032 td->status |= cpu_to_hc32(uhci, TD_CTRL_IOC); uhci_submit_common()
1037 td = uhci_alloc_td(uhci); uhci_submit_common()
1040 *plink = LINK_TO_TD(uhci, td); uhci_submit_common()
1042 uhci_fill_td(uhci, td, 0, USB_PID_OUT | uhci_explen(0), 0); uhci_submit_common()
1044 qh->dummy_td->status |= cpu_to_hc32(uhci, TD_CTRL_ACTIVE); uhci_submit_common()
1057 static int uhci_submit_bulk(struct uhci_hcd *uhci, struct urb *urb, uhci_submit_bulk() argument
1068 ret = uhci_submit_common(uhci, urb, qh); uhci_submit_bulk()
1070 uhci_add_fsbr(uhci, urb); uhci_submit_bulk()
1074 static int uhci_submit_interrupt(struct uhci_hcd *uhci, struct urb *urb, uhci_submit_interrupt() argument
1104 ret = uhci_check_bandwidth(uhci, qh); uhci_submit_interrupt()
1111 ret = uhci_submit_common(uhci, urb, qh); uhci_submit_interrupt()
1115 uhci_reserve_bandwidth(uhci, qh); uhci_submit_interrupt()
1123 static int uhci_fixup_short_transfer(struct uhci_hcd *uhci, uhci_fixup_short_transfer() argument
1137 qh->element = LINK_TO_TD(uhci, td); uhci_fixup_short_transfer()
1147 uhci_toggle(td_token(uhci, qh->post_td)) ^ 1; uhci_fixup_short_transfer()
1148 uhci_fixup_toggles(uhci, qh, 1); uhci_fixup_short_transfer()
1163 uhci_free_td(uhci, td); uhci_fixup_short_transfer()
1171 static int uhci_result_common(struct uhci_hcd *uhci, struct urb *urb) uhci_result_common() argument
1183 ctrlstat = td_status(uhci, td); uhci_result_common()
1193 uhci_packetout(td_token(uhci, td))); uhci_result_common()
1202 uhci_show_qh(uhci, urbp->qh, errbuf, uhci_result_common()
1209 } else if (len < uhci_expected_length(td_token(uhci, td))) { uhci_result_common()
1229 uhci_free_td(uhci, qh->post_td); uhci_result_common()
1241 qh->element = UHCI_PTR_TERM(uhci); uhci_result_common()
1244 qh->initial_toggle = uhci_toggle(td_token(uhci, td)) ^ uhci_result_common()
1248 ret = uhci_fixup_short_transfer(uhci, qh, urbp); uhci_result_common()
1255 static int uhci_submit_isochronous(struct uhci_hcd *uhci, struct urb *urb, uhci_submit_isochronous() argument
1269 uhci_get_current_frame_number(uhci); uhci_submit_isochronous()
1275 i = uhci_check_bandwidth(uhci, qh); uhci_submit_isochronous()
1280 next = uhci->frame_number + 10; uhci_submit_isochronous()
1290 next = uhci->frame_number + 1; uhci_submit_isochronous()
1320 dev_dbg(uhci_dev(uhci), "iso underrun %p (%u+%u < %u)\n", uhci_submit_isochronous()
1329 if (uhci_frame_before_eq(uhci->last_iso_frame + UHCI_NUMFRAMES, uhci_submit_isochronous()
1338 td = uhci_alloc_td(uhci); uhci_submit_isochronous()
1343 uhci_fill_td(uhci, td, status, destination | uhci_submit_isochronous()
1350 td->status |= cpu_to_hc32(uhci, TD_CTRL_IOC); uhci_submit_isochronous()
1355 uhci_insert_td_in_frame_list(uhci, td, frame); uhci_submit_isochronous()
1366 uhci_reserve_bandwidth(uhci, qh); uhci_submit_isochronous()
1370 static int uhci_result_isochronous(struct uhci_hcd *uhci, struct urb *urb) uhci_result_isochronous() argument
1381 if (uhci_frame_before_eq(uhci->cur_iso_frame, qh->iso_frame)) uhci_result_isochronous()
1384 uhci_remove_tds_from_frame(uhci, qh->iso_frame); uhci_result_isochronous()
1386 ctrlstat = td_status(uhci, td); uhci_result_isochronous()
1402 uhci_free_td(uhci, td); uhci_result_isochronous()
1413 struct uhci_hcd *uhci = hcd_to_uhci(hcd); uhci_urb_enqueue() local
1418 spin_lock_irqsave(&uhci->lock, flags); uhci_urb_enqueue()
1425 urbp = uhci_alloc_urb_priv(uhci, urb); uhci_urb_enqueue()
1432 qh = uhci_alloc_qh(uhci, urb->dev, urb->ep); uhci_urb_enqueue()
1440 ret = uhci_submit_control(uhci, urb, qh); uhci_urb_enqueue()
1443 ret = uhci_submit_bulk(uhci, urb, qh); uhci_urb_enqueue()
1446 ret = uhci_submit_interrupt(uhci, urb, qh); uhci_urb_enqueue()
1450 ret = uhci_submit_isochronous(uhci, urb, qh); uhci_urb_enqueue()
1464 uhci_activate_qh(uhci, qh); uhci_urb_enqueue()
1465 uhci_urbp_wants_fsbr(uhci, urbp); uhci_urb_enqueue()
1471 uhci_make_qh_idle(uhci, qh); /* Reclaim unused QH */ uhci_urb_enqueue()
1473 uhci_free_urb_priv(uhci, urbp); uhci_urb_enqueue()
1478 spin_unlock_irqrestore(&uhci->lock, flags); uhci_urb_enqueue()
1484 struct uhci_hcd *uhci = hcd_to_uhci(hcd); uhci_urb_dequeue() local
1489 spin_lock_irqsave(&uhci->lock, flags); uhci_urb_dequeue()
1498 uhci_unlink_isochronous_tds(uhci, urb); uhci_urb_dequeue()
1502 uhci_get_current_frame_number(uhci); uhci_urb_dequeue()
1503 if (uhci_frame_before_eq(urb->start_frame, uhci->frame_number)) uhci_urb_dequeue()
1504 qh->unlink_frame = uhci->frame_number; uhci_urb_dequeue()
1507 uhci_unlink_qh(uhci, qh); uhci_urb_dequeue()
1510 spin_unlock_irqrestore(&uhci->lock, flags); uhci_urb_dequeue()
1517 static void uhci_giveback_urb(struct uhci_hcd *uhci, struct uhci_qh *qh,
1519 __releases(uhci->lock)
1520 __acquires(uhci->lock)
1553 uhci_free_urb_priv(uhci, urbp);
1554 usb_hcd_unlink_urb_from_ep(uhci_to_hcd(uhci), urb);
1556 spin_unlock(&uhci->lock);
1557 usb_hcd_giveback_urb(uhci_to_hcd(uhci), urb, status);
1558 spin_lock(&uhci->lock);
1563 uhci_unlink_qh(uhci, qh);
1565 uhci_release_bandwidth(uhci, qh);
1574 uhci->frame_number + uhci->is_stopped != qh->unlink_frame)
1576 static void uhci_scan_qh(struct uhci_hcd *uhci, struct uhci_qh *qh) uhci_scan_qh() argument
1587 status = uhci_result_isochronous(uhci, urb); uhci_scan_qh()
1589 status = uhci_result_common(uhci, urb); uhci_scan_qh()
1602 uhci_giveback_urb(uhci, qh, urb, status); uhci_scan_qh()
1623 if (!uhci_cleanup_queue(uhci, qh, urb)) { uhci_scan_qh()
1627 uhci_giveback_urb(uhci, qh, urb, 0); uhci_scan_qh()
1637 uhci_fixup_toggles(uhci, qh, 0); uhci_scan_qh()
1647 td->status |= cpu_to_hc32(uhci, TD_CTRL_IOC); uhci_scan_qh()
1650 uhci_activate_qh(uhci, qh); uhci_scan_qh()
1656 uhci_make_qh_idle(uhci, qh); uhci_scan_qh()
1669 static int uhci_advance_check(struct uhci_hcd *uhci, struct uhci_qh *qh) uhci_advance_check() argument
1694 status = td_status(uhci, td); uhci_advance_check()
1702 ret = uhci->is_stopped; uhci_advance_check()
1713 LINK_TO_TD(uhci, qh->post_td)) { uhci_advance_check()
1727 uhci_unlink_qh(uhci, qh); uhci_advance_check()
1732 uhci_urbp_wants_fsbr(uhci, urbp); uhci_advance_check()
1742 static void uhci_scan_schedule(struct uhci_hcd *uhci) uhci_scan_schedule() argument
1748 if (uhci->scan_in_progress) { uhci_scan_schedule()
1749 uhci->need_rescan = 1; uhci_scan_schedule()
1752 uhci->scan_in_progress = 1; uhci_scan_schedule()
1754 uhci->need_rescan = 0; uhci_scan_schedule()
1755 uhci->fsbr_is_wanted = 0; uhci_scan_schedule()
1757 uhci_clear_next_interrupt(uhci); uhci_scan_schedule()
1758 uhci_get_current_frame_number(uhci); uhci_scan_schedule()
1759 uhci->cur_iso_frame = uhci->frame_number; uhci_scan_schedule()
1763 uhci->next_qh = list_entry(uhci->skelqh[i]->node.next, uhci_scan_schedule()
1765 while ((qh = uhci->next_qh) != uhci->skelqh[i]) { uhci_scan_schedule()
1766 uhci->next_qh = list_entry(qh->node.next, uhci_scan_schedule()
1769 if (uhci_advance_check(uhci, qh)) { uhci_scan_schedule()
1770 uhci_scan_qh(uhci, qh); uhci_scan_schedule()
1772 uhci_urbp_wants_fsbr(uhci, uhci_scan_schedule()
1779 uhci->last_iso_frame = uhci->cur_iso_frame; uhci_scan_schedule()
1780 if (uhci->need_rescan) uhci_scan_schedule()
1782 uhci->scan_in_progress = 0; uhci_scan_schedule()
1784 if (uhci->fsbr_is_on && !uhci->fsbr_is_wanted && uhci_scan_schedule()
1785 !uhci->fsbr_expiring) { uhci_scan_schedule()
1786 uhci->fsbr_expiring = 1; uhci_scan_schedule()
1787 mod_timer(&uhci->fsbr_timer, jiffies + FSBR_OFF_DELAY); uhci_scan_schedule()
1790 if (list_empty(&uhci->skel_unlink_qh->node)) uhci_scan_schedule()
1791 uhci_clear_next_interrupt(uhci); uhci_scan_schedule()
1793 uhci_set_next_interrupt(uhci); uhci_scan_schedule()
H A Duhci-platform.c6 * This file is based on uhci-grlib.c
16 struct uhci_hcd *uhci = hcd_to_uhci(hcd); uhci_platform_init() local
18 uhci->rh_numports = uhci_count_ports(hcd); uhci_platform_init()
21 uhci->reset_hc = uhci_generic_reset_hc; uhci_platform_init()
22 uhci->check_and_reset_hc = uhci_generic_check_and_reset_hc; uhci_platform_init()
25 uhci->configure_hc = NULL; uhci_platform_init()
26 uhci->resume_detect_interrupts_are_broken = NULL; uhci_platform_init()
27 uhci->global_suspend_mode_is_broken = NULL; uhci_platform_init()
30 check_and_reset_hc(uhci); uhci_platform_init()
67 struct uhci_hcd *uhci; uhci_hcd_platform_probe() local
97 uhci = hcd_to_uhci(hcd); uhci_hcd_platform_probe()
99 uhci->regs = hcd->regs; uhci_hcd_platform_probe()
139 { .compatible = "generic-uhci", },
140 { .compatible = "platform-uhci", },
149 .name = "platform-uhci",
H A Duhci-hcd.h81 #define UHCI_PTR_BITS(uhci) cpu_to_hc32((uhci), 0x000F)
82 #define UHCI_PTR_TERM(uhci) cpu_to_hc32((uhci), 0x0001)
83 #define UHCI_PTR_QH(uhci) cpu_to_hc32((uhci), 0x0002)
84 #define UHCI_PTR_DEPTH(uhci) cpu_to_hc32((uhci), 0x0004)
85 #define UHCI_PTR_BREADTH(uhci) cpu_to_hc32((uhci), 0x0000)
189 #define LINK_TO_QH(uhci, qh) (UHCI_PTR_QH((uhci)) | \
190 cpu_to_hc32((uhci), (qh)->dma_handle))
223 #define td_token(uhci, td) hc32_to_cpu((uhci), (td)->token)
274 #define td_status(uhci, td) hc32_to_cpu((uhci), \
277 #define LINK_TO_TD(uhci, td) (cpu_to_hc32((uhci), (td)->dma_handle))
447 void (*reset_hc) (struct uhci_hcd *uhci);
448 int (*check_and_reset_hc) (struct uhci_hcd *uhci);
450 void (*configure_hc) (struct uhci_hcd *uhci);
452 int (*resume_detect_interrupts_are_broken) (struct uhci_hcd *uhci);
454 int (*global_suspend_mode_is_broken) (struct uhci_hcd *uhci);
462 static inline struct usb_hcd *uhci_to_hcd(struct uhci_hcd *uhci) uhci_to_hcd() argument
464 return container_of((void *) uhci, struct usb_hcd, hcd_priv); uhci_to_hcd()
501 static inline u32 uhci_readl(const struct uhci_hcd *uhci, int reg) uhci_readl() argument
503 return inl(uhci->io_addr + reg); uhci_readl()
506 static inline void uhci_writel(const struct uhci_hcd *uhci, u32 val, int reg) uhci_writel() argument
508 outl(val, uhci->io_addr + reg); uhci_writel()
511 static inline u16 uhci_readw(const struct uhci_hcd *uhci, int reg) uhci_readw() argument
513 return inw(uhci->io_addr + reg); uhci_readw()
516 static inline void uhci_writew(const struct uhci_hcd *uhci, u16 val, int reg) uhci_writew() argument
518 outw(val, uhci->io_addr + reg); uhci_writew()
521 static inline u8 uhci_readb(const struct uhci_hcd *uhci, int reg) uhci_readb() argument
523 return inb(uhci->io_addr + reg); uhci_readb()
526 static inline void uhci_writeb(const struct uhci_hcd *uhci, u8 val, int reg) uhci_writeb() argument
528 outb(val, uhci->io_addr + reg); uhci_writeb()
548 static inline u32 uhci_readl(const struct uhci_hcd *uhci, int reg) uhci_readl() argument
550 if (uhci_has_pci_registers(uhci)) uhci_readl()
551 return inl(uhci->io_addr + reg); uhci_readl()
553 else if (uhci_big_endian_mmio(uhci)) uhci_readl()
554 return readl_be(uhci->regs + reg); uhci_readl()
557 return readl(uhci->regs + reg); uhci_readl()
560 static inline void uhci_writel(const struct uhci_hcd *uhci, u32 val, int reg) uhci_writel() argument
562 if (uhci_has_pci_registers(uhci)) uhci_writel()
563 outl(val, uhci->io_addr + reg); uhci_writel()
565 else if (uhci_big_endian_mmio(uhci)) uhci_writel()
566 writel_be(val, uhci->regs + reg); uhci_writel()
569 writel(val, uhci->regs + reg); uhci_writel()
572 static inline u16 uhci_readw(const struct uhci_hcd *uhci, int reg) uhci_readw() argument
574 if (uhci_has_pci_registers(uhci)) uhci_readw()
575 return inw(uhci->io_addr + reg); uhci_readw()
577 else if (uhci_big_endian_mmio(uhci)) uhci_readw()
578 return readw_be(uhci->regs + reg); uhci_readw()
581 return readw(uhci->regs + reg); uhci_readw()
584 static inline void uhci_writew(const struct uhci_hcd *uhci, u16 val, int reg) uhci_writew() argument
586 if (uhci_has_pci_registers(uhci)) uhci_writew()
587 outw(val, uhci->io_addr + reg); uhci_writew()
589 else if (uhci_big_endian_mmio(uhci)) uhci_writew()
590 writew_be(val, uhci->regs + reg); uhci_writew()
593 writew(val, uhci->regs + reg); uhci_writew()
596 static inline u8 uhci_readb(const struct uhci_hcd *uhci, int reg) uhci_readb() argument
598 if (uhci_has_pci_registers(uhci)) uhci_readb()
599 return inb(uhci->io_addr + reg); uhci_readb()
601 else if (uhci_big_endian_mmio(uhci)) uhci_readb()
602 return readb_be(uhci->regs + reg); uhci_readb()
605 return readb(uhci->regs + reg); uhci_readb()
608 static inline void uhci_writeb(const struct uhci_hcd *uhci, u8 val, int reg) uhci_writeb() argument
610 if (uhci_has_pci_registers(uhci)) uhci_writeb()
611 outb(val, uhci->io_addr + reg); uhci_writeb()
613 else if (uhci_big_endian_mmio(uhci)) uhci_writeb()
614 writeb_be(val, uhci->regs + reg); uhci_writeb()
617 writeb(val, uhci->regs + reg); uhci_writeb()
630 /* cpu to uhci */ cpu_to_hc32()
631 static inline __hc32 cpu_to_hc32(const struct uhci_hcd *uhci, const u32 x) cpu_to_hc32() argument
633 return uhci_big_endian_desc(uhci) cpu_to_hc32()
638 /* uhci to cpu */ hc32_to_cpu()
639 static inline u32 hc32_to_cpu(const struct uhci_hcd *uhci, const __hc32 x) hc32_to_cpu() argument
641 return uhci_big_endian_desc(uhci) hc32_to_cpu()
647 /* cpu to uhci */ cpu_to_hc32()
648 static inline __hc32 cpu_to_hc32(const struct uhci_hcd *uhci, const u32 x) cpu_to_hc32() argument
653 /* uhci to cpu */ hc32_to_cpu()
654 static inline u32 hc32_to_cpu(const struct uhci_hcd *uhci, const __hc32 x) hc32_to_cpu() argument
H A Duhci-grlib.c27 struct uhci_hcd *uhci = hcd_to_uhci(hcd); uhci_grlib_init() local
38 if (!(uhci_readw(uhci, USBPORTSC1) & 0x80)) { uhci_grlib_init()
39 uhci->big_endian_mmio = 1; uhci_grlib_init()
40 uhci->big_endian_desc = 1; uhci_grlib_init()
43 uhci->rh_numports = uhci_count_ports(hcd); uhci_grlib_init()
46 uhci->reset_hc = uhci_generic_reset_hc; uhci_grlib_init()
47 uhci->check_and_reset_hc = uhci_generic_check_and_reset_hc; uhci_grlib_init()
49 uhci->configure_hc = NULL; uhci_grlib_init()
50 uhci->resume_detect_interrupts_are_broken = NULL; uhci_grlib_init()
51 uhci->global_suspend_mode_is_broken = NULL; uhci_grlib_init()
54 check_and_reset_hc(uhci); uhci_grlib_init()
93 struct uhci_hcd *uhci = NULL; uhci_hcd_grlib_probe() local
130 uhci = hcd_to_uhci(hcd); uhci_hcd_grlib_probe()
132 uhci->regs = hcd->regs; uhci_hcd_grlib_probe()
190 .name = "grlib-uhci",
H A DMakefile60 obj-$(CONFIG_USB_UHCI_HCD) += uhci-hcd.o
H A Dohci-pci.c8 * [ uhci code and gregs ohci fragments ]
H A Dohci-hcd.c10 * [ uhci code and gregs ohci fragments ]
/linux-4.1.27/drivers/net/irda/
H A Dirda-usb.c40 * o usb-uhci-hcd (For Intel/Via USB controllers)
41 * o uhci-hcd (Alternate/JE driver for Intel/Via USB controllers)
/linux-4.1.27/drivers/usb/misc/
H A Dlegousbtower.c29 * uhci and legusbtower
/linux-4.1.27/include/linux/usb/
H A Dhcd.h198 * (ohci 32, uhci 1024, ehci 256/512/1024).
/linux-4.1.27/sound/usb/usx2y/
H A Dusbusx2yaudio.c46 1 to 4 have been tested ok on uhci.
/linux-4.1.27/include/linux/
H A Dusb.h1777 * - device address: bits 8-14 ... bit positions known to uhci-hcd
1778 * - endpoint: bits 15-18 ... bit positions known to uhci-hcd

Completed in 466 milliseconds