/linux-4.1.27/drivers/usb/host/ |
H A D | uhci-hcd.c | 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) 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 D | uhci-hub.c | 43 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 D | uhci-pci.c | 4 * 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 D | uhci-debug.c | 17 #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 D | uhci-q.c | 28 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 D | uhci-platform.c | 6 * 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 D | uhci-hcd.h | 81 #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 D | uhci-grlib.c | 27 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 D | Makefile | 60 obj-$(CONFIG_USB_UHCI_HCD) += uhci-hcd.o
|
H A D | ohci-pci.c | 8 * [ uhci code and gregs ohci fragments ]
|
H A D | ohci-hcd.c | 10 * [ uhci code and gregs ohci fragments ]
|
/linux-4.1.27/drivers/net/irda/ |
H A D | irda-usb.c | 40 * 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 D | legousbtower.c | 29 * uhci and legusbtower
|
/linux-4.1.27/include/linux/usb/ |
H A D | hcd.h | 198 * (ohci 32, uhci 1024, ehci 256/512/1024).
|
/linux-4.1.27/sound/usb/usx2y/ |
H A D | usbusx2yaudio.c | 46 1 to 4 have been tested ok on uhci.
|
/linux-4.1.27/include/linux/ |
H A D | usb.h | 1777 * - device address: bits 8-14 ... bit positions known to uhci-hcd 1778 * - endpoint: bits 15-18 ... bit positions known to uhci-hcd
|