Lines Matching full:xhci
3 * xHCI host controller driver
24 #include "xhci.h"
25 #include "xhci-trace.h"
26 #include "xhci-debugfs.h"
27 #include "xhci-dbgcap.h"
91 int xhci_handshake_check_state(struct xhci_hcd *xhci, void __iomem *ptr, in xhci_handshake_check_state() argument
100 xhci->xhc_state & exit_state, in xhci_handshake_check_state()
103 if (result == U32_MAX || xhci->xhc_state & exit_state) in xhci_handshake_check_state()
110 * Disable interrupts and begin the xHCI halting process.
112 void xhci_quiesce(struct xhci_hcd *xhci) in xhci_quiesce() argument
119 halted = readl(&xhci->op_regs->status) & STS_HALT; in xhci_quiesce()
123 cmd = readl(&xhci->op_regs->command); in xhci_quiesce()
125 writel(cmd, &xhci->op_regs->command); in xhci_quiesce()
136 int xhci_halt(struct xhci_hcd *xhci) in xhci_halt() argument
140 xhci_dbg_trace(xhci, trace_xhci_dbg_init, "// Halt the HC"); in xhci_halt()
141 xhci_quiesce(xhci); in xhci_halt()
143 ret = xhci_handshake(&xhci->op_regs->status, in xhci_halt()
146 xhci_warn(xhci, "Host halt failed, %d\n", ret); in xhci_halt()
150 xhci->xhc_state |= XHCI_STATE_HALTED; in xhci_halt()
151 xhci->cmd_ring_state = CMD_RING_STATE_STOPPED; in xhci_halt()
159 int xhci_start(struct xhci_hcd *xhci) in xhci_start() argument
164 temp = readl(&xhci->op_regs->command); in xhci_start()
166 xhci_dbg_trace(xhci, trace_xhci_dbg_init, "// Turn on HC, cmd = 0x%x.", in xhci_start()
168 writel(temp, &xhci->op_regs->command); in xhci_start()
174 ret = xhci_handshake(&xhci->op_regs->status, in xhci_start()
177 xhci_err(xhci, "Host took too long to start, " in xhci_start()
182 xhci->xhc_state = 0; in xhci_start()
183 xhci->run_graceperiod = jiffies + msecs_to_jiffies(500); in xhci_start()
196 int xhci_reset(struct xhci_hcd *xhci, u64 timeout_us) in xhci_reset() argument
202 state = readl(&xhci->op_regs->status); in xhci_reset()
205 xhci_warn(xhci, "Host not accessible, reset failed.\n"); in xhci_reset()
210 xhci_warn(xhci, "Host controller not halted, aborting reset.\n"); in xhci_reset()
214 xhci_dbg_trace(xhci, trace_xhci_dbg_init, "// Reset the HC"); in xhci_reset()
215 command = readl(&xhci->op_regs->command); in xhci_reset()
217 writel(command, &xhci->op_regs->command); in xhci_reset()
219 /* Existing Intel xHCI controllers require a delay of 1 mS, in xhci_reset()
226 if (xhci->quirks & XHCI_INTEL_HOST) in xhci_reset()
229 ret = xhci_handshake_check_state(xhci, &xhci->op_regs->command, in xhci_reset()
234 if (xhci->quirks & XHCI_ASMEDIA_MODIFY_FLOWCONTROL) in xhci_reset()
235 usb_asmedia_modifyflowcontrol(to_pci_dev(xhci_to_hcd(xhci)->self.controller)); in xhci_reset()
237 xhci_dbg_trace(xhci, trace_xhci_dbg_init, in xhci_reset()
240 * xHCI cannot write to any doorbells or operational registers other in xhci_reset()
243 ret = xhci_handshake(&xhci->op_regs->status, STS_CNR, 0, timeout_us); in xhci_reset()
245 xhci->usb2_rhub.bus_state.port_c_suspend = 0; in xhci_reset()
246 xhci->usb2_rhub.bus_state.suspended_ports = 0; in xhci_reset()
247 xhci->usb2_rhub.bus_state.resuming_ports = 0; in xhci_reset()
248 xhci->usb3_rhub.bus_state.port_c_suspend = 0; in xhci_reset()
249 xhci->usb3_rhub.bus_state.suspended_ports = 0; in xhci_reset()
250 xhci->usb3_rhub.bus_state.resuming_ports = 0; in xhci_reset()
255 static void xhci_zero_64b_regs(struct xhci_hcd *xhci) in xhci_zero_64b_regs() argument
257 struct device *dev = xhci_to_hcd(xhci)->self.sysdev; in xhci_zero_64b_regs()
278 if (!(xhci->quirks & XHCI_ZERO_64B_REGS) || !domain || in xhci_zero_64b_regs()
282 xhci_info(xhci, "Zeroing 64bit base registers, expecting fault\n"); in xhci_zero_64b_regs()
285 val = readl(&xhci->op_regs->command); in xhci_zero_64b_regs()
287 writel(val, &xhci->op_regs->command); in xhci_zero_64b_regs()
290 val = readl(&xhci->op_regs->status); in xhci_zero_64b_regs()
292 writel(val, &xhci->op_regs->status); in xhci_zero_64b_regs()
295 val = xhci_read_64(xhci, &xhci->op_regs->dcbaa_ptr); in xhci_zero_64b_regs()
297 xhci_write_64(xhci, 0, &xhci->op_regs->dcbaa_ptr); in xhci_zero_64b_regs()
298 val = xhci_read_64(xhci, &xhci->op_regs->cmd_ring); in xhci_zero_64b_regs()
300 xhci_write_64(xhci, 0, &xhci->op_regs->cmd_ring); in xhci_zero_64b_regs()
302 intrs = min_t(u32, HCS_MAX_INTRS(xhci->hcs_params1), in xhci_zero_64b_regs()
303 ARRAY_SIZE(xhci->run_regs->ir_set)); in xhci_zero_64b_regs()
308 ir = &xhci->run_regs->ir_set[i]; in xhci_zero_64b_regs()
309 val = xhci_read_64(xhci, &ir->erst_base); in xhci_zero_64b_regs()
311 xhci_write_64(xhci, 0, &ir->erst_base); in xhci_zero_64b_regs()
312 val= xhci_read_64(xhci, &ir->erst_dequeue); in xhci_zero_64b_regs()
314 xhci_write_64(xhci, 0, &ir->erst_dequeue); in xhci_zero_64b_regs()
318 err = xhci_handshake(&xhci->op_regs->status, in xhci_zero_64b_regs()
322 xhci_info(xhci, "Fault detected\n"); in xhci_zero_64b_regs()
370 struct xhci_hcd *xhci; in compliance_mode_recovery() local
376 xhci = from_timer(xhci, t, comp_mode_recovery_timer); in compliance_mode_recovery()
377 rhub = &xhci->usb3_rhub; in compliance_mode_recovery()
390 xhci_dbg_trace(xhci, trace_xhci_dbg_quirks, in compliance_mode_recovery()
393 xhci_dbg_trace(xhci, trace_xhci_dbg_quirks, in compliance_mode_recovery()
403 if (xhci->port_status_u0 != ((1 << rhub->num_ports) - 1)) in compliance_mode_recovery()
404 mod_timer(&xhci->comp_mode_recovery_timer, in compliance_mode_recovery()
415 * status event is generated when entering compliance mode (per xhci spec),
418 static void compliance_mode_recovery_timer_init(struct xhci_hcd *xhci) in compliance_mode_recovery_timer_init() argument
420 xhci->port_status_u0 = 0; in compliance_mode_recovery_timer_init()
421 timer_setup(&xhci->comp_mode_recovery_timer, compliance_mode_recovery, in compliance_mode_recovery_timer_init()
423 xhci->comp_mode_recovery_timer.expires = jiffies + in compliance_mode_recovery_timer_init()
426 add_timer(&xhci->comp_mode_recovery_timer); in compliance_mode_recovery_timer_init()
427 xhci_dbg_trace(xhci, trace_xhci_dbg_quirks, in compliance_mode_recovery_timer_init()
458 static int xhci_all_ports_seen_u0(struct xhci_hcd *xhci) in xhci_all_ports_seen_u0() argument
460 return (xhci->port_status_u0 == ((1 << xhci->usb3_rhub.num_ports) - 1)); in xhci_all_ports_seen_u0()
473 struct xhci_hcd *xhci = hcd_to_xhci(hcd); in xhci_init() local
476 xhci_dbg_trace(xhci, trace_xhci_dbg_init, "xhci_init"); in xhci_init()
477 spin_lock_init(&xhci->lock); in xhci_init()
479 retval = xhci_mem_init(xhci, GFP_KERNEL); in xhci_init()
480 xhci_dbg_trace(xhci, trace_xhci_dbg_init, "Finished xhci_init"); in xhci_init()
484 xhci->quirks |= XHCI_COMP_MODE_QUIRK; in xhci_init()
485 compliance_mode_recovery_timer_init(xhci); in xhci_init()
493 static int xhci_run_finished(struct xhci_hcd *xhci) in xhci_run_finished() argument
495 struct xhci_interrupter *ir = xhci->interrupters[0]; in xhci_run_finished()
500 * Enable interrupts before starting the host (xhci 4.2 and 5.5.2). in xhci_run_finished()
503 spin_lock_irqsave(&xhci->lock, flags); in xhci_run_finished()
505 xhci_dbg_trace(xhci, trace_xhci_dbg_init, "Enable interrupts"); in xhci_run_finished()
506 temp = readl(&xhci->op_regs->command); in xhci_run_finished()
508 writel(temp, &xhci->op_regs->command); in xhci_run_finished()
510 xhci_dbg_trace(xhci, trace_xhci_dbg_init, "Enable primary interrupter"); in xhci_run_finished()
513 if (xhci_start(xhci)) { in xhci_run_finished()
514 xhci_halt(xhci); in xhci_run_finished()
515 spin_unlock_irqrestore(&xhci->lock, flags); in xhci_run_finished()
519 xhci->cmd_ring_state = CMD_RING_STATE_RUNNING; in xhci_run_finished()
521 if (xhci->quirks & XHCI_NEC_HOST) in xhci_run_finished()
522 xhci_ring_cmd_db(xhci); in xhci_run_finished()
524 spin_unlock_irqrestore(&xhci->lock, flags); in xhci_run_finished()
545 struct xhci_hcd *xhci = hcd_to_xhci(hcd); in xhci_run() local
546 struct xhci_interrupter *ir = xhci->interrupters[0]; in xhci_run()
547 /* Start the xHCI host controller running only after the USB 2.0 roothub in xhci_run()
556 return xhci_run_finished(xhci); in xhci_run()
558 xhci_dbg_trace(xhci, trace_xhci_dbg_init, "xhci_run"); in xhci_run()
560 temp_64 = xhci_read_64(xhci, &ir->ir_set->erst_dequeue); in xhci_run()
562 xhci_dbg_trace(xhci, trace_xhci_dbg_init, in xhci_run()
565 xhci_set_interrupter_moderation(ir, xhci->imod_interval); in xhci_run()
567 if (xhci->quirks & XHCI_NEC_HOST) { in xhci_run()
570 command = xhci_alloc_command(xhci, false, GFP_KERNEL); in xhci_run()
574 ret = xhci_queue_vendor_command(xhci, command, 0, 0, 0, in xhci_run()
577 xhci_free_command(xhci, command); in xhci_run()
579 xhci_dbg_trace(xhci, trace_xhci_dbg_init, in xhci_run()
582 xhci_create_dbc_dev(xhci); in xhci_run()
584 xhci_debugfs_init(xhci); in xhci_run()
586 if (xhci_has_one_roothub(xhci)) in xhci_run()
587 return xhci_run_finished(xhci); in xhci_run()
596 * Stop xHCI driver.
607 struct xhci_hcd *xhci = hcd_to_xhci(hcd); in xhci_stop() local
608 struct xhci_interrupter *ir = xhci->interrupters[0]; in xhci_stop()
610 mutex_lock(&xhci->mutex); in xhci_stop()
614 mutex_unlock(&xhci->mutex); in xhci_stop()
618 xhci_remove_dbc_dev(xhci); in xhci_stop()
620 spin_lock_irq(&xhci->lock); in xhci_stop()
621 xhci->xhc_state |= XHCI_STATE_HALTED; in xhci_stop()
622 xhci->cmd_ring_state = CMD_RING_STATE_STOPPED; in xhci_stop()
623 xhci_halt(xhci); in xhci_stop()
624 xhci_reset(xhci, XHCI_RESET_SHORT_USEC); in xhci_stop()
625 spin_unlock_irq(&xhci->lock); in xhci_stop()
628 if ((xhci->quirks & XHCI_COMP_MODE_QUIRK) && in xhci_stop()
629 (!(xhci_all_ports_seen_u0(xhci)))) { in xhci_stop()
630 timer_delete_sync(&xhci->comp_mode_recovery_timer); in xhci_stop()
631 xhci_dbg_trace(xhci, trace_xhci_dbg_quirks, in xhci_stop()
636 if (xhci->quirks & XHCI_AMD_PLL_FIX) in xhci_stop()
639 xhci_dbg_trace(xhci, trace_xhci_dbg_init, in xhci_stop()
641 temp = readl(&xhci->op_regs->status); in xhci_stop()
642 writel((temp & ~0x1fff) | STS_EINT, &xhci->op_regs->status); in xhci_stop()
645 xhci_dbg_trace(xhci, trace_xhci_dbg_init, "cleaning up memory"); in xhci_stop()
646 xhci_mem_cleanup(xhci); in xhci_stop()
647 xhci_debugfs_exit(xhci); in xhci_stop()
648 xhci_dbg_trace(xhci, trace_xhci_dbg_init, in xhci_stop()
650 readl(&xhci->op_regs->status)); in xhci_stop()
651 mutex_unlock(&xhci->mutex); in xhci_stop()
666 struct xhci_hcd *xhci = hcd_to_xhci(hcd); in xhci_shutdown() local
668 if (xhci->quirks & XHCI_SPURIOUS_REBOOT) in xhci_shutdown()
672 xhci_dbg(xhci, "%s: stopping usb%d port polling.\n", in xhci_shutdown()
677 if (xhci->shared_hcd) { in xhci_shutdown()
678 clear_bit(HCD_FLAG_POLL_RH, &xhci->shared_hcd->flags); in xhci_shutdown()
679 timer_delete_sync(&xhci->shared_hcd->rh_timer); in xhci_shutdown()
682 spin_lock_irq(&xhci->lock); in xhci_shutdown()
683 xhci_halt(xhci); in xhci_shutdown()
689 if (xhci->quirks & XHCI_SPURIOUS_WAKEUP || in xhci_shutdown()
690 xhci->quirks & XHCI_RESET_TO_DEFAULT) in xhci_shutdown()
691 xhci_reset(xhci, XHCI_RESET_SHORT_USEC); in xhci_shutdown()
693 spin_unlock_irq(&xhci->lock); in xhci_shutdown()
695 xhci_dbg_trace(xhci, trace_xhci_dbg_init, in xhci_shutdown()
697 readl(&xhci->op_regs->status)); in xhci_shutdown()
702 static void xhci_save_registers(struct xhci_hcd *xhci) in xhci_save_registers() argument
707 xhci->s3.command = readl(&xhci->op_regs->command); in xhci_save_registers()
708 xhci->s3.dev_nt = readl(&xhci->op_regs->dev_notification); in xhci_save_registers()
709 xhci->s3.dcbaa_ptr = xhci_read_64(xhci, &xhci->op_regs->dcbaa_ptr); in xhci_save_registers()
710 xhci->s3.config_reg = readl(&xhci->op_regs->config_reg); in xhci_save_registers()
714 for (i = 0; i < xhci->max_interrupters; i++) { in xhci_save_registers()
715 ir = xhci->interrupters[i]; in xhci_save_registers()
720 ir->s3_erst_base = xhci_read_64(xhci, &ir->ir_set->erst_base); in xhci_save_registers()
721 ir->s3_erst_dequeue = xhci_read_64(xhci, &ir->ir_set->erst_dequeue); in xhci_save_registers()
727 static void xhci_restore_registers(struct xhci_hcd *xhci) in xhci_restore_registers() argument
732 writel(xhci->s3.command, &xhci->op_regs->command); in xhci_restore_registers()
733 writel(xhci->s3.dev_nt, &xhci->op_regs->dev_notification); in xhci_restore_registers()
734 xhci_write_64(xhci, xhci->s3.dcbaa_ptr, &xhci->op_regs->dcbaa_ptr); in xhci_restore_registers()
735 writel(xhci->s3.config_reg, &xhci->op_regs->config_reg); in xhci_restore_registers()
738 for (i = 0; i < xhci->max_interrupters; i++) { in xhci_restore_registers()
739 ir = xhci->interrupters[i]; in xhci_restore_registers()
744 xhci_write_64(xhci, ir->s3_erst_base, &ir->ir_set->erst_base); in xhci_restore_registers()
745 xhci_write_64(xhci, ir->s3_erst_dequeue, &ir->ir_set->erst_dequeue); in xhci_restore_registers()
751 static void xhci_set_cmd_ring_deq(struct xhci_hcd *xhci) in xhci_set_cmd_ring_deq() argument
756 val_64 = xhci_read_64(xhci, &xhci->op_regs->cmd_ring); in xhci_set_cmd_ring_deq()
758 (xhci_trb_virt_to_dma(xhci->cmd_ring->deq_seg, in xhci_set_cmd_ring_deq()
759 xhci->cmd_ring->dequeue) & in xhci_set_cmd_ring_deq()
761 xhci->cmd_ring->cycle_state; in xhci_set_cmd_ring_deq()
762 xhci_dbg_trace(xhci, trace_xhci_dbg_init, in xhci_set_cmd_ring_deq()
765 xhci_write_64(xhci, val_64, &xhci->op_regs->cmd_ring); in xhci_set_cmd_ring_deq()
777 static void xhci_clear_command_ring(struct xhci_hcd *xhci) in xhci_clear_command_ring() argument
782 ring = xhci->cmd_ring; in xhci_clear_command_ring()
798 xhci_set_cmd_ring_deq(xhci); in xhci_clear_command_ring()
806 * Internal wake causes immediate xHCI wake after suspend. PORT_CSC write done
810 static void xhci_disable_hub_port_wake(struct xhci_hcd *xhci, in xhci_disable_hub_port_wake() argument
818 spin_lock_irqsave(&xhci->lock, flags); in xhci_disable_hub_port_wake()
835 xhci_dbg(xhci, "config port %d-%d wake bits, portsc: 0x%x, write: 0x%x\n", in xhci_disable_hub_port_wake()
839 spin_unlock_irqrestore(&xhci->lock, flags); in xhci_disable_hub_port_wake()
842 static bool xhci_pending_portevent(struct xhci_hcd *xhci) in xhci_pending_portevent() argument
849 status = readl(&xhci->op_regs->status); in xhci_pending_portevent()
855 * being written to the Event Ring. See note in xhci 1.1 section 4.19.2. in xhci_pending_portevent()
858 port_index = xhci->usb2_rhub.num_ports; in xhci_pending_portevent()
859 ports = xhci->usb2_rhub.ports; in xhci_pending_portevent()
866 port_index = xhci->usb3_rhub.num_ports; in xhci_pending_portevent()
867 ports = xhci->usb3_rhub.ports; in xhci_pending_portevent()
883 int xhci_suspend(struct xhci_hcd *xhci, bool do_wakeup) in xhci_suspend() argument
887 struct usb_hcd *hcd = xhci_to_hcd(xhci); in xhci_suspend()
895 (xhci->shared_hcd && xhci->shared_hcd->state != HC_STATE_SUSPENDED)) in xhci_suspend()
899 xhci_disable_hub_port_wake(xhci, &xhci->usb3_rhub, do_wakeup); in xhci_suspend()
900 xhci_disable_hub_port_wake(xhci, &xhci->usb2_rhub, do_wakeup); in xhci_suspend()
905 xhci_dbc_suspend(xhci); in xhci_suspend()
908 xhci_dbg(xhci, "%s: stopping usb%d port polling.\n", in xhci_suspend()
912 if (xhci->shared_hcd) { in xhci_suspend()
913 clear_bit(HCD_FLAG_POLL_RH, &xhci->shared_hcd->flags); in xhci_suspend()
914 timer_delete_sync(&xhci->shared_hcd->rh_timer); in xhci_suspend()
917 if (xhci->quirks & XHCI_SUSPEND_DELAY) in xhci_suspend()
920 spin_lock_irq(&xhci->lock); in xhci_suspend()
922 if (xhci->shared_hcd) in xhci_suspend()
923 clear_bit(HCD_FLAG_HW_ACCESSIBLE, &xhci->shared_hcd->flags); in xhci_suspend()
928 command = readl(&xhci->op_regs->command); in xhci_suspend()
930 writel(command, &xhci->op_regs->command); in xhci_suspend()
933 delay *= (xhci->quirks & XHCI_SLOW_SUSPEND) ? 10 : 1; in xhci_suspend()
935 if (xhci_handshake(&xhci->op_regs->status, in xhci_suspend()
937 xhci_warn(xhci, "WARN: xHC CMD_RUN timeout\n"); in xhci_suspend()
938 spin_unlock_irq(&xhci->lock); in xhci_suspend()
941 xhci_clear_command_ring(xhci); in xhci_suspend()
944 xhci_save_registers(xhci); in xhci_suspend()
947 command = readl(&xhci->op_regs->command); in xhci_suspend()
949 writel(command, &xhci->op_regs->command); in xhci_suspend()
950 xhci->broken_suspend = 0; in xhci_suspend()
951 if (xhci_handshake(&xhci->op_regs->status, in xhci_suspend()
959 * if SRE and HCE bits are not set (as per xhci in xhci_suspend()
962 res = readl(&xhci->op_regs->status); in xhci_suspend()
963 if ((xhci->quirks & XHCI_SNPS_BROKEN_SUSPEND) && in xhci_suspend()
966 xhci->broken_suspend = 1; in xhci_suspend()
968 xhci_warn(xhci, "WARN: xHC save state timeout\n"); in xhci_suspend()
969 spin_unlock_irq(&xhci->lock); in xhci_suspend()
973 spin_unlock_irq(&xhci->lock); in xhci_suspend()
976 * Deleting Compliance Mode Recovery Timer because the xHCI Host in xhci_suspend()
979 if ((xhci->quirks & XHCI_COMP_MODE_QUIRK) && in xhci_suspend()
980 (!(xhci_all_ports_seen_u0(xhci)))) { in xhci_suspend()
981 timer_delete_sync(&xhci->comp_mode_recovery_timer); in xhci_suspend()
982 xhci_dbg_trace(xhci, trace_xhci_dbg_quirks, in xhci_suspend()
997 int xhci_resume(struct xhci_hcd *xhci, bool power_lost, bool is_auto_resume) in xhci_resume() argument
1000 struct usb_hcd *hcd = xhci_to_hcd(xhci); in xhci_resume()
1013 if (time_before(jiffies, xhci->usb2_rhub.bus_state.next_statechange) || in xhci_resume()
1014 time_before(jiffies, xhci->usb3_rhub.bus_state.next_statechange)) in xhci_resume()
1018 if (xhci->shared_hcd) in xhci_resume()
1019 set_bit(HCD_FLAG_HW_ACCESSIBLE, &xhci->shared_hcd->flags); in xhci_resume()
1021 spin_lock_irq(&xhci->lock); in xhci_resume()
1023 if (xhci->quirks & XHCI_RESET_ON_RESUME || xhci->broken_suspend) in xhci_resume()
1031 retval = xhci_handshake(&xhci->op_regs->status, in xhci_resume()
1034 xhci_warn(xhci, "Controller not ready at resume %d\n", in xhci_resume()
1036 spin_unlock_irq(&xhci->lock); in xhci_resume()
1040 xhci_restore_registers(xhci); in xhci_resume()
1042 xhci_set_cmd_ring_deq(xhci); in xhci_resume()
1045 command = readl(&xhci->op_regs->command); in xhci_resume()
1047 writel(command, &xhci->op_regs->command); in xhci_resume()
1050 * restore so setting the timeout to 100ms. Xhci specification in xhci_resume()
1053 if (xhci_handshake(&xhci->op_regs->status, in xhci_resume()
1055 xhci_warn(xhci, "WARN: xHC restore state timeout\n"); in xhci_resume()
1056 spin_unlock_irq(&xhci->lock); in xhci_resume()
1061 temp = readl(&xhci->op_regs->status); in xhci_resume()
1065 !(xhci->xhc_state & XHCI_STATE_REMOVING)) { in xhci_resume()
1067 xhci_warn(xhci, "xHC error in resume, USBSTS 0x%x, Reinit\n", temp); in xhci_resume()
1072 if ((xhci->quirks & XHCI_COMP_MODE_QUIRK) && in xhci_resume()
1073 !(xhci_all_ports_seen_u0(xhci))) { in xhci_resume()
1074 timer_delete_sync(&xhci->comp_mode_recovery_timer); in xhci_resume()
1075 xhci_dbg_trace(xhci, trace_xhci_dbg_quirks, in xhci_resume()
1080 usb_root_hub_lost_power(xhci->main_hcd->self.root_hub); in xhci_resume()
1081 if (xhci->shared_hcd) in xhci_resume()
1082 usb_root_hub_lost_power(xhci->shared_hcd->self.root_hub); in xhci_resume()
1084 xhci_dbg(xhci, "Stop HCD\n"); in xhci_resume()
1085 xhci_halt(xhci); in xhci_resume()
1086 xhci_zero_64b_regs(xhci); in xhci_resume()
1087 retval = xhci_reset(xhci, XHCI_RESET_LONG_USEC); in xhci_resume()
1088 spin_unlock_irq(&xhci->lock); in xhci_resume()
1092 xhci_dbg(xhci, "// Disabling event ring interrupts\n"); in xhci_resume()
1093 temp = readl(&xhci->op_regs->status); in xhci_resume()
1094 writel((temp & ~0x1fff) | STS_EINT, &xhci->op_regs->status); in xhci_resume()
1095 xhci_disable_interrupter(xhci->interrupters[0]); in xhci_resume()
1097 xhci_dbg(xhci, "cleaning up memory\n"); in xhci_resume()
1098 xhci_mem_cleanup(xhci); in xhci_resume()
1099 xhci_debugfs_exit(xhci); in xhci_resume()
1100 xhci_dbg(xhci, "xhci_stop completed - status = %x\n", in xhci_resume()
1101 readl(&xhci->op_regs->status)); in xhci_resume()
1107 xhci_dbg(xhci, "Initialize the xhci_hcd\n"); in xhci_resume()
1113 xhci_dbg(xhci, "Start the primary HCD\n"); in xhci_resume()
1115 if (!retval && xhci->shared_hcd) { in xhci_resume()
1116 xhci_dbg(xhci, "Start the secondary HCD\n"); in xhci_resume()
1117 retval = xhci_run(xhci->shared_hcd); in xhci_resume()
1127 if (xhci->shared_hcd) { in xhci_resume()
1128 xhci->shared_hcd->state = HC_STATE_SUSPENDED; in xhci_resume()
1129 usb_hcd_resume_root_hub(xhci->shared_hcd); in xhci_resume()
1137 command = readl(&xhci->op_regs->command); in xhci_resume()
1139 writel(command, &xhci->op_regs->command); in xhci_resume()
1140 xhci_handshake(&xhci->op_regs->status, STS_HALT, in xhci_resume()
1152 spin_unlock_irq(&xhci->lock); in xhci_resume()
1154 xhci_dbc_resume(xhci); in xhci_resume()
1163 if (xhci->usb3_rhub.bus_state.suspended_ports || in xhci_resume()
1164 xhci->usb3_rhub.bus_state.bus_suspended) in xhci_resume()
1167 pending_portevent = xhci_pending_portevent(xhci); in xhci_resume()
1171 pending_portevent = xhci_pending_portevent(xhci); in xhci_resume()
1175 if (xhci->shared_hcd) in xhci_resume()
1176 usb_hcd_resume_root_hub(xhci->shared_hcd); in xhci_resume()
1187 if ((xhci->quirks & XHCI_COMP_MODE_QUIRK) && !comp_timer_running) in xhci_resume()
1188 compliance_mode_recovery_timer_init(xhci); in xhci_resume()
1190 if (xhci->quirks & XHCI_ASMEDIA_MODIFY_FLOWCONTROL) in xhci_resume()
1194 xhci_dbg(xhci, "%s: starting usb%d port polling.\n", in xhci_resume()
1196 if (xhci->shared_hcd) { in xhci_resume()
1197 set_bit(HCD_FLAG_POLL_RH, &xhci->shared_hcd->flags); in xhci_resume()
1198 usb_hcd_poll_rh_status(xhci->shared_hcd); in xhci_resume()
1328 struct xhci_hcd *xhci; in xhci_map_urb_for_dma() local
1330 xhci = hcd_to_xhci(hcd); in xhci_map_urb_for_dma()
1335 if (xhci->quirks & XHCI_SG_TRB_CACHE_SIZE_QUIRK) { in xhci_map_urb_for_dma()
1344 struct xhci_hcd *xhci; in xhci_unmap_urb_for_dma() local
1347 xhci = hcd_to_xhci(hcd); in xhci_unmap_urb_for_dma()
1352 if ((xhci->quirks & XHCI_SG_TRB_CACHE_SIZE_QUIRK) && unmap_temp_buf) in xhci_unmap_urb_for_dma()
1381 * address from the XHCI endpoint index.
1416 struct xhci_hcd *xhci; in xhci_check_args() local
1420 pr_debug("xHCI %s called with invalid args\n", func); in xhci_check_args()
1424 pr_debug("xHCI %s called for root hub\n", func); in xhci_check_args()
1428 xhci = hcd_to_xhci(hcd); in xhci_check_args()
1430 if (!udev->slot_id || !xhci->devs[udev->slot_id]) { in xhci_check_args()
1431 xhci_dbg(xhci, "xHCI %s called with unaddressed device\n", in xhci_check_args()
1436 virt_dev = xhci->devs[udev->slot_id]; in xhci_check_args()
1438 xhci_dbg(xhci, "xHCI %s called with udev and " in xhci_check_args()
1444 if (xhci->xhc_state & XHCI_STATE_HALTED) in xhci_check_args()
1450 static int xhci_configure_endpoint(struct xhci_hcd *xhci,
1460 static int xhci_check_ep0_maxpacket(struct xhci_hcd *xhci, struct xhci_virt_device *vdev) in xhci_check_ep0_maxpacket() argument
1469 ep_ctx = xhci_get_ep_ctx(xhci, vdev->out_ctx, 0); in xhci_check_ep0_maxpacket()
1478 xhci_dbg_trace(xhci, trace_xhci_dbg_context_change, in xhci_check_ep0_maxpacket()
1480 xhci_dbg_trace(xhci, trace_xhci_dbg_context_change, in xhci_check_ep0_maxpacket()
1483 xhci_dbg_trace(xhci, trace_xhci_dbg_context_change, in xhci_check_ep0_maxpacket()
1484 "Max packet size in xHCI HW = %d", in xhci_check_ep0_maxpacket()
1486 xhci_dbg_trace(xhci, trace_xhci_dbg_context_change, in xhci_check_ep0_maxpacket()
1489 command = xhci_alloc_command(xhci, true, GFP_KERNEL); in xhci_check_ep0_maxpacket()
1496 xhci_warn(xhci, "%s: Could not get input context, bad type.\n", in xhci_check_ep0_maxpacket()
1502 xhci_endpoint_copy(xhci, vdev->in_ctx, vdev->out_ctx, 0); in xhci_check_ep0_maxpacket()
1504 ep_ctx = xhci_get_ep_ctx(xhci, command->in_ctx, 0); in xhci_check_ep0_maxpacket()
1512 ret = xhci_configure_endpoint(xhci, vdev->udev, command, in xhci_check_ep0_maxpacket()
1535 struct xhci_hcd *xhci = hcd_to_xhci(hcd); in xhci_urb_enqueue() local
1565 spin_lock_irqsave(&xhci->lock, flags); in xhci_urb_enqueue()
1581 if (xhci->devs[slot_id]->flags & VDEV_PORT_ERROR) { in xhci_urb_enqueue()
1582 xhci_dbg(xhci, "Can't queue urb, port error, link inactive\n"); in xhci_urb_enqueue()
1587 if (xhci->xhc_state & XHCI_STATE_DYING) { in xhci_urb_enqueue()
1588 xhci_dbg(xhci, "Ep 0x%x: URB %p submitted for non-responsive xHCI host.\n", in xhci_urb_enqueue()
1594 ep_state = &xhci->devs[slot_id]->eps[ep_index].ep_state; in xhci_urb_enqueue()
1597 xhci_warn(xhci, "WARN: Can't enqueue URB, ep in streams transition state %x\n", in xhci_urb_enqueue()
1603 xhci_warn(xhci, "Can't enqueue URB while manually clearing toggle\n"); in xhci_urb_enqueue()
1611 ret = xhci_queue_ctrl_tx(xhci, GFP_ATOMIC, urb, in xhci_urb_enqueue()
1615 ret = xhci_queue_bulk_tx(xhci, GFP_ATOMIC, urb, in xhci_urb_enqueue()
1619 ret = xhci_queue_intr_tx(xhci, GFP_ATOMIC, urb, in xhci_urb_enqueue()
1623 ret = xhci_queue_isoc_tx_prepare(xhci, GFP_ATOMIC, urb, in xhci_urb_enqueue()
1632 spin_unlock_irqrestore(&xhci->lock, flags); in xhci_urb_enqueue()
1654 * endpoint command, as noted in the xHCI 0.95 errata.
1672 struct xhci_hcd *xhci; in xhci_urb_dequeue() local
1681 xhci = hcd_to_xhci(hcd); in xhci_urb_dequeue()
1682 spin_lock_irqsave(&xhci->lock, flags); in xhci_urb_dequeue()
1692 vdev = xhci->devs[urb->dev->slot_id]; in xhci_urb_dequeue()
1699 ep_ring = xhci_urb_to_transfer_ring(xhci, urb); in xhci_urb_dequeue()
1704 temp = readl(&xhci->op_regs->status); in xhci_urb_dequeue()
1705 if (temp == ~(u32)0 || xhci->xhc_state & XHCI_STATE_DYING) { in xhci_urb_dequeue()
1706 xhci_hc_died(xhci); in xhci_urb_dequeue()
1716 xhci_err(xhci, "Canceled URB td not found on endpoint ring"); in xhci_urb_dequeue()
1725 if (xhci->xhc_state & XHCI_STATE_HALTED) { in xhci_urb_dequeue()
1726 xhci_dbg_trace(xhci, trace_xhci_dbg_cancel_urb, in xhci_urb_dequeue()
1742 xhci_dbg_trace(xhci, trace_xhci_dbg_cancel_urb, in xhci_urb_dequeue()
1763 xhci_dbg(xhci, "Not queuing Stop Endpoint on slot %d ep %d in state 0x%x\n", in xhci_urb_dequeue()
1771 xhci_dbg(xhci, "Invalidating TDs instantly on slot %d ep %d in state 0x%x\n", in xhci_urb_dequeue()
1776 command = xhci_alloc_command(xhci, false, GFP_ATOMIC); in xhci_urb_dequeue()
1783 xhci_queue_stop_endpoint(xhci, command, urb->dev->slot_id, in xhci_urb_dequeue()
1785 xhci_ring_cmd_db(xhci); in xhci_urb_dequeue()
1788 spin_unlock_irqrestore(&xhci->lock, flags); in xhci_urb_dequeue()
1795 spin_unlock_irqrestore(&xhci->lock, flags); in xhci_urb_dequeue()
1811 * the xhci->devs[slot_id] structure.
1816 struct xhci_hcd *xhci; in xhci_drop_endpoint() local
1828 xhci = hcd_to_xhci(hcd); in xhci_drop_endpoint()
1829 if (xhci->xhc_state & XHCI_STATE_DYING) in xhci_drop_endpoint()
1832 xhci_dbg(xhci, "%s called for udev %p\n", __func__, udev); in xhci_drop_endpoint()
1835 xhci_dbg(xhci, "xHCI %s - can't drop slot or ep 0 %#x\n", in xhci_drop_endpoint()
1840 in_ctx = xhci->devs[udev->slot_id]->in_ctx; in xhci_drop_endpoint()
1841 out_ctx = xhci->devs[udev->slot_id]->out_ctx; in xhci_drop_endpoint()
1844 xhci_warn(xhci, "%s: Could not get input context, bad type.\n", in xhci_drop_endpoint()
1850 ep_ctx = xhci_get_ep_ctx(xhci, out_ctx, ep_index); in xhci_drop_endpoint()
1858 if (xhci->devs[udev->slot_id]->eps[ep_index].ring != NULL) in xhci_drop_endpoint()
1859 xhci_warn(xhci, "xHCI %s called with disabled ep %p\n", in xhci_drop_endpoint()
1870 xhci_debugfs_remove_endpoint(xhci, xhci->devs[udev->slot_id], ep_index); in xhci_drop_endpoint()
1872 xhci_endpoint_zero(xhci, xhci->devs[udev->slot_id], ep); in xhci_drop_endpoint()
1874 xhci_dbg(xhci, "drop ep 0x%x, slot id %d, new drop flags = %#x, new add flags = %#x\n", in xhci_drop_endpoint()
1894 * for mutual exclusion to protect the xhci->devs[slot_id] structure.
1899 struct xhci_hcd *xhci; in xhci_add_endpoint() local
1915 xhci = hcd_to_xhci(hcd); in xhci_add_endpoint()
1916 if (xhci->xhc_state & XHCI_STATE_DYING) in xhci_add_endpoint()
1925 xhci_dbg(xhci, "xHCI %s - can't add slot or ep 0 %#x\n", in xhci_add_endpoint()
1930 virt_dev = xhci->devs[udev->slot_id]; in xhci_add_endpoint()
1934 xhci_warn(xhci, "%s: Could not get input context, bad type.\n", in xhci_add_endpoint()
1945 xhci_warn(xhci, "Trying to add endpoint 0x%x " in xhci_add_endpoint()
1955 xhci_warn(xhci, "xHCI %s called with enabled ep %p\n", in xhci_add_endpoint()
1965 if (xhci_endpoint_init(xhci, virt_dev, udev, ep, GFP_NOIO) < 0) { in xhci_add_endpoint()
1985 ep_ctx = xhci_get_ep_ctx(xhci, virt_dev->in_ctx, ep_index); in xhci_add_endpoint()
1988 xhci_dbg(xhci, "add ep 0x%x, slot id %d, new drop flags = %#x, new add flags = %#x\n", in xhci_add_endpoint()
1997 static void xhci_zero_in_ctx(struct xhci_hcd *xhci, struct xhci_virt_device *virt_dev) in xhci_zero_in_ctx() argument
2006 xhci_warn(xhci, "%s: Could not get input context, bad type.\n", in xhci_zero_in_ctx()
2018 slot_ctx = xhci_get_slot_ctx(xhci, virt_dev->in_ctx); in xhci_zero_in_ctx()
2023 ep_ctx = xhci_get_ep_ctx(xhci, virt_dev->in_ctx, i); in xhci_zero_in_ctx()
2031 static int xhci_configure_endpoint_result(struct xhci_hcd *xhci, in xhci_configure_endpoint_result() argument
2039 xhci_warn(xhci, "Timeout while waiting for configure endpoint command\n"); in xhci_configure_endpoint_result()
2068 xhci_dbg_trace(xhci, trace_xhci_dbg_context_change, in xhci_configure_endpoint_result()
2073 xhci_err(xhci, "ERROR: unexpected command completion code 0x%x.\n", in xhci_configure_endpoint_result()
2081 static int xhci_evaluate_context_result(struct xhci_hcd *xhci, in xhci_evaluate_context_result() argument
2089 xhci_warn(xhci, "Timeout while waiting for evaluate context command\n"); in xhci_evaluate_context_result()
2094 "WARN: xHCI driver setup invalid evaluate context command.\n"); in xhci_evaluate_context_result()
2118 xhci_dbg_trace(xhci, trace_xhci_dbg_context_change, in xhci_evaluate_context_result()
2123 xhci_err(xhci, "ERROR: unexpected command completion code 0x%x.\n", in xhci_evaluate_context_result()
2131 static u32 xhci_count_num_new_endpoints(struct xhci_hcd *xhci, in xhci_count_num_new_endpoints() argument
2152 static unsigned int xhci_count_num_dropped_endpoints(struct xhci_hcd *xhci, in xhci_count_num_dropped_endpoints() argument
2176 * Must be called with xhci->lock held.
2178 static int xhci_reserve_host_resources(struct xhci_hcd *xhci, in xhci_reserve_host_resources() argument
2183 added_eps = xhci_count_num_new_endpoints(xhci, ctrl_ctx); in xhci_reserve_host_resources()
2184 if (xhci->num_active_eps + added_eps > xhci->limit_active_eps) { in xhci_reserve_host_resources()
2185 xhci_dbg_trace(xhci, trace_xhci_dbg_quirks, in xhci_reserve_host_resources()
2188 xhci->num_active_eps, added_eps, in xhci_reserve_host_resources()
2189 xhci->limit_active_eps); in xhci_reserve_host_resources()
2192 xhci->num_active_eps += added_eps; in xhci_reserve_host_resources()
2193 xhci_dbg_trace(xhci, trace_xhci_dbg_quirks, in xhci_reserve_host_resources()
2195 xhci->num_active_eps); in xhci_reserve_host_resources()
2203 * Must be called with xhci->lock held.
2205 static void xhci_free_host_resources(struct xhci_hcd *xhci, in xhci_free_host_resources() argument
2210 num_failed_eps = xhci_count_num_new_endpoints(xhci, ctrl_ctx); in xhci_free_host_resources()
2211 xhci->num_active_eps -= num_failed_eps; in xhci_free_host_resources()
2212 xhci_dbg_trace(xhci, trace_xhci_dbg_quirks, in xhci_free_host_resources()
2215 xhci->num_active_eps); in xhci_free_host_resources()
2222 * Must be called with xhci->lock held.
2224 static void xhci_finish_resource_reservation(struct xhci_hcd *xhci, in xhci_finish_resource_reservation() argument
2229 num_dropped_eps = xhci_count_num_dropped_endpoints(xhci, ctrl_ctx); in xhci_finish_resource_reservation()
2230 xhci->num_active_eps -= num_dropped_eps; in xhci_finish_resource_reservation()
2232 xhci_dbg_trace(xhci, trace_xhci_dbg_quirks, in xhci_finish_resource_reservation()
2235 xhci->num_active_eps); in xhci_finish_resource_reservation()
2270 static int xhci_check_tt_bw_table(struct xhci_hcd *xhci, in xhci_check_tt_bw_table() argument
2278 bw_table = &xhci->rh_bw[virt_dev->rhub_port->hw_portnum].bw_table; in xhci_check_tt_bw_table()
2300 static int xhci_check_ss_bw(struct xhci_hcd *xhci, in xhci_check_ss_bw() argument
2357 static int xhci_check_bw_table(struct xhci_hcd *xhci, in xhci_check_bw_table() argument
2373 return xhci_check_ss_bw(xhci, virt_dev); in xhci_check_bw_table()
2394 xhci_dbg_trace(xhci, trace_xhci_dbg_quirks, in xhci_check_bw_table()
2397 if (xhci_check_tt_bw_table(xhci, virt_dev, old_active_eps)) { in xhci_check_bw_table()
2398 xhci_warn(xhci, "Not enough bandwidth on HS bus for " in xhci_check_bw_table()
2402 xhci_dbg_trace(xhci, trace_xhci_dbg_quirks, in xhci_check_bw_table()
2407 xhci_dbg_trace(xhci, trace_xhci_dbg_quirks, in xhci_check_bw_table()
2490 xhci_warn(xhci, "Not enough bandwidth. " in xhci_check_bw_table()
2511 xhci->rh_bw[virt_dev->rhub_port->hw_portnum].num_active_tts; in xhci_check_bw_table()
2514 xhci_dbg_trace(xhci, trace_xhci_dbg_quirks, in xhci_check_bw_table()
2523 xhci_warn(xhci, "Not enough bandwidth. Proposed: %u, Max: %u\n", in xhci_check_bw_table()
2558 static void xhci_drop_ep_from_interval_table(struct xhci_hcd *xhci, in xhci_drop_ep_from_interval_table() argument
2573 xhci->devs[udev->slot_id]->bw_table->ss_bw_in -= in xhci_drop_ep_from_interval_table()
2576 xhci->devs[udev->slot_id]->bw_table->ss_bw_out -= in xhci_drop_ep_from_interval_table()
2619 static void xhci_add_ep_to_interval_table(struct xhci_hcd *xhci, in xhci_add_ep_to_interval_table() argument
2635 xhci->devs[udev->slot_id]->bw_table->ss_bw_in += in xhci_add_ep_to_interval_table()
2638 xhci->devs[udev->slot_id]->bw_table->ss_bw_out += in xhci_add_ep_to_interval_table()
2690 void xhci_update_tt_active_eps(struct xhci_hcd *xhci, in xhci_update_tt_active_eps() argument
2698 rh_bw_info = &xhci->rh_bw[virt_dev->rhub_port->hw_portnum]; in xhci_update_tt_active_eps()
2710 static int xhci_reserve_bandwidth(struct xhci_hcd *xhci, in xhci_reserve_bandwidth() argument
2724 xhci_warn(xhci, "%s: Could not get input context, bad type.\n", in xhci_reserve_bandwidth()
2740 xhci_drop_ep_from_interval_table(xhci, in xhci_reserve_bandwidth()
2748 xhci_update_bw_info(xhci, virt_dev->in_ctx, ctrl_ctx, virt_dev); in xhci_reserve_bandwidth()
2752 xhci_add_ep_to_interval_table(xhci, in xhci_reserve_bandwidth()
2760 if (!xhci_check_bw_table(xhci, virt_dev, old_active_eps)) { in xhci_reserve_bandwidth()
2764 xhci_update_tt_active_eps(xhci, virt_dev, old_active_eps); in xhci_reserve_bandwidth()
2777 xhci_drop_ep_from_interval_table(xhci, in xhci_reserve_bandwidth()
2789 xhci_add_ep_to_interval_table(xhci, in xhci_reserve_bandwidth()
2800 * Synchronous XHCI stop endpoint helper. Issues the stop endpoint command and
2808 int xhci_stop_endpoint_sync(struct xhci_hcd *xhci, struct xhci_virt_ep *ep, int suspend, in xhci_stop_endpoint_sync() argument
2815 command = xhci_alloc_command(xhci, true, gfp_flags); in xhci_stop_endpoint_sync()
2819 spin_lock_irqsave(&xhci->lock, flags); in xhci_stop_endpoint_sync()
2820 ret = xhci_queue_stop_endpoint(xhci, command, ep->vdev->slot_id, in xhci_stop_endpoint_sync()
2823 spin_unlock_irqrestore(&xhci->lock, flags); in xhci_stop_endpoint_sync()
2827 xhci_ring_cmd_db(xhci); in xhci_stop_endpoint_sync()
2828 spin_unlock_irqrestore(&xhci->lock, flags); in xhci_stop_endpoint_sync()
2835 xhci_warn(xhci, "Timeout while waiting for stop endpoint command\n"); in xhci_stop_endpoint_sync()
2839 xhci_free_command(xhci, command); in xhci_stop_endpoint_sync()
2848 static int xhci_configure_endpoint(struct xhci_hcd *xhci, in xhci_configure_endpoint() argument
2862 spin_lock_irqsave(&xhci->lock, flags); in xhci_configure_endpoint()
2864 if (xhci->xhc_state & XHCI_STATE_DYING) { in xhci_configure_endpoint()
2865 spin_unlock_irqrestore(&xhci->lock, flags); in xhci_configure_endpoint()
2869 virt_dev = xhci->devs[udev->slot_id]; in xhci_configure_endpoint()
2873 spin_unlock_irqrestore(&xhci->lock, flags); in xhci_configure_endpoint()
2874 xhci_warn(xhci, "%s: Could not get input context, bad type.\n", in xhci_configure_endpoint()
2879 if ((xhci->quirks & XHCI_EP_LIMIT_QUIRK) && in xhci_configure_endpoint()
2880 xhci_reserve_host_resources(xhci, ctrl_ctx)) { in xhci_configure_endpoint()
2881 spin_unlock_irqrestore(&xhci->lock, flags); in xhci_configure_endpoint()
2882 xhci_warn(xhci, "Not enough host resources, " in xhci_configure_endpoint()
2884 xhci->num_active_eps); in xhci_configure_endpoint()
2887 if ((xhci->quirks & XHCI_SW_BW_CHECKING) && !ctx_change && in xhci_configure_endpoint()
2888 xhci_reserve_bandwidth(xhci, virt_dev, command->in_ctx)) { in xhci_configure_endpoint()
2889 if ((xhci->quirks & XHCI_EP_LIMIT_QUIRK)) in xhci_configure_endpoint()
2890 xhci_free_host_resources(xhci, ctrl_ctx); in xhci_configure_endpoint()
2891 spin_unlock_irqrestore(&xhci->lock, flags); in xhci_configure_endpoint()
2892 xhci_warn(xhci, "Not enough bandwidth\n"); in xhci_configure_endpoint()
2896 slot_ctx = xhci_get_slot_ctx(xhci, command->in_ctx); in xhci_configure_endpoint()
2902 ret = xhci_queue_configure_endpoint(xhci, command, in xhci_configure_endpoint()
2906 ret = xhci_queue_evaluate_context(xhci, command, in xhci_configure_endpoint()
2910 if ((xhci->quirks & XHCI_EP_LIMIT_QUIRK)) in xhci_configure_endpoint()
2911 xhci_free_host_resources(xhci, ctrl_ctx); in xhci_configure_endpoint()
2912 spin_unlock_irqrestore(&xhci->lock, flags); in xhci_configure_endpoint()
2913 xhci_dbg_trace(xhci, trace_xhci_dbg_context_change, in xhci_configure_endpoint()
2917 xhci_ring_cmd_db(xhci); in xhci_configure_endpoint()
2918 spin_unlock_irqrestore(&xhci->lock, flags); in xhci_configure_endpoint()
2924 ret = xhci_configure_endpoint_result(xhci, udev, in xhci_configure_endpoint()
2927 ret = xhci_evaluate_context_result(xhci, udev, in xhci_configure_endpoint()
2930 if ((xhci->quirks & XHCI_EP_LIMIT_QUIRK)) { in xhci_configure_endpoint()
2931 spin_lock_irqsave(&xhci->lock, flags); in xhci_configure_endpoint()
2936 xhci_free_host_resources(xhci, ctrl_ctx); in xhci_configure_endpoint()
2938 xhci_finish_resource_reservation(xhci, ctrl_ctx); in xhci_configure_endpoint()
2939 spin_unlock_irqrestore(&xhci->lock, flags); in xhci_configure_endpoint()
2944 static void xhci_check_bw_drop_ep_streams(struct xhci_hcd *xhci, in xhci_check_bw_drop_ep_streams() argument
2950 xhci_warn(xhci, "WARN: endpoint 0x%02x has streams on set_interface, freeing streams.\n", in xhci_check_bw_drop_ep_streams()
2952 xhci_free_stream_info(xhci, ep->stream_info); in xhci_check_bw_drop_ep_streams()
2965 * else should be touching the xhci->devs[slot_id] structure, so we
2966 * don't need to take the xhci->lock for manipulating that.
2972 struct xhci_hcd *xhci; in xhci_check_bandwidth() local
2981 xhci = hcd_to_xhci(hcd); in xhci_check_bandwidth()
2982 if ((xhci->xhc_state & XHCI_STATE_DYING) || in xhci_check_bandwidth()
2983 (xhci->xhc_state & XHCI_STATE_REMOVING)) in xhci_check_bandwidth()
2986 xhci_dbg(xhci, "%s called for udev %p\n", __func__, udev); in xhci_check_bandwidth()
2987 virt_dev = xhci->devs[udev->slot_id]; in xhci_check_bandwidth()
2989 command = xhci_alloc_command(xhci, true, GFP_KERNEL); in xhci_check_bandwidth()
2998 xhci_warn(xhci, "%s: Could not get input context, bad type.\n", in xhci_check_bandwidth()
3014 slot_ctx = xhci_get_slot_ctx(xhci, virt_dev->in_ctx); in xhci_check_bandwidth()
3026 ret = xhci_configure_endpoint(xhci, udev, command, in xhci_check_bandwidth()
3036 xhci_free_endpoint_ring(xhci, virt_dev, i); in xhci_check_bandwidth()
3037 xhci_check_bw_drop_ep_streams(xhci, virt_dev, i); in xhci_check_bandwidth()
3040 xhci_zero_in_ctx(xhci, virt_dev); in xhci_check_bandwidth()
3052 xhci_free_endpoint_ring(xhci, virt_dev, i); in xhci_check_bandwidth()
3054 xhci_check_bw_drop_ep_streams(xhci, virt_dev, i); in xhci_check_bandwidth()
3057 xhci_debugfs_create_endpoint(xhci, virt_dev, i); in xhci_check_bandwidth()
3069 struct xhci_hcd *xhci; in xhci_reset_bandwidth() local
3076 xhci = hcd_to_xhci(hcd); in xhci_reset_bandwidth()
3078 xhci_dbg(xhci, "%s called for udev %p\n", __func__, udev); in xhci_reset_bandwidth()
3079 virt_dev = xhci->devs[udev->slot_id]; in xhci_reset_bandwidth()
3083 xhci_debugfs_remove_endpoint(xhci, virt_dev, i); in xhci_reset_bandwidth()
3084 xhci_ring_free(xhci, virt_dev->eps[i].new_ring); in xhci_reset_bandwidth()
3088 xhci_zero_in_ctx(xhci, virt_dev); in xhci_reset_bandwidth()
3092 static void xhci_setup_input_ctx_for_config_ep(struct xhci_hcd *xhci, in xhci_setup_input_ctx_for_config_ep() argument
3100 xhci_slot_copy(xhci, in_ctx, out_ctx); in xhci_setup_input_ctx_for_config_ep()
3107 struct xhci_hcd *xhci; in xhci_endpoint_disable() local
3114 xhci = hcd_to_xhci(hcd); in xhci_endpoint_disable()
3116 spin_lock_irqsave(&xhci->lock, flags); in xhci_endpoint_disable()
3122 vdev = xhci->devs[udev->slot_id]; in xhci_endpoint_disable()
3131 spin_unlock_irqrestore(&xhci->lock, flags); in xhci_endpoint_disable()
3137 xhci_dbg(xhci, "endpoint disable with ep_state 0x%x\n", in xhci_endpoint_disable()
3141 spin_unlock_irqrestore(&xhci->lock, flags); in xhci_endpoint_disable()
3153 * endpoint. Refer to the additional note in xhci spcification section 4.6.8.
3162 struct xhci_hcd *xhci; in xhci_endpoint_reset() local
3173 xhci = hcd_to_xhci(hcd); in xhci_endpoint_reset()
3179 * mismatch. Reconfigure the xhci ep0 endpoint context here in that case in xhci_endpoint_reset()
3187 vdev = xhci->devs[udev->slot_id]; in xhci_endpoint_reset()
3191 xhci_check_ep0_maxpacket(xhci, vdev); in xhci_endpoint_reset()
3200 vdev = xhci->devs[udev->slot_id]; in xhci_endpoint_reset()
3208 spin_lock_irqsave(&xhci->lock, flags); in xhci_endpoint_reset()
3211 spin_unlock_irqrestore(&xhci->lock, flags); in xhci_endpoint_reset()
3214 spin_unlock_irqrestore(&xhci->lock, flags); in xhci_endpoint_reset()
3225 stop_cmd = xhci_alloc_command(xhci, true, GFP_NOWAIT); in xhci_endpoint_reset()
3229 cfg_cmd = xhci_alloc_command_with_ctx(xhci, true, GFP_NOWAIT); in xhci_endpoint_reset()
3233 spin_lock_irqsave(&xhci->lock, flags); in xhci_endpoint_reset()
3246 spin_unlock_irqrestore(&xhci->lock, flags); in xhci_endpoint_reset()
3247 xhci_free_command(xhci, cfg_cmd); in xhci_endpoint_reset()
3251 err = xhci_queue_stop_endpoint(xhci, stop_cmd, udev->slot_id, in xhci_endpoint_reset()
3254 spin_unlock_irqrestore(&xhci->lock, flags); in xhci_endpoint_reset()
3255 xhci_free_command(xhci, cfg_cmd); in xhci_endpoint_reset()
3256 xhci_dbg(xhci, "%s: Failed to queue stop ep command, %d ", in xhci_endpoint_reset()
3261 xhci_ring_cmd_db(xhci); in xhci_endpoint_reset()
3262 spin_unlock_irqrestore(&xhci->lock, flags); in xhci_endpoint_reset()
3266 spin_lock_irqsave(&xhci->lock, flags); in xhci_endpoint_reset()
3271 spin_unlock_irqrestore(&xhci->lock, flags); in xhci_endpoint_reset()
3272 xhci_free_command(xhci, cfg_cmd); in xhci_endpoint_reset()
3273 xhci_warn(xhci, "%s: Could not get input context, bad type.\n", in xhci_endpoint_reset()
3278 xhci_setup_input_ctx_for_config_ep(xhci, cfg_cmd->in_ctx, vdev->out_ctx, in xhci_endpoint_reset()
3280 xhci_endpoint_copy(xhci, cfg_cmd->in_ctx, vdev->out_ctx, ep_index); in xhci_endpoint_reset()
3282 err = xhci_queue_configure_endpoint(xhci, cfg_cmd, cfg_cmd->in_ctx->dma, in xhci_endpoint_reset()
3285 spin_unlock_irqrestore(&xhci->lock, flags); in xhci_endpoint_reset()
3286 xhci_free_command(xhci, cfg_cmd); in xhci_endpoint_reset()
3287 xhci_dbg(xhci, "%s: Failed to queue config ep command, %d ", in xhci_endpoint_reset()
3292 xhci_ring_cmd_db(xhci); in xhci_endpoint_reset()
3293 spin_unlock_irqrestore(&xhci->lock, flags); in xhci_endpoint_reset()
3297 xhci_free_command(xhci, cfg_cmd); in xhci_endpoint_reset()
3299 xhci_free_command(xhci, stop_cmd); in xhci_endpoint_reset()
3300 spin_lock_irqsave(&xhci->lock, flags); in xhci_endpoint_reset()
3303 spin_unlock_irqrestore(&xhci->lock, flags); in xhci_endpoint_reset()
3306 static int xhci_check_streams_endpoint(struct xhci_hcd *xhci, in xhci_check_streams_endpoint() argument
3316 ret = xhci_check_args(xhci_to_hcd(xhci), udev, ep, 1, true, __func__); in xhci_check_streams_endpoint()
3320 xhci_warn(xhci, "WARN: SuperSpeed Endpoint Companion" in xhci_check_streams_endpoint()
3327 ep_state = xhci->devs[slot_id]->eps[ep_index].ep_state; in xhci_check_streams_endpoint()
3330 xhci_warn(xhci, "WARN: SuperSpeed bulk endpoint 0x%x " in xhci_check_streams_endpoint()
3333 xhci_warn(xhci, "Send email to xHCI maintainer and ask for " in xhci_check_streams_endpoint()
3337 if (!list_empty(&xhci->devs[slot_id]->eps[ep_index].ring->td_list)) { in xhci_check_streams_endpoint()
3338 xhci_warn(xhci, "Cannot setup streams for SuperSpeed bulk " in xhci_check_streams_endpoint()
3346 static void xhci_calculate_streams_entries(struct xhci_hcd *xhci, in xhci_calculate_streams_entries() argument
3356 * level page entries), but that's an optional feature for xHCI host in xhci_calculate_streams_entries()
3359 max_streams = HCC_MAX_PSA(xhci->hcc_params); in xhci_calculate_streams_entries()
3361 xhci_dbg(xhci, "xHCI HW only supports %u stream ctx entries.\n", in xhci_calculate_streams_entries()
3372 static int xhci_calculate_streams_and_bitmask(struct xhci_hcd *xhci, in xhci_calculate_streams_and_bitmask() argument
3383 ret = xhci_check_streams_endpoint(xhci, udev, in xhci_calculate_streams_and_bitmask()
3390 xhci_dbg(xhci, "Ep 0x%x only supports %u stream IDs.\n", in xhci_calculate_streams_and_bitmask()
3404 static u32 xhci_calculate_no_streams_bitmask(struct xhci_hcd *xhci, in xhci_calculate_no_streams_bitmask() argument
3415 if (!xhci->devs[slot_id]) in xhci_calculate_no_streams_bitmask()
3420 ep_state = xhci->devs[slot_id]->eps[ep_index].ep_state; in xhci_calculate_no_streams_bitmask()
3423 xhci_warn(xhci, "WARN Can't disable streams for " in xhci_calculate_no_streams_bitmask()
3432 xhci_warn(xhci, "WARN Can't disable streams for " in xhci_calculate_no_streams_bitmask()
3436 xhci_warn(xhci, "WARN xhci_free_streams() called " in xhci_calculate_no_streams_bitmask()
3466 struct xhci_hcd *xhci; in xhci_alloc_streams() local
3480 * stream 0 that is reserved for xHCI usage. in xhci_alloc_streams()
3483 xhci = hcd_to_xhci(hcd); in xhci_alloc_streams()
3484 xhci_dbg(xhci, "Driver wants %u stream IDs (including stream 0).\n", in xhci_alloc_streams()
3488 if ((xhci->quirks & XHCI_BROKEN_STREAMS) || in xhci_alloc_streams()
3489 HCC_MAX_PSA(xhci->hcc_params) < 4) { in xhci_alloc_streams()
3490 xhci_dbg(xhci, "xHCI controller does not support streams.\n"); in xhci_alloc_streams()
3494 config_cmd = xhci_alloc_command_with_ctx(xhci, true, mem_flags); in xhci_alloc_streams()
3500 xhci_warn(xhci, "%s: Could not get input context, bad type.\n", in xhci_alloc_streams()
3502 xhci_free_command(xhci, config_cmd); in xhci_alloc_streams()
3510 spin_lock_irqsave(&xhci->lock, flags); in xhci_alloc_streams()
3511 ret = xhci_calculate_streams_and_bitmask(xhci, udev, eps, in xhci_alloc_streams()
3514 xhci_free_command(xhci, config_cmd); in xhci_alloc_streams()
3515 spin_unlock_irqrestore(&xhci->lock, flags); in xhci_alloc_streams()
3519 xhci_warn(xhci, "WARN: endpoints can't handle " in xhci_alloc_streams()
3521 xhci_free_command(xhci, config_cmd); in xhci_alloc_streams()
3522 spin_unlock_irqrestore(&xhci->lock, flags); in xhci_alloc_streams()
3525 vdev = xhci->devs[udev->slot_id]; in xhci_alloc_streams()
3533 spin_unlock_irqrestore(&xhci->lock, flags); in xhci_alloc_streams()
3539 xhci_calculate_streams_entries(xhci, &num_streams, &num_stream_ctxs); in xhci_alloc_streams()
3540 xhci_dbg(xhci, "Need %u stream ctx entries for %u stream IDs.\n", in xhci_alloc_streams()
3546 vdev->eps[ep_index].stream_info = xhci_alloc_stream_info(xhci, in xhci_alloc_streams()
3562 ep_ctx = xhci_get_ep_ctx(xhci, config_cmd->in_ctx, ep_index); in xhci_alloc_streams()
3564 xhci_endpoint_copy(xhci, config_cmd->in_ctx, in xhci_alloc_streams()
3566 xhci_setup_streams_ep_input_ctx(xhci, ep_ctx, in xhci_alloc_streams()
3572 xhci_setup_input_ctx_for_config_ep(xhci, config_cmd->in_ctx, in xhci_alloc_streams()
3577 ret = xhci_configure_endpoint(xhci, udev, config_cmd, in xhci_alloc_streams()
3587 spin_lock_irqsave(&xhci->lock, flags); in xhci_alloc_streams()
3591 xhci_dbg(xhci, "Slot %u ep ctx %u now has streams.\n", in xhci_alloc_streams()
3595 xhci_free_command(xhci, config_cmd); in xhci_alloc_streams()
3596 spin_unlock_irqrestore(&xhci->lock, flags); in xhci_alloc_streams()
3600 xhci_debugfs_create_stream_files(xhci, vdev, ep_index); in xhci_alloc_streams()
3609 xhci_free_stream_info(xhci, vdev->eps[ep_index].stream_info); in xhci_alloc_streams()
3616 xhci_endpoint_zero(xhci, vdev, eps[i]); in xhci_alloc_streams()
3618 xhci_free_command(xhci, config_cmd); in xhci_alloc_streams()
3633 struct xhci_hcd *xhci; in xhci_free_streams() local
3641 xhci = hcd_to_xhci(hcd); in xhci_free_streams()
3642 vdev = xhci->devs[udev->slot_id]; in xhci_free_streams()
3645 spin_lock_irqsave(&xhci->lock, flags); in xhci_free_streams()
3646 changed_ep_bitmask = xhci_calculate_no_streams_bitmask(xhci, in xhci_free_streams()
3649 spin_unlock_irqrestore(&xhci->lock, flags); in xhci_free_streams()
3661 spin_unlock_irqrestore(&xhci->lock, flags); in xhci_free_streams()
3662 xhci_warn(xhci, "%s: Could not get input context, bad type.\n", in xhci_free_streams()
3671 ep_ctx = xhci_get_ep_ctx(xhci, command->in_ctx, ep_index); in xhci_free_streams()
3672 xhci->devs[udev->slot_id]->eps[ep_index].ep_state |= in xhci_free_streams()
3675 xhci_endpoint_copy(xhci, command->in_ctx, in xhci_free_streams()
3680 xhci_setup_input_ctx_for_config_ep(xhci, command->in_ctx, in xhci_free_streams()
3683 spin_unlock_irqrestore(&xhci->lock, flags); in xhci_free_streams()
3688 ret = xhci_configure_endpoint(xhci, udev, command, in xhci_free_streams()
3697 spin_lock_irqsave(&xhci->lock, flags); in xhci_free_streams()
3700 xhci_free_stream_info(xhci, vdev->eps[ep_index].stream_info); in xhci_free_streams()
3708 spin_unlock_irqrestore(&xhci->lock, flags); in xhci_free_streams()
3718 * Must be called with xhci->lock held.
3720 void xhci_free_device_endpoint_resources(struct xhci_hcd *xhci, in xhci_free_device_endpoint_resources() argument
3733 xhci->num_active_eps -= num_dropped_eps; in xhci_free_device_endpoint_resources()
3735 xhci_dbg_trace(xhci, trace_xhci_dbg_quirks, in xhci_free_device_endpoint_resources()
3739 xhci->num_active_eps); in xhci_free_device_endpoint_resources()
3767 struct xhci_hcd *xhci; in xhci_discover_or_reset_device() local
3777 xhci = hcd_to_xhci(hcd); in xhci_discover_or_reset_device()
3779 virt_dev = xhci->devs[slot_id]; in xhci_discover_or_reset_device()
3781 xhci_dbg(xhci, "The device to be reset with slot ID %u does " in xhci_discover_or_reset_device()
3798 xhci_dbg(xhci, "The device to be reset with slot ID %u does " in xhci_discover_or_reset_device()
3809 slot_ctx = xhci_get_slot_ctx(xhci, virt_dev->out_ctx); in xhci_discover_or_reset_device()
3814 if (xhci->quirks & XHCI_ETRON_HOST) { in xhci_discover_or_reset_device()
3816 * Obtaining a new device slot to inform the xHCI host that in xhci_discover_or_reset_device()
3819 ret = xhci_disable_slot(xhci, udev->slot_id); in xhci_discover_or_reset_device()
3820 xhci_free_virt_device(xhci, udev->slot_id); in xhci_discover_or_reset_device()
3833 xhci_dbg(xhci, "Resetting device with slot ID %u\n", slot_id); in xhci_discover_or_reset_device()
3840 reset_device_cmd = xhci_alloc_command(xhci, true, GFP_NOIO); in xhci_discover_or_reset_device()
3842 xhci_dbg(xhci, "Couldn't allocate command structure.\n"); in xhci_discover_or_reset_device()
3847 spin_lock_irqsave(&xhci->lock, flags); in xhci_discover_or_reset_device()
3849 ret = xhci_queue_reset_device(xhci, reset_device_cmd, slot_id); in xhci_discover_or_reset_device()
3851 xhci_dbg(xhci, "FIXME: allocate a command ring segment\n"); in xhci_discover_or_reset_device()
3852 spin_unlock_irqrestore(&xhci->lock, flags); in xhci_discover_or_reset_device()
3855 xhci_ring_cmd_db(xhci); in xhci_discover_or_reset_device()
3856 spin_unlock_irqrestore(&xhci->lock, flags); in xhci_discover_or_reset_device()
3869 xhci_warn(xhci, "Timeout waiting for reset device command\n"); in xhci_discover_or_reset_device()
3874 xhci_dbg(xhci, "Can't reset device (slot ID %u) in %s state\n", in xhci_discover_or_reset_device()
3876 xhci_get_slot_state(xhci, virt_dev->out_ctx)); in xhci_discover_or_reset_device()
3877 xhci_dbg(xhci, "Not freeing device rings.\n"); in xhci_discover_or_reset_device()
3882 xhci_dbg(xhci, "Successful reset device command.\n"); in xhci_discover_or_reset_device()
3885 if (xhci_is_vendor_info_code(xhci, ret)) in xhci_discover_or_reset_device()
3887 xhci_warn(xhci, "Unknown completion code %u for " in xhci_discover_or_reset_device()
3894 if ((xhci->quirks & XHCI_EP_LIMIT_QUIRK)) { in xhci_discover_or_reset_device()
3895 spin_lock_irqsave(&xhci->lock, flags); in xhci_discover_or_reset_device()
3897 xhci_free_device_endpoint_resources(xhci, virt_dev, false); in xhci_discover_or_reset_device()
3898 spin_unlock_irqrestore(&xhci->lock, flags); in xhci_discover_or_reset_device()
3906 xhci_warn(xhci, "WARN: endpoint 0x%02x has streams on device reset, freeing streams.\n", in xhci_discover_or_reset_device()
3908 xhci_free_stream_info(xhci, ep->stream_info); in xhci_discover_or_reset_device()
3914 xhci_debugfs_remove_endpoint(xhci, virt_dev, i); in xhci_discover_or_reset_device()
3915 xhci_free_endpoint_ring(xhci, virt_dev, i); in xhci_discover_or_reset_device()
3918 xhci_drop_ep_from_interval_table(xhci, in xhci_discover_or_reset_device()
3927 xhci_update_tt_active_eps(xhci, virt_dev, old_active_eps); in xhci_discover_or_reset_device()
3932 xhci_free_command(xhci, reset_device_cmd); in xhci_discover_or_reset_device()
3943 struct xhci_hcd *xhci = hcd_to_xhci(hcd); in xhci_free_dev() local
3954 if (xhci->quirks & XHCI_RESET_ON_RESUME) in xhci_free_dev()
3964 virt_dev = xhci->devs[udev->slot_id]; in xhci_free_dev()
3965 slot_ctx = xhci_get_slot_ctx(xhci, virt_dev->out_ctx); in xhci_free_dev()
3972 xhci_disable_slot(xhci, udev->slot_id); in xhci_free_dev()
3974 spin_lock_irqsave(&xhci->lock, flags); in xhci_free_dev()
3975 xhci_free_virt_device(xhci, udev->slot_id); in xhci_free_dev()
3976 spin_unlock_irqrestore(&xhci->lock, flags); in xhci_free_dev()
3980 int xhci_disable_slot(struct xhci_hcd *xhci, u32 slot_id) in xhci_disable_slot() argument
3987 command = xhci_alloc_command(xhci, true, GFP_KERNEL); in xhci_disable_slot()
3991 xhci_debugfs_remove_slot(xhci, slot_id); in xhci_disable_slot()
3993 spin_lock_irqsave(&xhci->lock, flags); in xhci_disable_slot()
3995 state = readl(&xhci->op_regs->status); in xhci_disable_slot()
3996 if (state == 0xffffffff || (xhci->xhc_state & XHCI_STATE_DYING) || in xhci_disable_slot()
3997 (xhci->xhc_state & XHCI_STATE_HALTED)) { in xhci_disable_slot()
3998 spin_unlock_irqrestore(&xhci->lock, flags); in xhci_disable_slot()
4003 ret = xhci_queue_slot_control(xhci, command, TRB_DISABLE_SLOT, in xhci_disable_slot()
4006 spin_unlock_irqrestore(&xhci->lock, flags); in xhci_disable_slot()
4010 xhci_ring_cmd_db(xhci); in xhci_disable_slot()
4011 spin_unlock_irqrestore(&xhci->lock, flags); in xhci_disable_slot()
4016 xhci_warn(xhci, "Unsuccessful disable slot %u command, status %d\n", in xhci_disable_slot()
4019 xhci_free_command(xhci, command); in xhci_disable_slot()
4028 * Must be called with xhci->lock held.
4030 static int xhci_reserve_host_control_ep_resources(struct xhci_hcd *xhci) in xhci_reserve_host_control_ep_resources() argument
4032 if (xhci->num_active_eps + 1 > xhci->limit_active_eps) { in xhci_reserve_host_control_ep_resources()
4033 xhci_dbg_trace(xhci, trace_xhci_dbg_quirks, in xhci_reserve_host_control_ep_resources()
4036 xhci->num_active_eps, xhci->limit_active_eps); in xhci_reserve_host_control_ep_resources()
4039 xhci->num_active_eps += 1; in xhci_reserve_host_control_ep_resources()
4040 xhci_dbg_trace(xhci, trace_xhci_dbg_quirks, in xhci_reserve_host_control_ep_resources()
4042 xhci->num_active_eps); in xhci_reserve_host_control_ep_resources()
4053 struct xhci_hcd *xhci = hcd_to_xhci(hcd); in xhci_alloc_dev() local
4060 command = xhci_alloc_command(xhci, true, GFP_KERNEL); in xhci_alloc_dev()
4064 spin_lock_irqsave(&xhci->lock, flags); in xhci_alloc_dev()
4065 ret = xhci_queue_slot_control(xhci, command, TRB_ENABLE_SLOT, 0); in xhci_alloc_dev()
4067 spin_unlock_irqrestore(&xhci->lock, flags); in xhci_alloc_dev()
4068 xhci_dbg(xhci, "FIXME: allocate a command ring segment\n"); in xhci_alloc_dev()
4069 xhci_free_command(xhci, command); in xhci_alloc_dev()
4072 xhci_ring_cmd_db(xhci); in xhci_alloc_dev()
4073 spin_unlock_irqrestore(&xhci->lock, flags); in xhci_alloc_dev()
4079 xhci_err(xhci, "Error while assigning device slot ID: %s\n", in xhci_alloc_dev()
4081 xhci_err(xhci, "Max number of devices this xHCI host supports is %u.\n", in xhci_alloc_dev()
4083 readl(&xhci->cap_regs->hcs_params1))); in xhci_alloc_dev()
4084 xhci_free_command(xhci, command); in xhci_alloc_dev()
4088 xhci_free_command(xhci, command); in xhci_alloc_dev()
4090 if ((xhci->quirks & XHCI_EP_LIMIT_QUIRK)) { in xhci_alloc_dev()
4091 spin_lock_irqsave(&xhci->lock, flags); in xhci_alloc_dev()
4092 ret = xhci_reserve_host_control_ep_resources(xhci); in xhci_alloc_dev()
4094 spin_unlock_irqrestore(&xhci->lock, flags); in xhci_alloc_dev()
4095 xhci_warn(xhci, "Not enough host resources, " in xhci_alloc_dev()
4097 xhci->num_active_eps); in xhci_alloc_dev()
4100 spin_unlock_irqrestore(&xhci->lock, flags); in xhci_alloc_dev()
4106 if (!xhci_alloc_virt_device(xhci, slot_id, udev, GFP_NOIO)) { in xhci_alloc_dev()
4107 xhci_warn(xhci, "Could not allocate xHCI USB device data structures\n"); in xhci_alloc_dev()
4110 vdev = xhci->devs[slot_id]; in xhci_alloc_dev()
4111 slot_ctx = xhci_get_slot_ctx(xhci, vdev->out_ctx); in xhci_alloc_dev()
4116 xhci_debugfs_create_slot(xhci, slot_id); in xhci_alloc_dev()
4122 if (xhci->quirks & XHCI_RESET_ON_RESUME) in xhci_alloc_dev()
4130 xhci_disable_slot(xhci, udev->slot_id); in xhci_alloc_dev()
4131 xhci_free_virt_device(xhci, udev->slot_id); in xhci_alloc_dev()
4153 struct xhci_hcd *xhci = hcd_to_xhci(hcd); in xhci_setup_device() local
4159 mutex_lock(&xhci->mutex); in xhci_setup_device()
4161 if (xhci->xhc_state) { /* dying, removing or halted */ in xhci_setup_device()
4167 xhci_dbg_trace(xhci, trace_xhci_dbg_address, in xhci_setup_device()
4173 virt_dev = xhci->devs[udev->slot_id]; in xhci_setup_device()
4181 xhci_warn(xhci, "Virt dev invalid for slot_id 0x%x!\n", in xhci_setup_device()
4186 slot_ctx = xhci_get_slot_ctx(xhci, virt_dev->out_ctx); in xhci_setup_device()
4192 xhci_dbg(xhci, "Slot already in default state\n"); in xhci_setup_device()
4197 command = xhci_alloc_command(xhci, true, GFP_KERNEL); in xhci_setup_device()
4206 slot_ctx = xhci_get_slot_ctx(xhci, virt_dev->in_ctx); in xhci_setup_device()
4209 xhci_warn(xhci, "%s: Could not get input context, bad type.\n", in xhci_setup_device()
4216 * virt_device realloaction after a resume with an xHCI power loss, in xhci_setup_device()
4220 xhci_setup_addressable_virt_dev(xhci, udev); in xhci_setup_device()
4223 xhci_copy_ep0_dequeue_into_input_ctx(xhci, udev); in xhci_setup_device()
4227 trace_xhci_address_ctx(xhci, virt_dev->in_ctx, in xhci_setup_device()
4231 spin_lock_irqsave(&xhci->lock, flags); in xhci_setup_device()
4233 ret = xhci_queue_address_device(xhci, command, virt_dev->in_ctx->dma, in xhci_setup_device()
4236 spin_unlock_irqrestore(&xhci->lock, flags); in xhci_setup_device()
4237 xhci_dbg_trace(xhci, trace_xhci_dbg_address, in xhci_setup_device()
4241 xhci_ring_cmd_db(xhci); in xhci_setup_device()
4242 spin_unlock_irqrestore(&xhci->lock, flags); in xhci_setup_device()
4254 xhci_warn(xhci, "Timeout while waiting for setup device command\n"); in xhci_setup_device()
4259 xhci_err(xhci, "Setup ERROR: setup %s command for slot %d.\n", in xhci_setup_device()
4266 mutex_unlock(&xhci->mutex); in xhci_setup_device()
4267 ret = xhci_disable_slot(xhci, udev->slot_id); in xhci_setup_device()
4268 xhci_free_virt_device(xhci, udev->slot_id); in xhci_setup_device()
4271 xhci_setup_addressable_virt_dev(xhci, udev); in xhci_setup_device()
4282 xhci_dbg_trace(xhci, trace_xhci_dbg_address, in xhci_setup_device()
4286 xhci_err(xhci, in xhci_setup_device()
4289 trace_xhci_address_ctx(xhci, virt_dev->out_ctx, 1); in xhci_setup_device()
4295 temp_64 = xhci_read_64(xhci, &xhci->op_regs->dcbaa_ptr); in xhci_setup_device()
4296 xhci_dbg_trace(xhci, trace_xhci_dbg_address, in xhci_setup_device()
4298 xhci_dbg_trace(xhci, trace_xhci_dbg_address, in xhci_setup_device()
4301 &xhci->dcbaa->dev_context_ptrs[udev->slot_id], in xhci_setup_device()
4303 le64_to_cpu(xhci->dcbaa->dev_context_ptrs[udev->slot_id])); in xhci_setup_device()
4304 xhci_dbg_trace(xhci, trace_xhci_dbg_address, in xhci_setup_device()
4307 trace_xhci_address_ctx(xhci, virt_dev->in_ctx, in xhci_setup_device()
4313 trace_xhci_address_ctx(xhci, virt_dev->out_ctx, in xhci_setup_device()
4318 slot_ctx = xhci_get_slot_ctx(xhci, virt_dev->out_ctx); in xhci_setup_device()
4321 xhci_dbg_trace(xhci, trace_xhci_dbg_address, in xhci_setup_device()
4325 mutex_unlock(&xhci->mutex); in xhci_setup_device()
4363 static int __maybe_unused xhci_change_max_exit_latency(struct xhci_hcd *xhci, in xhci_change_max_exit_latency() argument
4373 command = xhci_alloc_command_with_ctx(xhci, true, GFP_KERNEL); in xhci_change_max_exit_latency()
4377 spin_lock_irqsave(&xhci->lock, flags); in xhci_change_max_exit_latency()
4379 virt_dev = xhci->devs[udev->slot_id]; in xhci_change_max_exit_latency()
4384 * hub_port_finish_reset() is done and xhci->devs[] are re-allocated in xhci_change_max_exit_latency()
4388 spin_unlock_irqrestore(&xhci->lock, flags); in xhci_change_max_exit_latency()
4389 xhci_free_command(xhci, command); in xhci_change_max_exit_latency()
4396 spin_unlock_irqrestore(&xhci->lock, flags); in xhci_change_max_exit_latency()
4397 xhci_free_command(xhci, command); in xhci_change_max_exit_latency()
4398 xhci_warn(xhci, "%s: Could not get input context, bad type.\n", in xhci_change_max_exit_latency()
4403 xhci_slot_copy(xhci, command->in_ctx, virt_dev->out_ctx); in xhci_change_max_exit_latency()
4404 spin_unlock_irqrestore(&xhci->lock, flags); in xhci_change_max_exit_latency()
4407 slot_ctx = xhci_get_slot_ctx(xhci, command->in_ctx); in xhci_change_max_exit_latency()
4412 xhci_dbg_trace(xhci, trace_xhci_dbg_context_change, in xhci_change_max_exit_latency()
4416 ret = xhci_configure_endpoint(xhci, udev, command, in xhci_change_max_exit_latency()
4420 spin_lock_irqsave(&xhci->lock, flags); in xhci_change_max_exit_latency()
4422 spin_unlock_irqrestore(&xhci->lock, flags); in xhci_change_max_exit_latency()
4425 xhci_free_command(xhci, command); in xhci_change_max_exit_latency()
4437 static int xhci_calculate_hird_besl(struct xhci_hcd *xhci, in xhci_calculate_hird_besl() argument
4444 u2del = HCS_U2_LATENCY(xhci->hcs_params3); in xhci_calculate_hird_besl()
4481 /* xHCI l1 is set in steps of 256us, xHCI 1.0 section 5.4.11.2 */ in xhci_calculate_usb2_hw_lpm_params()
4496 struct xhci_hcd *xhci = hcd_to_xhci(hcd); in xhci_set_usb2_hardware_lpm() local
4505 if (xhci->quirks & XHCI_HW_LPM_DISABLE) in xhci_set_usb2_hardware_lpm()
4508 if (hcd->speed >= HCD_USB3 || !xhci->hw_lpm_support || in xhci_set_usb2_hardware_lpm()
4519 spin_lock_irqsave(&xhci->lock, flags); in xhci_set_usb2_hardware_lpm()
4521 ports = xhci->usb2_rhub.ports; in xhci_set_usb2_hardware_lpm()
4527 xhci_dbg(xhci, "%s port %d USB2 hardware LPM\n", in xhci_set_usb2_hardware_lpm()
4535 * systems. See XHCI_DEFAULT_BESL definition in xhci.h in xhci_set_usb2_hardware_lpm()
4545 spin_unlock_irqrestore(&xhci->lock, flags); in xhci_set_usb2_hardware_lpm()
4547 ret = xhci_change_max_exit_latency(xhci, udev, in xhci_set_usb2_hardware_lpm()
4551 spin_lock_irqsave(&xhci->lock, flags); in xhci_set_usb2_hardware_lpm()
4558 hird = xhci_calculate_hird_besl(xhci, udev); in xhci_set_usb2_hardware_lpm()
4575 spin_unlock_irqrestore(&xhci->lock, flags); in xhci_set_usb2_hardware_lpm()
4576 xhci_change_max_exit_latency(xhci, udev, 0); in xhci_set_usb2_hardware_lpm()
4584 spin_unlock_irqrestore(&xhci->lock, flags); in xhci_set_usb2_hardware_lpm()
4590 struct xhci_hcd *xhci = hcd_to_xhci(hcd); in xhci_update_device() local
4596 port = xhci->usb3_rhub.ports[udev->portnum - 1]; in xhci_update_device()
4598 udev->tunnel_mode = xhci_port_is_tunneled(xhci, port); in xhci_update_device()
4608 if (hcd->speed >= HCD_USB3 || !udev->lpm_capable || !xhci->hw_lpm_support) in xhci_update_device()
4616 port = xhci->usb2_rhub.ports[udev->portnum - 1]; in xhci_update_device()
4727 static u16 xhci_calculate_u1_timeout(struct xhci_hcd *xhci, in xhci_calculate_u1_timeout() argument
4741 if (xhci->quirks & (XHCI_INTEL_HOST | XHCI_ZHAOXIN_HOST)) in xhci_calculate_u1_timeout()
4791 static u16 xhci_calculate_u2_timeout(struct xhci_hcd *xhci, in xhci_calculate_u2_timeout() argument
4805 if (xhci->quirks & (XHCI_INTEL_HOST | XHCI_ZHAOXIN_HOST)) in xhci_calculate_u2_timeout()
4822 static u16 xhci_call_host_update_timeout_for_endpoint(struct xhci_hcd *xhci, in xhci_call_host_update_timeout_for_endpoint() argument
4829 return xhci_calculate_u1_timeout(xhci, udev, desc); in xhci_call_host_update_timeout_for_endpoint()
4831 return xhci_calculate_u2_timeout(xhci, udev, desc); in xhci_call_host_update_timeout_for_endpoint()
4836 static int xhci_update_timeout_for_endpoint(struct xhci_hcd *xhci, in xhci_update_timeout_for_endpoint() argument
4844 alt_timeout = xhci_call_host_update_timeout_for_endpoint(xhci, udev, in xhci_update_timeout_for_endpoint()
4861 static int xhci_update_timeout_for_interface(struct xhci_hcd *xhci, in xhci_update_timeout_for_interface() argument
4870 if (xhci_update_timeout_for_endpoint(xhci, udev, in xhci_update_timeout_for_interface()
4877 static int xhci_check_tier_policy(struct xhci_hcd *xhci, in xhci_check_tier_policy() argument
4889 if (xhci->quirks & XHCI_INTEL_HOST && tier > 3) in xhci_check_tier_policy()
4891 if (xhci->quirks & XHCI_ZHAOXIN_HOST && tier > 2) in xhci_check_tier_policy()
4909 struct xhci_hcd *xhci = hcd_to_xhci(hcd); in xhci_calculate_lpm_timeout() local
4928 if (xhci_update_timeout_for_endpoint(xhci, udev, &udev->ep0.desc, in xhci_calculate_lpm_timeout()
4962 if (xhci_update_timeout_for_interface(xhci, udev, in xhci_calculate_lpm_timeout()
5004 /* xHCI host controller max exit latency field is only 16 bits wide. */ in calculate_max_exit_latency()
5017 struct xhci_hcd *xhci; in xhci_enable_usb3_lpm_timeout() local
5023 xhci = hcd_to_xhci(hcd); in xhci_enable_usb3_lpm_timeout()
5028 if (!xhci || !(xhci->quirks & XHCI_LPM_SUPPORT) || in xhci_enable_usb3_lpm_timeout()
5029 !xhci->devs[udev->slot_id]) in xhci_enable_usb3_lpm_timeout()
5032 if (xhci_check_tier_policy(xhci, udev, state) < 0) in xhci_enable_usb3_lpm_timeout()
5037 port = xhci->usb3_rhub.ports[udev->portnum - 1]; in xhci_enable_usb3_lpm_timeout()
5050 ret = xhci_change_max_exit_latency(xhci, udev, mel); in xhci_enable_usb3_lpm_timeout()
5059 struct xhci_hcd *xhci; in xhci_disable_usb3_lpm_timeout() local
5062 xhci = hcd_to_xhci(hcd); in xhci_disable_usb3_lpm_timeout()
5063 if (!xhci || !(xhci->quirks & XHCI_LPM_SUPPORT) || in xhci_disable_usb3_lpm_timeout()
5064 !xhci->devs[udev->slot_id]) in xhci_disable_usb3_lpm_timeout()
5068 return xhci_change_max_exit_latency(xhci, udev, mel); in xhci_disable_usb3_lpm_timeout()
5104 struct xhci_hcd *xhci = hcd_to_xhci(hcd); in xhci_update_hub_device() local
5117 vdev = xhci->devs[hdev->slot_id]; in xhci_update_hub_device()
5119 xhci_warn(xhci, "Cannot update hub desc for unknown device.\n"); in xhci_update_hub_device()
5123 config_cmd = xhci_alloc_command_with_ctx(xhci, true, mem_flags); in xhci_update_hub_device()
5129 xhci_warn(xhci, "%s: Could not get input context, bad type.\n", in xhci_update_hub_device()
5131 xhci_free_command(xhci, config_cmd); in xhci_update_hub_device()
5135 spin_lock_irqsave(&xhci->lock, flags); in xhci_update_hub_device()
5137 xhci_alloc_tt_info(xhci, vdev, hdev, tt, GFP_ATOMIC)) { in xhci_update_hub_device()
5138 xhci_dbg(xhci, "Could not allocate xHCI TT structure.\n"); in xhci_update_hub_device()
5139 xhci_free_command(xhci, config_cmd); in xhci_update_hub_device()
5140 spin_unlock_irqrestore(&xhci->lock, flags); in xhci_update_hub_device()
5144 xhci_slot_copy(xhci, config_cmd->in_ctx, vdev->out_ctx); in xhci_update_hub_device()
5146 slot_ctx = xhci_get_slot_ctx(xhci, config_cmd->in_ctx); in xhci_update_hub_device()
5150 * but it may be already set to 1 when setup an xHCI virtual in xhci_update_hub_device()
5158 if (xhci->hci_version > 0x95) { in xhci_update_hub_device()
5159 xhci_dbg(xhci, "xHCI version %x needs hub " in xhci_update_hub_device()
5161 (unsigned int) xhci->hci_version); in xhci_update_hub_device()
5167 * xHCI 1.0: this field shall be 0 if the device is not a in xhci_update_hub_device()
5173 if (xhci->hci_version < 0x100 || hdev->speed == USB_SPEED_HIGH) in xhci_update_hub_device()
5177 xhci_dbg(xhci, "xHCI version %x doesn't need hub " in xhci_update_hub_device()
5179 (unsigned int) xhci->hci_version); in xhci_update_hub_device()
5182 spin_unlock_irqrestore(&xhci->lock, flags); in xhci_update_hub_device()
5184 xhci_dbg(xhci, "Set up %s for hub device.\n", in xhci_update_hub_device()
5185 (xhci->hci_version > 0x95) ? in xhci_update_hub_device()
5191 if (xhci->hci_version > 0x95) in xhci_update_hub_device()
5192 ret = xhci_configure_endpoint(xhci, hdev, config_cmd, in xhci_update_hub_device()
5195 ret = xhci_configure_endpoint(xhci, hdev, config_cmd, in xhci_update_hub_device()
5198 xhci_free_command(xhci, config_cmd); in xhci_update_hub_device()
5205 struct xhci_hcd *xhci = hcd_to_xhci(hcd); in xhci_get_frame() local
5207 return readl(&xhci->run_regs->microframe_index) >> 3; in xhci_get_frame()
5210 static void xhci_hcd_init_usb2_data(struct xhci_hcd *xhci, struct usb_hcd *hcd) in xhci_hcd_init_usb2_data() argument
5212 xhci->usb2_rhub.hcd = hcd; in xhci_hcd_init_usb2_data()
5216 * USB 2.0 roothub under xHCI has an integrated TT, in xhci_hcd_init_usb2_data()
5223 static void xhci_hcd_init_usb3_data(struct xhci_hcd *xhci, struct usb_hcd *hcd) in xhci_hcd_init_usb3_data() argument
5228 * Early xHCI 1.1 spec did not mention USB 3.1 capable hosts in xhci_hcd_init_usb3_data()
5231 * This was later clarified in xHCI 1.2. in xhci_hcd_init_usb3_data()
5236 if (xhci->usb3_rhub.min_rev == 0x1) in xhci_hcd_init_usb3_data()
5239 minor_rev = xhci->usb3_rhub.min_rev / 0x10; in xhci_hcd_init_usb3_data()
5255 xhci_info(xhci, "Host supports USB 3.%x %sSuperSpeed\n", in xhci_hcd_init_usb3_data()
5258 xhci->usb3_rhub.hcd = hcd; in xhci_hcd_init_usb3_data()
5263 struct xhci_hcd *xhci; in xhci_gen_setup() local
5277 /* XHCI controllers don't stop the ep queue on short packets :| */ in xhci_gen_setup()
5280 xhci = hcd_to_xhci(hcd); in xhci_gen_setup()
5283 xhci_hcd_init_usb3_data(xhci, hcd); in xhci_gen_setup()
5287 mutex_init(&xhci->mutex); in xhci_gen_setup()
5288 xhci->main_hcd = hcd; in xhci_gen_setup()
5289 xhci->cap_regs = hcd->regs; in xhci_gen_setup()
5290 xhci->op_regs = hcd->regs + in xhci_gen_setup()
5291 HC_LENGTH(readl(&xhci->cap_regs->hc_capbase)); in xhci_gen_setup()
5292 xhci->run_regs = hcd->regs + in xhci_gen_setup()
5293 (readl(&xhci->cap_regs->run_regs_off) & RTSOFF_MASK); in xhci_gen_setup()
5295 xhci->hcs_params1 = readl(&xhci->cap_regs->hcs_params1); in xhci_gen_setup()
5296 xhci->hcs_params2 = readl(&xhci->cap_regs->hcs_params2); in xhci_gen_setup()
5297 xhci->hcs_params3 = readl(&xhci->cap_regs->hcs_params3); in xhci_gen_setup()
5298 xhci->hci_version = HC_VERSION(readl(&xhci->cap_regs->hc_capbase)); in xhci_gen_setup()
5299 xhci->hcc_params = readl(&xhci->cap_regs->hcc_params); in xhci_gen_setup()
5300 if (xhci->hci_version > 0x100) in xhci_gen_setup()
5301 xhci->hcc_params2 = readl(&xhci->cap_regs->hcc_params2); in xhci_gen_setup()
5303 /* xhci-plat or xhci-pci might have set max_interrupters already */ in xhci_gen_setup()
5304 if ((!xhci->max_interrupters) || in xhci_gen_setup()
5305 xhci->max_interrupters > HCS_MAX_INTRS(xhci->hcs_params1)) in xhci_gen_setup()
5306 xhci->max_interrupters = HCS_MAX_INTRS(xhci->hcs_params1); in xhci_gen_setup()
5308 xhci->quirks |= quirks; in xhci_gen_setup()
5311 get_quirks(dev, xhci); in xhci_gen_setup()
5313 /* In xhci controllers which follow xhci 1.0 spec gives a spurious in xhci_gen_setup()
5317 if (xhci->hci_version > 0x96) in xhci_gen_setup()
5318 xhci->quirks |= XHCI_SPURIOUS_SUCCESS; in xhci_gen_setup()
5320 if (xhci->hci_version == 0x95 && link_quirk) { in xhci_gen_setup()
5321 xhci_dbg(xhci, "QUIRK: Not clearing Link TRB chain bits"); in xhci_gen_setup()
5322 xhci->quirks |= XHCI_LINK_TRB_QUIRK; in xhci_gen_setup()
5326 retval = xhci_halt(xhci); in xhci_gen_setup()
5330 xhci_zero_64b_regs(xhci); in xhci_gen_setup()
5332 xhci_dbg(xhci, "Resetting HCD\n"); in xhci_gen_setup()
5334 retval = xhci_reset(xhci, XHCI_RESET_LONG_USEC); in xhci_gen_setup()
5337 xhci_dbg(xhci, "Reset complete\n"); in xhci_gen_setup()
5340 * On some xHCI controllers (e.g. R-Car SoCs), the AC64 bit (bit 0) in xhci_gen_setup()
5343 * bit of xhci->hcc_params to call dma_set_coherent_mask(dev, in xhci_gen_setup()
5346 if (xhci->quirks & XHCI_NO_64BIT_SUPPORT) in xhci_gen_setup()
5347 xhci->hcc_params &= ~BIT(0); in xhci_gen_setup()
5351 if (HCC_64BIT_ADDR(xhci->hcc_params) && in xhci_gen_setup()
5353 xhci_dbg(xhci, "Enabling 64-bit DMA addresses.\n"); in xhci_gen_setup()
5363 xhci_dbg(xhci, "Enabling 32-bit DMA addresses.\n"); in xhci_gen_setup()
5367 xhci_dbg(xhci, "Calling HCD init\n"); in xhci_gen_setup()
5372 xhci_dbg(xhci, "Called HCD init\n"); in xhci_gen_setup()
5375 xhci_hcd_init_usb3_data(xhci, hcd); in xhci_gen_setup()
5377 xhci_hcd_init_usb2_data(xhci, hcd); in xhci_gen_setup()
5379 xhci_info(xhci, "hcc params 0x%08x hci version 0x%x quirks 0x%016llx\n", in xhci_gen_setup()
5380 xhci->hcc_params, xhci->hci_version, xhci->quirks); in xhci_gen_setup()
5389 struct xhci_hcd *xhci; in xhci_clear_tt_buffer_complete() local
5395 xhci = hcd_to_xhci(hcd); in xhci_clear_tt_buffer_complete()
5397 spin_lock_irqsave(&xhci->lock, flags); in xhci_clear_tt_buffer_complete()
5402 xhci->devs[slot_id]->eps[ep_index].ep_state &= ~EP_CLEARING_TT; in xhci_clear_tt_buffer_complete()
5403 xhci_ring_doorbell_for_active_rings(xhci, slot_id, ep_index); in xhci_clear_tt_buffer_complete()
5404 spin_unlock_irqrestore(&xhci->lock, flags); in xhci_clear_tt_buffer_complete()
5408 .description = "xhci-hcd",
5409 .product_desc = "xHCI Host Controller",