// SPDX-License-Identifier: GPL-2.0 /* * xHCI host controller driver * * Copyright (C) 2008 Intel Corp. * * Author: Sarah Sharp * Some code borrowed from the Linux EHCI driver. */ #include <linux/pci.h> #include <linux/iommu.h> #include <linux/iopoll.h> #include <linux/irq.h> #include <linux/log2.h> #include <linux/module.h> #include <linux/moduleparam.h> #include <linux/slab.h> #include <linux/dmi.h> #include <linux/dma-mapping.h> #include "xhci.h" #include "xhci-trace.h" #include "xhci-debugfs.h" #include "xhci-dbgcap.h" #define DRIVER_AUTHOR … #define DRIVER_DESC … #define PORT_WAKE_BITS … /* Some 0.95 hardware can't handle the chain bit on a Link TRB being cleared */ static int link_quirk; module_param(link_quirk, int, S_IRUGO | S_IWUSR); MODULE_PARM_DESC(…) …; static unsigned long long quirks; module_param(quirks, ullong, S_IRUGO); MODULE_PARM_DESC(…) …; static bool td_on_ring(struct xhci_td *td, struct xhci_ring *ring) { … } /* * xhci_handshake - spin reading hc until handshake completes or fails * @ptr: address of hc register to be read * @mask: bits to look at in result of read * @done: value of those bits when handshake succeeds * @usec: timeout in microseconds * * Returns negative errno, or zero on success * * Success happens when the "mask" bits have the specified value (hardware * handshake done). There are two failure modes: "usec" have passed (major * hardware flakeout), or the register reads as all-ones (hardware removed). */ int xhci_handshake(void __iomem *ptr, u32 mask, u32 done, u64 timeout_us) { … } /* * xhci_handshake_check_state - same as xhci_handshake but takes an additional * exit_state parameter, and bails out with an error immediately when xhc_state * has exit_state flag set. */ int xhci_handshake_check_state(struct xhci_hcd *xhci, void __iomem *ptr, u32 mask, u32 done, int usec, unsigned int exit_state) { … } /* * Disable interrupts and begin the xHCI halting process. */ void xhci_quiesce(struct xhci_hcd *xhci) { … } /* * Force HC into halt state. * * Disable any IRQs and clear the run/stop bit. * HC will complete any current and actively pipelined transactions, and * should halt within 16 ms of the run/stop bit being cleared. * Read HC Halted bit in the status register to see when the HC is finished. */ int xhci_halt(struct xhci_hcd *xhci) { … } /* * Set the run bit and wait for the host to be running. */ int xhci_start(struct xhci_hcd *xhci) { … } /* * Reset a halted HC. * * This resets pipelines, timers, counters, state machines, etc. * Transactions will be terminated immediately, and operational registers * will be set to their defaults. */ int xhci_reset(struct xhci_hcd *xhci, u64 timeout_us) { … } static void xhci_zero_64b_regs(struct xhci_hcd *xhci) { … } static int xhci_enable_interrupter(struct xhci_interrupter *ir) { … } static int xhci_disable_interrupter(struct xhci_interrupter *ir) { … } /* interrupt moderation interval imod_interval in nanoseconds */ static int xhci_set_interrupter_moderation(struct xhci_interrupter *ir, u32 imod_interval) { … } static void compliance_mode_recovery(struct timer_list *t) { … } /* * Quirk to work around issue generated by the SN65LVPE502CP USB3.0 re-driver * that causes ports behind that hardware to enter compliance mode sometimes. * The quirk creates a timer that polls every 2 seconds the link state of * each host controller's port and recovers it by issuing a Warm reset * if Compliance mode is detected, otherwise the port will become "dead" (no * device connections or disconnections will be detected anymore). Becasue no * status event is generated when entering compliance mode (per xhci spec), * this quirk is needed on systems that have the failing hardware installed. */ static void compliance_mode_recovery_timer_init(struct xhci_hcd *xhci) { … } /* * This function identifies the systems that have installed the SN65LVPE502CP * USB3.0 re-driver and that need the Compliance Mode Quirk. * Systems: * Vendor: Hewlett-Packard -> System Models: Z420, Z620 and Z820 */ static bool xhci_compliance_mode_recovery_timer_quirk_check(void) { … } static int xhci_all_ports_seen_u0(struct xhci_hcd *xhci) { … } /* * Initialize memory for HCD and xHC (one-time init). * * Program the PAGESIZE register, initialize the device context array, create * device contexts (?), set up a command ring segment (or two?), create event * ring (one for now). */ static int xhci_init(struct usb_hcd *hcd) { … } /*-------------------------------------------------------------------------*/ static int xhci_run_finished(struct xhci_hcd *xhci) { … } /* * Start the HC after it was halted. * * This function is called by the USB core when the HC driver is added. * Its opposite is xhci_stop(). * * xhci_init() must be called once before this function can be called. * Reset the HC, enable device slot contexts, program DCBAAP, and * set command ring pointer and event ring pointer. * * Setup MSI-X vectors and enable interrupts. */ int xhci_run(struct usb_hcd *hcd) { … } EXPORT_SYMBOL_GPL(…); /* * Stop xHCI driver. * * This function is called by the USB core when the HC driver is removed. * Its opposite is xhci_run(). * * Disable device contexts, disable IRQs, and quiesce the HC. * Reset the HC, finish any completed transactions, and cleanup memory. */ void xhci_stop(struct usb_hcd *hcd) { … } EXPORT_SYMBOL_GPL(…); /* * Shutdown HC (not bus-specific) * * This is called when the machine is rebooting or halting. We assume that the * machine will be powered off, and the HC's internal state will be reset. * Don't bother to free memory. * * This will only ever be called with the main usb_hcd (the USB3 roothub). */ void xhci_shutdown(struct usb_hcd *hcd) { … } EXPORT_SYMBOL_GPL(…); #ifdef CONFIG_PM static void xhci_save_registers(struct xhci_hcd *xhci) { … } static void xhci_restore_registers(struct xhci_hcd *xhci) { … } static void xhci_set_cmd_ring_deq(struct xhci_hcd *xhci) { … } /* * The whole command ring must be cleared to zero when we suspend the host. * * The host doesn't save the command ring pointer in the suspend well, so we * need to re-program it on resume. Unfortunately, the pointer must be 64-byte * aligned, because of the reserved bits in the command ring dequeue pointer * register. Therefore, we can't just set the dequeue pointer back in the * middle of the ring (TRBs are 16-byte aligned). */ static void xhci_clear_command_ring(struct xhci_hcd *xhci) { … } /* * Disable port wake bits if do_wakeup is not set. * * Also clear a possible internal port wake state left hanging for ports that * detected termination but never successfully enumerated (trained to 0U). * Internal wake causes immediate xHCI wake after suspend. PORT_CSC write done * at enumeration clears this wake, force one here as well for unconnected ports */ static void xhci_disable_hub_port_wake(struct xhci_hcd *xhci, struct xhci_hub *rhub, bool do_wakeup) { … } static bool xhci_pending_portevent(struct xhci_hcd *xhci) { … } /* * Stop HC (not bus-specific) * * This is called when the machine transition into S3/S4 mode. * */ int xhci_suspend(struct xhci_hcd *xhci, bool do_wakeup) { … } EXPORT_SYMBOL_GPL(…); /* * start xHC (not bus-specific) * * This is called when the machine transition from S3/S4 mode. * */ int xhci_resume(struct xhci_hcd *xhci, pm_message_t msg) { … } EXPORT_SYMBOL_GPL(…); #endif /* CONFIG_PM */ /*-------------------------------------------------------------------------*/ static int xhci_map_temp_buffer(struct usb_hcd *hcd, struct urb *urb) { … } static bool xhci_urb_temp_buffer_required(struct usb_hcd *hcd, struct urb *urb) { … } static void xhci_unmap_temp_buf(struct usb_hcd *hcd, struct urb *urb) { … } /* * Bypass the DMA mapping if URB is suitable for Immediate Transfer (IDT), * we'll copy the actual data into the TRB address register. This is limited to * transfers up to 8 bytes on output endpoints of any kind with wMaxPacketSize * >= 8 bytes. If suitable for IDT only one Transfer TRB per TD is allowed. */ static int xhci_map_urb_for_dma(struct usb_hcd *hcd, struct urb *urb, gfp_t mem_flags) { … } static void xhci_unmap_urb_for_dma(struct usb_hcd *hcd, struct urb *urb) { … } /** * xhci_get_endpoint_index - Used for passing endpoint bitmasks between the core and * HCDs. Find the index for an endpoint given its descriptor. Use the return * value to right shift 1 for the bitmask. * * Index = (epnum * 2) + direction - 1, * where direction = 0 for OUT, 1 for IN. * For control endpoints, the IN index is used (OUT index is unused), so * index = (epnum * 2) + direction - 1 = (epnum * 2) + 1 - 1 = (epnum * 2) */ unsigned int xhci_get_endpoint_index(struct usb_endpoint_descriptor *desc) { … } EXPORT_SYMBOL_GPL(…); /* The reverse operation to xhci_get_endpoint_index. Calculate the USB endpoint * address from the XHCI endpoint index. */ static unsigned int xhci_get_endpoint_address(unsigned int ep_index) { … } /* Find the flag for this endpoint (for use in the control context). Use the * endpoint index to create a bitmask. The slot context is bit 0, endpoint 0 is * bit 1, etc. */ static unsigned int xhci_get_endpoint_flag(struct usb_endpoint_descriptor *desc) { … } /* Compute the last valid endpoint context index. Basically, this is the * endpoint index plus one. For slot contexts with more than valid endpoint, * we find the most significant bit set in the added contexts flags. * e.g. ep 1 IN (with epnum 0x81) => added_ctxs = 0b1000 * fls(0b1000) = 4, but the endpoint context index is 3, so subtract one. */ unsigned int xhci_last_valid_endpoint(u32 added_ctxs) { … } /* Returns 1 if the arguments are OK; * returns 0 this is a root hub; returns -EINVAL for NULL pointers. */ static int xhci_check_args(struct usb_hcd *hcd, struct usb_device *udev, struct usb_host_endpoint *ep, int check_ep, bool check_virt_dev, const char *func) { … } static int xhci_configure_endpoint(struct xhci_hcd *xhci, struct usb_device *udev, struct xhci_command *command, bool ctx_change, bool must_succeed); /* * Full speed devices may have a max packet size greater than 8 bytes, but the * USB core doesn't know that until it reads the first 8 bytes of the * descriptor. If the usb_device's max packet size changes after that point, * we need to issue an evaluate context command and wait on it. */ static int xhci_check_ep0_maxpacket(struct xhci_hcd *xhci, struct xhci_virt_device *vdev) { … } /* * non-error returns are a promise to giveback() the urb later * we drop ownership so next owner (or urb unlink) can get it */ static int xhci_urb_enqueue(struct usb_hcd *hcd, struct urb *urb, gfp_t mem_flags) { … } /* * Remove the URB's TD from the endpoint ring. This may cause the HC to stop * USB transfers, potentially stopping in the middle of a TRB buffer. The HC * should pick up where it left off in the TD, unless a Set Transfer Ring * Dequeue Pointer is issued. * * The TRBs that make up the buffers for the canceled URB will be "removed" from * the ring. Since the ring is a contiguous structure, they can't be physically * removed. Instead, there are two options: * * 1) If the HC is in the middle of processing the URB to be canceled, we * simply move the ring's dequeue pointer past those TRBs using the Set * Transfer Ring Dequeue Pointer command. This will be the common case, * when drivers timeout on the last submitted URB and attempt to cancel. * * 2) If the HC is in the middle of a different TD, we turn the TRBs into a * series of 1-TRB transfer no-op TDs. (No-ops shouldn't be chained.) The * HC will need to invalidate the any TRBs it has cached after the stop * endpoint command, as noted in the xHCI 0.95 errata. * * 3) The TD may have completed by the time the Stop Endpoint Command * completes, so software needs to handle that case too. * * This function should protect against the TD enqueueing code ringing the * doorbell while this code is waiting for a Stop Endpoint command to complete. * It also needs to account for multiple cancellations on happening at the same * time for the same endpoint. * * Note that this function can be called in any context, or so says * usb_hcd_unlink_urb() */ static int xhci_urb_dequeue(struct usb_hcd *hcd, struct urb *urb, int status) { … } /* Drop an endpoint from a new bandwidth configuration for this device. * Only one call to this function is allowed per endpoint before * check_bandwidth() or reset_bandwidth() must be called. * A call to xhci_drop_endpoint() followed by a call to xhci_add_endpoint() will * add the endpoint to the schedule with possibly new parameters denoted by a * different endpoint descriptor in usb_host_endpoint. * A call to xhci_add_endpoint() followed by a call to xhci_drop_endpoint() is * not allowed. * * The USB core will not allow URBs to be queued to an endpoint that is being * disabled, so there's no need for mutual exclusion to protect * the xhci->devs[slot_id] structure. */ int xhci_drop_endpoint(struct usb_hcd *hcd, struct usb_device *udev, struct usb_host_endpoint *ep) { … } EXPORT_SYMBOL_GPL(…); /* Add an endpoint to a new possible bandwidth configuration for this device. * Only one call to this function is allowed per endpoint before * check_bandwidth() or reset_bandwidth() must be called. * A call to xhci_drop_endpoint() followed by a call to xhci_add_endpoint() will * add the endpoint to the schedule with possibly new parameters denoted by a * different endpoint descriptor in usb_host_endpoint. * A call to xhci_add_endpoint() followed by a call to xhci_drop_endpoint() is * not allowed. * * The USB core will not allow URBs to be queued to an endpoint until the * configuration or alt setting is installed in the device, so there's no need * for mutual exclusion to protect the xhci->devs[slot_id] structure. */ int xhci_add_endpoint(struct usb_hcd *hcd, struct usb_device *udev, struct usb_host_endpoint *ep) { … } EXPORT_SYMBOL_GPL(…); static void xhci_zero_in_ctx(struct xhci_hcd *xhci, struct xhci_virt_device *virt_dev) { … } static int xhci_configure_endpoint_result(struct xhci_hcd *xhci, struct usb_device *udev, u32 *cmd_status) { … } static int xhci_evaluate_context_result(struct xhci_hcd *xhci, struct usb_device *udev, u32 *cmd_status) { … } static u32 xhci_count_num_new_endpoints(struct xhci_hcd *xhci, struct xhci_input_control_ctx *ctrl_ctx) { … } static unsigned int xhci_count_num_dropped_endpoints(struct xhci_hcd *xhci, struct xhci_input_control_ctx *ctrl_ctx) { … } /* * We need to reserve the new number of endpoints before the configure endpoint * command completes. We can't subtract the dropped endpoints from the number * of active endpoints until the command completes because we can oversubscribe * the host in this case: * * - the first configure endpoint command drops more endpoints than it adds * - a second configure endpoint command that adds more endpoints is queued * - the first configure endpoint command fails, so the config is unchanged * - the second command may succeed, even though there isn't enough resources * * Must be called with xhci->lock held. */ static int xhci_reserve_host_resources(struct xhci_hcd *xhci, struct xhci_input_control_ctx *ctrl_ctx) { … } /* * The configure endpoint was failed by the xHC for some other reason, so we * need to revert the resources that failed configuration would have used. * * Must be called with xhci->lock held. */ static void xhci_free_host_resources(struct xhci_hcd *xhci, struct xhci_input_control_ctx *ctrl_ctx) { … } /* * Now that the command has completed, clean up the active endpoint count by * subtracting out the endpoints that were dropped (but not changed). * * Must be called with xhci->lock held. */ static void xhci_finish_resource_reservation(struct xhci_hcd *xhci, struct xhci_input_control_ctx *ctrl_ctx) { … } static unsigned int xhci_get_block_size(struct usb_device *udev) { … } static unsigned int xhci_get_largest_overhead(struct xhci_interval_bw *interval_bw) { … } /* If we are changing a LS/FS device under a HS hub, * make sure (if we are activating a new TT) that the HS bus has enough * bandwidth for this new TT. */ static int xhci_check_tt_bw_table(struct xhci_hcd *xhci, struct xhci_virt_device *virt_dev, int old_active_eps) { … } static int xhci_check_ss_bw(struct xhci_hcd *xhci, struct xhci_virt_device *virt_dev) { … } /* * This algorithm is a very conservative estimate of the worst-case scheduling * scenario for any one interval. The hardware dynamically schedules the * packets, so we can't tell which microframe could be the limiting factor in * the bandwidth scheduling. This only takes into account periodic endpoints. * * Obviously, we can't solve an NP complete problem to find the minimum worst * case scenario. Instead, we come up with an estimate that is no less than * the worst case bandwidth used for any one microframe, but may be an * over-estimate. * * We walk the requirements for each endpoint by interval, starting with the * smallest interval, and place packets in the schedule where there is only one * possible way to schedule packets for that interval. In order to simplify * this algorithm, we record the largest max packet size for each interval, and * assume all packets will be that size. * * For interval 0, we obviously must schedule all packets for each interval. * The bandwidth for interval 0 is just the amount of data to be transmitted * (the sum of all max ESIT payload sizes, plus any overhead per packet times * the number of packets). * * For interval 1, we have two possible microframes to schedule those packets * in. For this algorithm, if we can schedule the same number of packets for * each possible scheduling opportunity (each microframe), we will do so. The * remaining number of packets will be saved to be transmitted in the gaps in * the next interval's scheduling sequence. * * As we move those remaining packets to be scheduled with interval 2 packets, * we have to double the number of remaining packets to transmit. This is * because the intervals are actually powers of 2, and we would be transmitting * the previous interval's packets twice in this interval. We also have to be * sure that when we look at the largest max packet size for this interval, we * also look at the largest max packet size for the remaining packets and take * the greater of the two. * * The algorithm continues to evenly distribute packets in each scheduling * opportunity, and push the remaining packets out, until we get to the last * interval. Then those packets and their associated overhead are just added * to the bandwidth used. */ static int xhci_check_bw_table(struct xhci_hcd *xhci, struct xhci_virt_device *virt_dev, int old_active_eps) { … } static bool xhci_is_async_ep(unsigned int ep_type) { … } static bool xhci_is_sync_in_ep(unsigned int ep_type) { … } static unsigned int xhci_get_ss_bw_consumed(struct xhci_bw_info *ep_bw) { … } static void xhci_drop_ep_from_interval_table(struct xhci_hcd *xhci, struct xhci_bw_info *ep_bw, struct xhci_interval_bw_table *bw_table, struct usb_device *udev, struct xhci_virt_ep *virt_ep, struct xhci_tt_bw_info *tt_info) { … } static void xhci_add_ep_to_interval_table(struct xhci_hcd *xhci, struct xhci_bw_info *ep_bw, struct xhci_interval_bw_table *bw_table, struct usb_device *udev, struct xhci_virt_ep *virt_ep, struct xhci_tt_bw_info *tt_info) { … } void xhci_update_tt_active_eps(struct xhci_hcd *xhci, struct xhci_virt_device *virt_dev, int old_active_eps) { … } static int xhci_reserve_bandwidth(struct xhci_hcd *xhci, struct xhci_virt_device *virt_dev, struct xhci_container_ctx *in_ctx) { … } /* Issue a configure endpoint command or evaluate context command * and wait for it to finish. */ static int xhci_configure_endpoint(struct xhci_hcd *xhci, struct usb_device *udev, struct xhci_command *command, bool ctx_change, bool must_succeed) { … } static void xhci_check_bw_drop_ep_streams(struct xhci_hcd *xhci, struct xhci_virt_device *vdev, int i) { … } /* Called after one or more calls to xhci_add_endpoint() or * xhci_drop_endpoint(). If this call fails, the USB core is expected * to call xhci_reset_bandwidth(). * * Since we are in the middle of changing either configuration or * installing a new alt setting, the USB core won't allow URBs to be * enqueued for any endpoint on the old config or interface. Nothing * else should be touching the xhci->devs[slot_id] structure, so we * don't need to take the xhci->lock for manipulating that. */ int xhci_check_bandwidth(struct usb_hcd *hcd, struct usb_device *udev) { … } EXPORT_SYMBOL_GPL(…); void xhci_reset_bandwidth(struct usb_hcd *hcd, struct usb_device *udev) { … } EXPORT_SYMBOL_GPL(…); static void xhci_setup_input_ctx_for_config_ep(struct xhci_hcd *xhci, struct xhci_container_ctx *in_ctx, struct xhci_container_ctx *out_ctx, struct xhci_input_control_ctx *ctrl_ctx, u32 add_flags, u32 drop_flags) { … } static void xhci_endpoint_disable(struct usb_hcd *hcd, struct usb_host_endpoint *host_ep) { … } /* * Called after usb core issues a clear halt control message. * The host side of the halt should already be cleared by a reset endpoint * command issued when the STALL event was received. * * The reset endpoint command may only be issued to endpoints in the halted * state. For software that wishes to reset the data toggle or sequence number * of an endpoint that isn't in the halted state this function will issue a * configure endpoint command with the Drop and Add bits set for the target * endpoint. Refer to the additional note in xhci spcification section 4.6.8. * * vdev may be lost due to xHC restore error and re-initialization during S3/S4 * resume. A new vdev will be allocated later by xhci_discover_or_reset_device() */ static void xhci_endpoint_reset(struct usb_hcd *hcd, struct usb_host_endpoint *host_ep) { … } static int xhci_check_streams_endpoint(struct xhci_hcd *xhci, struct usb_device *udev, struct usb_host_endpoint *ep, unsigned int slot_id) { … } static void xhci_calculate_streams_entries(struct xhci_hcd *xhci, unsigned int *num_streams, unsigned int *num_stream_ctxs) { … } /* Returns an error code if one of the endpoint already has streams. * This does not change any data structures, it only checks and gathers * information. */ static int xhci_calculate_streams_and_bitmask(struct xhci_hcd *xhci, struct usb_device *udev, struct usb_host_endpoint **eps, unsigned int num_eps, unsigned int *num_streams, u32 *changed_ep_bitmask) { … } static u32 xhci_calculate_no_streams_bitmask(struct xhci_hcd *xhci, struct usb_device *udev, struct usb_host_endpoint **eps, unsigned int num_eps) { … } /* * The USB device drivers use this function (through the HCD interface in USB * core) to prepare a set of bulk endpoints to use streams. Streams are used to * coordinate mass storage command queueing across multiple endpoints (basically * a stream ID == a task ID). * * Setting up streams involves allocating the same size stream context array * for each endpoint and issuing a configure endpoint command for all endpoints. * * Don't allow the call to succeed if one endpoint only supports one stream * (which means it doesn't support streams at all). * * Drivers may get less stream IDs than they asked for, if the host controller * hardware or endpoints claim they can't support the number of requested * stream IDs. */ static int xhci_alloc_streams(struct usb_hcd *hcd, struct usb_device *udev, struct usb_host_endpoint **eps, unsigned int num_eps, unsigned int num_streams, gfp_t mem_flags) { … } /* Transition the endpoint from using streams to being a "normal" endpoint * without streams. * * Modify the endpoint context state, submit a configure endpoint command, * and free all endpoint rings for streams if that completes successfully. */ static int xhci_free_streams(struct usb_hcd *hcd, struct usb_device *udev, struct usb_host_endpoint **eps, unsigned int num_eps, gfp_t mem_flags) { … } /* * Deletes endpoint resources for endpoints that were active before a Reset * Device command, or a Disable Slot command. The Reset Device command leaves * the control endpoint intact, whereas the Disable Slot command deletes it. * * Must be called with xhci->lock held. */ void xhci_free_device_endpoint_resources(struct xhci_hcd *xhci, struct xhci_virt_device *virt_dev, bool drop_control_ep) { … } /* * This submits a Reset Device Command, which will set the device state to 0, * set the device address to 0, and disable all the endpoints except the default * control endpoint. The USB core should come back and call * xhci_address_device(), and then re-set up the configuration. If this is * called because of a usb_reset_and_verify_device(), then the old alternate * settings will be re-installed through the normal bandwidth allocation * functions. * * Wait for the Reset Device command to finish. Remove all structures * associated with the endpoints that were disabled. Clear the input device * structure? Reset the control endpoint 0 max packet size? * * If the virt_dev to be reset does not exist or does not match the udev, * it means the device is lost, possibly due to the xHC restore error and * re-initialization during S3/S4. In this case, call xhci_alloc_dev() to * re-allocate the device. */ static int xhci_discover_or_reset_device(struct usb_hcd *hcd, struct usb_device *udev) { … } /* * At this point, the struct usb_device is about to go away, the device has * disconnected, and all traffic has been stopped and the endpoints have been * disabled. Free any HC data structures associated with that device. */ static void xhci_free_dev(struct usb_hcd *hcd, struct usb_device *udev) { … } int xhci_disable_slot(struct xhci_hcd *xhci, u32 slot_id) { … } /* * Checks if we have enough host controller resources for the default control * endpoint. * * Must be called with xhci->lock held. */ static int xhci_reserve_host_control_ep_resources(struct xhci_hcd *xhci) { … } /* * Returns 0 if the xHC ran out of device slots, the Enable Slot command * timed out, or allocating memory failed. Returns 1 on success. */ int xhci_alloc_dev(struct usb_hcd *hcd, struct usb_device *udev) { … } /** * xhci_setup_device - issues an Address Device command to assign a unique * USB bus address. * @hcd: USB host controller data structure. * @udev: USB dev structure representing the connected device. * @setup: Enum specifying setup mode: address only or with context. * @timeout_ms: Max wait time (ms) for the command operation to complete. * * Return: 0 if successful; otherwise, negative error code. */ static int xhci_setup_device(struct usb_hcd *hcd, struct usb_device *udev, enum xhci_setup_dev setup, unsigned int timeout_ms) { … } static int xhci_address_device(struct usb_hcd *hcd, struct usb_device *udev, unsigned int timeout_ms) { … } static int xhci_enable_device(struct usb_hcd *hcd, struct usb_device *udev) { … } /* * Transfer the port index into real index in the HW port status * registers. Caculate offset between the port's PORTSC register * and port status base. Divide the number of per port register * to get the real index. The raw port number bases 1. */ int xhci_find_raw_port_number(struct usb_hcd *hcd, int port1) { … } /* * Issue an Evaluate Context command to change the Maximum Exit Latency in the * slot context. If that succeeds, store the new MEL in the xhci_virt_device. */ static int __maybe_unused xhci_change_max_exit_latency(struct xhci_hcd *xhci, struct usb_device *udev, u16 max_exit_latency) { … } #ifdef CONFIG_PM /* BESL to HIRD Encoding array for USB2 LPM */ static int xhci_besl_encoding[16] = …; /* Calculate HIRD/BESL for USB2 PORTPMSC*/ static int xhci_calculate_hird_besl(struct xhci_hcd *xhci, struct usb_device *udev) { … } /* Calculate BESLD, L1 timeout and HIRDM for USB2 PORTHLPMC */ static int xhci_calculate_usb2_hw_lpm_params(struct usb_device *udev) { … } static int xhci_set_usb2_hardware_lpm(struct usb_hcd *hcd, struct usb_device *udev, int enable) { … } static int xhci_update_device(struct usb_hcd *hcd, struct usb_device *udev) { … } /*---------------------- USB 3.0 Link PM functions ------------------------*/ /* Service interval in nanoseconds = 2^(bInterval - 1) * 125us * 1000ns / 1us */ static unsigned long long xhci_service_interval_to_ns( struct usb_endpoint_descriptor *desc) { … } static u16 xhci_get_timeout_no_hub_lpm(struct usb_device *udev, enum usb3_link_state state) { … } /* The U1 timeout should be the maximum of the following values: * - For control endpoints, U1 system exit latency (SEL) * 3 * - For bulk endpoints, U1 SEL * 5 * - For interrupt endpoints: * - Notification EPs, U1 SEL * 3 * - Periodic EPs, max(105% of bInterval, U1 SEL * 2) * - For isochronous endpoints, max(105% of bInterval, U1 SEL * 2) */ static unsigned long long xhci_calculate_intel_u1_timeout( struct usb_device *udev, struct usb_endpoint_descriptor *desc) { … } /* Returns the hub-encoded U1 timeout value. */ static u16 xhci_calculate_u1_timeout(struct xhci_hcd *xhci, struct usb_device *udev, struct usb_endpoint_descriptor *desc) { … } /* The U2 timeout should be the maximum of: * - 10 ms (to avoid the bandwidth impact on the scheduler) * - largest bInterval of any active periodic endpoint (to avoid going * into lower power link states between intervals). * - the U2 Exit Latency of the device */ static unsigned long long xhci_calculate_intel_u2_timeout( struct usb_device *udev, struct usb_endpoint_descriptor *desc) { … } /* Returns the hub-encoded U2 timeout value. */ static u16 xhci_calculate_u2_timeout(struct xhci_hcd *xhci, struct usb_device *udev, struct usb_endpoint_descriptor *desc) { … } static u16 xhci_call_host_update_timeout_for_endpoint(struct xhci_hcd *xhci, struct usb_device *udev, struct usb_endpoint_descriptor *desc, enum usb3_link_state state, u16 *timeout) { … } static int xhci_update_timeout_for_endpoint(struct xhci_hcd *xhci, struct usb_device *udev, struct usb_endpoint_descriptor *desc, enum usb3_link_state state, u16 *timeout) { … } static int xhci_update_timeout_for_interface(struct xhci_hcd *xhci, struct usb_device *udev, struct usb_host_interface *alt, enum usb3_link_state state, u16 *timeout) { … } static int xhci_check_tier_policy(struct xhci_hcd *xhci, struct usb_device *udev, enum usb3_link_state state) { … } /* Returns the U1 or U2 timeout that should be enabled. * If the tier check or timeout setting functions return with a non-zero exit * code, that means the timeout value has been finalized and we shouldn't look * at any more endpoints. */ static u16 xhci_calculate_lpm_timeout(struct usb_hcd *hcd, struct usb_device *udev, enum usb3_link_state state) { … } static int calculate_max_exit_latency(struct usb_device *udev, enum usb3_link_state state_changed, u16 hub_encoded_timeout) { … } /* Returns the USB3 hub-encoded value for the U1/U2 timeout. */ static int xhci_enable_usb3_lpm_timeout(struct usb_hcd *hcd, struct usb_device *udev, enum usb3_link_state state) { … } static int xhci_disable_usb3_lpm_timeout(struct usb_hcd *hcd, struct usb_device *udev, enum usb3_link_state state) { … } #else /* CONFIG_PM */ static int xhci_set_usb2_hardware_lpm(struct usb_hcd *hcd, struct usb_device *udev, int enable) { return 0; } static int xhci_update_device(struct usb_hcd *hcd, struct usb_device *udev) { return 0; } static int xhci_enable_usb3_lpm_timeout(struct usb_hcd *hcd, struct usb_device *udev, enum usb3_link_state state) { return USB3_LPM_DISABLED; } static int xhci_disable_usb3_lpm_timeout(struct usb_hcd *hcd, struct usb_device *udev, enum usb3_link_state state) { return 0; } #endif /* CONFIG_PM */ /*-------------------------------------------------------------------------*/ /* Once a hub descriptor is fetched for a device, we need to update the xHC's * internal data structures for the device. */ int xhci_update_hub_device(struct usb_hcd *hcd, struct usb_device *hdev, struct usb_tt *tt, gfp_t mem_flags) { … } EXPORT_SYMBOL_GPL(…); static int xhci_get_frame(struct usb_hcd *hcd) { … } static void xhci_hcd_init_usb2_data(struct xhci_hcd *xhci, struct usb_hcd *hcd) { … } static void xhci_hcd_init_usb3_data(struct xhci_hcd *xhci, struct usb_hcd *hcd) { … } int xhci_gen_setup(struct usb_hcd *hcd, xhci_get_quirks_t get_quirks) { … } EXPORT_SYMBOL_GPL(…); static void xhci_clear_tt_buffer_complete(struct usb_hcd *hcd, struct usb_host_endpoint *ep) { … } static const struct hc_driver xhci_hc_driver = …; void xhci_init_driver(struct hc_driver *drv, const struct xhci_driver_overrides *over) { … } EXPORT_SYMBOL_GPL(…); MODULE_DESCRIPTION(…); MODULE_AUTHOR(…); MODULE_LICENSE(…) …; static int __init xhci_hcd_init(void) { … } /* * If an init function is provided, an exit function must also be provided * to allow module unload. */ static void __exit xhci_hcd_fini(void) { … } module_init(…) …; module_exit(xhci_hcd_fini);
Codebase Browser
linux