自学教程：C++ xhci_get_ports函数代码示例

void xhci_hub_power_port(struct usb_hcd *hcd,		int port, bool onoff){	struct xhci_hcd	*xhci = hcd_to_xhci(hcd);	__le32 __iomem **port_array;	int max_ports;	u32 temp;	max_ports = xhci_get_ports(hcd, &port_array);	if (!port || port > max_ports)		return;	port--;	temp = xhci_readl(xhci, port_array[port]);	if (temp == 0xffffffff)		return;	temp = etxhci_port_state_to_neutral(temp);	if (onoff)		temp |= PORT_POWER;	else		temp &= ~PORT_POWER;	xhci_writel(xhci, temp, port_array[port]);	temp = xhci_readl(xhci, port_array[port]);	xhci_dbg(xhci, "power %s port, actual port %p status  = 0x%x/n",			(onoff) ? "on" : "off", port_array[port], temp);}

static __le32 __iomem *xhci_get_port_io_addr(struct usb_hcd *hcd, int index){	__le32 __iomem **port_array;	xhci_get_ports(hcd, &port_array);	return port_array[index];}

/* * Returns 0 if the status hasn't changed, or the number of bytes in buf. * Ports are 0-indexed from the HCD point of view, * and 1-indexed from the USB core pointer of view. * * Note that the status change bits will be cleared as soon as a port status * change event is generated, so we use the saved status from that event. */int xhci_hub_status_data(struct usb_hcd *hcd, char *buf){	unsigned long flags;	u32 temp, status;	u32 mask;	int i, retval;	struct xhci_hcd	*xhci;	int max_ports;	__le32 __iomem **port_array;	struct xhci_bus_state *bus_state;	bool reset_change = false;	if (!hcd) {		pr_err("xhci_hub_status_data: hcd is null/n");		return -ENODEV;	}	xhci = hcd_to_xhci(hcd);	max_ports = xhci_get_ports(hcd, &port_array);	bus_state = &xhci->bus_state[hcd_index(hcd)];	/* Initial status is no changes */	retval = (max_ports + 8) / 8;	memset(buf, 0, retval);	/*	 * Inform the usbcore about resume-in-progress by returning	 * a non-zero value even if there are no status changes.	 */	status = bus_state->resuming_ports;	mask = PORT_CSC | PORT_PEC | PORT_OCC | PORT_PLC | PORT_WRC;	spin_lock_irqsave(&xhci->lock, flags);	/* For each port, did anything change?  If so, set that bit in buf. */	for (i = 0; i < max_ports; i++) {		temp = xhci_readl(xhci, port_array[i]);		if (temp == 0xffffffff) {			retval = -ENODEV;			break;		}		if ((temp & mask) != 0 ||			(bus_state->port_c_suspend & 1 << i) ||			(bus_state->resume_done[i] && time_after_eq(			    jiffies, bus_state->resume_done[i]))) {			buf[(i + 1) / 8] |= 1 << (i + 1) % 8;			status = 1;		}		if ((temp & PORT_RC))			reset_change = true;	}	if (!status && !reset_change) {		xhci_dbg(xhci, "%s: stopping port polling./n", __func__);		clear_bit(HCD_FLAG_POLL_RH, &hcd->flags);	}	spin_unlock_irqrestore(&xhci->lock, flags);	return status ? retval : 0;}

/* * Returns 0 if the status hasn't changed, or the number of bytes in buf. * Ports are 0-indexed from the HCD point of view, * and 1-indexed from the USB core pointer of view. * * Note that the status change bits will be cleared as soon as a port status * change event is generated, so we use the saved status from that event. */int etxhci_hub_status_data(struct usb_hcd *hcd, char *buf){	unsigned long flags;	u32 temp, status;	u32 mask;	int i, retval;	struct xhci_hcd	*xhci = hcd_to_xhci(hcd);	int max_ports;	__le32 __iomem **port_array;	struct xhci_bus_state *bus_state;	max_ports = xhci_get_ports(hcd, &port_array);	bus_state = &xhci->bus_state[hcd_index(hcd)];	/* Initial status is no changes */	retval = (max_ports + 8) / 8;	memset(buf, 0, retval);	/*	 * Inform the usbcore about resume-in-progress by returning	 * a non-zero value even if there are no status changes.	 */	status = bus_state->resuming_ports;	mask = PORT_CSC | PORT_PEC | PORT_OCC | PORT_PLC | PORT_WRC | PORT_CEC;	spin_lock_irqsave(&xhci->lock, flags);	/* For each port, did anything change?  If so, set that bit in buf. */	for (i = 0; i < max_ports; i++) {		temp = xhci_readl(xhci, port_array[i]);		if (temp == 0xffffffff) {			retval = -ENODEV;			break;		}		if ((temp & mask) != 0 ||			(bus_state->port_c_connection & 1 << i) ||			(bus_state->port_c_suspend & 1 << i) ||			(bus_state->resume_done[i] && time_after_eq(			    jiffies, bus_state->resume_done[i]))) {			buf[(i + 1) / 8] |= 1 << (i + 1) % 8;			status = 1;		}	}	spin_unlock_irqrestore(&xhci->lock, flags);	return status ? retval : 0;}

int xhci_bus_suspend(struct usb_hcd *hcd){	struct xhci_hcd	*xhci = hcd_to_xhci(hcd);	int max_ports, port_index;	__le32 __iomem **port_array;	struct xhci_bus_state *bus_state;	unsigned long flags;	max_ports = xhci_get_ports(hcd, &port_array);	bus_state = &xhci->bus_state[hcd_index(hcd)];	spin_lock_irqsave(&xhci->lock, flags);	if (hcd->self.root_hub->do_remote_wakeup) {		port_index = max_ports;		while (port_index--) {			if (bus_state->resume_done[port_index] != 0) {				spin_unlock_irqrestore(&xhci->lock, flags);				xhci_dbg(xhci, "suspend failed because "						"port %d is resuming/n",						port_index + 1);				return -EBUSY;			}		}	}	port_index = max_ports;	bus_state->bus_suspended = 0;	while (port_index--) {		/* suspend the port if the port is not suspended */		u32 t1, t2;		int slot_id;		t1 = xhci_readl(xhci, port_array[port_index]);		t2 = xhci_port_state_to_neutral(t1);		if ((t1 & PORT_PE) && !(t1 & PORT_PLS_MASK)) {			xhci_dbg(xhci, "port %d not suspended/n", port_index);			slot_id = xhci_find_slot_id_by_port(hcd, xhci,					port_index + 1);			if (slot_id) {				spin_unlock_irqrestore(&xhci->lock, flags);				xhci_stop_device(xhci, slot_id, 1);				spin_lock_irqsave(&xhci->lock, flags);			}			t2 &= ~PORT_PLS_MASK;			t2 |= PORT_LINK_STROBE | XDEV_U3;			set_bit(port_index, &bus_state->bus_suspended);		}		if (hcd->self.root_hub->do_remote_wakeup) {			if (t1 & PORT_CONNECT) {				t2 |= PORT_WKOC_E | PORT_WKDISC_E;				t2 &= ~PORT_WKCONN_E;			} else {				t2 |= PORT_WKOC_E | PORT_WKCONN_E;				t2 &= ~PORT_WKDISC_E;			}		} else			t2 &= ~PORT_WAKE_BITS;		t1 = xhci_port_state_to_neutral(t1);		if (t1 != t2)			xhci_writel(xhci, t2, port_array[port_index]);		if (hcd->speed != HCD_USB3) {			/* enable remote wake up for USB 2.0 */			__le32 __iomem *addr;			u32 tmp;			/* Add one to the port status register address to get			 * the port power control register address.			 */			addr = port_array[port_index] + 1;			tmp = xhci_readl(xhci, addr);			tmp |= PORT_RWE;			xhci_writel(xhci, tmp, addr);		}	}	hcd->state = HC_STATE_SUSPENDED;	bus_state->next_statechange = jiffies + msecs_to_jiffies(10);	spin_unlock_irqrestore(&xhci->lock, flags);	return 0;}

int xhci_hub_control(struct usb_hcd *hcd, u16 typeReq, u16 wValue,		u16 wIndex, char *buf, u16 wLength){	struct xhci_hcd	*xhci = hcd_to_xhci(hcd);	int max_ports;	unsigned long flags;	u32 temp, status;	int retval = 0;	__le32 __iomem **port_array;	int slot_id;	struct xhci_bus_state *bus_state;	u16 link_state = 0;	u16 wake_mask = 0;	u32 __iomem *status_reg = NULL;	u32 i, command, num_ports, selector;	max_ports = xhci_get_ports(hcd, &port_array);	bus_state = &xhci->bus_state[hcd_index(hcd)];	spin_lock_irqsave(&xhci->lock, flags);	switch (typeReq) {	case GetHubStatus:		/* No power source, over-current reported per port */		memset(buf, 0, 4);		break;	case GetHubDescriptor:		/* Check to make sure userspace is asking for the USB 3.0 hub		 * descriptor for the USB 3.0 roothub.  If not, we stall the		 * endpoint, like external hubs do.		 */		if (hcd->speed == HCD_USB3 &&				(wLength < USB_DT_SS_HUB_SIZE ||				 wValue != (USB_DT_SS_HUB << 8))) {			xhci_dbg(xhci, "Wrong hub descriptor type for "					"USB 3.0 roothub./n");			goto error;		}		xhci_hub_descriptor(hcd, xhci,				(struct usb_hub_descriptor *) buf);		break;	case DeviceRequest | USB_REQ_GET_DESCRIPTOR:		if ((wValue & 0xff00) != (USB_DT_BOS << 8))			goto error;		if (hcd->speed != HCD_USB3)			goto error;		memcpy(buf, &usb_bos_descriptor,				USB_DT_BOS_SIZE + USB_DT_USB_SS_CAP_SIZE);		temp = xhci_readl(xhci, &xhci->cap_regs->hcs_params3);		buf[12] = HCS_U1_LATENCY(temp);		put_unaligned_le16(HCS_U2_LATENCY(temp), &buf[13]);		spin_unlock_irqrestore(&xhci->lock, flags);		return USB_DT_BOS_SIZE + USB_DT_USB_SS_CAP_SIZE;	case GetPortStatus:		if (!wIndex || wIndex > max_ports)			goto error;		wIndex--;		status = 0;		temp = xhci_readl(xhci, port_array[wIndex]);		if (temp == 0xffffffff) {			retval = -ENODEV;			break;		}		xhci_dbg(xhci, "get port status, actual port %d status  = 0x%x/n", wIndex, temp);		/* wPortChange bits */		if (temp & PORT_CSC)			status |= USB_PORT_STAT_C_CONNECTION << 16;		if (temp & PORT_PEC)			status |= USB_PORT_STAT_C_ENABLE << 16;		if ((temp & PORT_OCC))			status |= USB_PORT_STAT_C_OVERCURRENT << 16;		if ((temp & PORT_RC))			status |= USB_PORT_STAT_C_RESET << 16;		/* USB3.0 only */		if (hcd->speed == HCD_USB3) {			if ((temp & PORT_PLC))				status |= USB_PORT_STAT_C_LINK_STATE << 16;			if ((temp & PORT_WRC))				status |= USB_PORT_STAT_C_BH_RESET << 16;		}		if (hcd->speed != HCD_USB3) {			if ((temp & PORT_PLS_MASK) == XDEV_U3					&& (temp & PORT_POWER))				status |= USB_PORT_STAT_SUSPEND;		}		if ((temp & PORT_PLS_MASK) == XDEV_RESUME &&				!DEV_SUPERSPEED(temp)) {			if ((temp & PORT_RESET) || !(temp & PORT_PE))				goto error;			if (time_after_eq(jiffies,					bus_state->resume_done[wIndex])) {				xhci_dbg(xhci, "Resume USB2 port %d/n",					wIndex + 1);				bus_state->resume_done[wIndex] = 0;//.........这里部分代码省略.........

int xhci_bus_resume(struct usb_hcd *hcd){	struct xhci_hcd	*xhci = hcd_to_xhci(hcd);	int max_ports, port_index;	__le32 __iomem **port_array;	struct xhci_bus_state *bus_state;	u32 temp;	unsigned long flags;	max_ports = xhci_get_ports(hcd, &port_array);	bus_state = &xhci->bus_state[hcd_index(hcd)];	if (time_before(jiffies, bus_state->next_statechange))		msleep(5);	spin_lock_irqsave(&xhci->lock, flags);	if (!HCD_HW_ACCESSIBLE(hcd)) {		spin_unlock_irqrestore(&xhci->lock, flags);		return -ESHUTDOWN;	}	/* delay the irqs */	temp = xhci_readl(xhci, &xhci->op_regs->command);	temp &= ~CMD_EIE;	xhci_writel(xhci, temp, &xhci->op_regs->command);	port_index = max_ports;	while (port_index--) {		/* Check whether need resume ports. If needed		   resume port and disable remote wakeup */		u32 temp;		int slot_id;		temp = xhci_readl(xhci, port_array[port_index]);		if (DEV_SUPERSPEED(temp))			temp &= ~(PORT_RWC_BITS | PORT_CEC | PORT_WAKE_BITS);		else			temp &= ~(PORT_RWC_BITS | PORT_WAKE_BITS);		if (test_bit(port_index, &bus_state->bus_suspended) &&		    (temp & PORT_PLS_MASK)) {			if (DEV_SUPERSPEED(temp)) {				temp = xhci_port_state_to_neutral(temp);				temp &= ~PORT_PLS_MASK;				temp |= PORT_LINK_STROBE | XDEV_U0;				xhci_writel(xhci, temp, port_array[port_index]);			} else {				temp = xhci_port_state_to_neutral(temp);				temp &= ~PORT_PLS_MASK;				temp |= PORT_LINK_STROBE | XDEV_RESUME;				xhci_writel(xhci, temp, port_array[port_index]);				spin_unlock_irqrestore(&xhci->lock, flags);				msleep(20);				spin_lock_irqsave(&xhci->lock, flags);				temp = xhci_readl(xhci, port_array[port_index]);				temp = xhci_port_state_to_neutral(temp);				temp &= ~PORT_PLS_MASK;				temp |= PORT_LINK_STROBE | XDEV_U0;				xhci_writel(xhci, temp, port_array[port_index]);			}			/* wait for the port to enter U0 and report port link			 * state change.			 */			spin_unlock_irqrestore(&xhci->lock, flags);			msleep(20);			spin_lock_irqsave(&xhci->lock, flags);			/* Clear PLC */			xhci_test_and_clear_bit(xhci, port_array, port_index,						PORT_PLC);			slot_id = xhci_find_slot_id_by_port(hcd,					xhci, port_index + 1);			if (slot_id)				xhci_ring_device(xhci, slot_id);		} else			xhci_writel(xhci, temp, port_array[port_index]);		if (hcd->speed != HCD_USB3) {			/* disable remote wake up for USB 2.0 */			__le32 __iomem *addr;			u32 tmp;			/* Add one to the port status register address to get			 * the port power control register address.			 */			addr = port_array[port_index] + 1;			tmp = xhci_readl(xhci, addr);			tmp &= ~PORT_RWE;			xhci_writel(xhci, tmp, addr);		}	}	(void) xhci_readl(xhci, &xhci->op_regs->command);	bus_state->next_statechange = jiffies + msecs_to_jiffies(5);	/* re-enable irqs */	temp = xhci_readl(xhci, &xhci->op_regs->command);	temp |= CMD_EIE;//.........这里部分代码省略.........

int xhci_bus_suspend(struct usb_hcd *hcd){	struct xhci_hcd	*xhci = hcd_to_xhci(hcd);	int max_ports, port_index;	__le32 __iomem **port_array;	struct xhci_bus_state *bus_state;	unsigned long flags;	max_ports = xhci_get_ports(hcd, &port_array);	bus_state = &xhci->bus_state[hcd_index(hcd)];	spin_lock_irqsave(&xhci->lock, flags);	if (hcd->self.root_hub->do_remote_wakeup) {		if (bus_state->resuming_ports) {			spin_unlock_irqrestore(&xhci->lock, flags);			xhci_dbg(xhci, "suspend failed because "						"a port is resuming/n");			return -EBUSY;		}	}	port_index = max_ports;	bus_state->bus_suspended = 0;	while (port_index--) {		/* suspend the port if the port is not suspended */		u32 t1, t2;		int slot_id;		t1 = xhci_readl(xhci, port_array[port_index]);		t2 = xhci_port_state_to_neutral(t1);		if ((t1 & PORT_PE) && !(t1 & PORT_PLS_MASK)) {			xhci_dbg(xhci, "port %d not suspended/n", port_index);			slot_id = xhci_find_slot_id_by_port(hcd, xhci,					port_index + 1);			if (slot_id) {				spin_unlock_irqrestore(&xhci->lock, flags);				xhci_stop_device(xhci, slot_id, 1);				spin_lock_irqsave(&xhci->lock, flags);			}			t2 &= ~PORT_PLS_MASK;			t2 |= PORT_LINK_STROBE | XDEV_U3;			set_bit(port_index, &bus_state->bus_suspended);		}		/* USB core sets remote wake mask for USB 3.0 hubs,		 * including the USB 3.0 roothub, but only if CONFIG_USB_SUSPEND		 * is enabled, so also enable remote wake here.		 */		if (hcd->self.root_hub->do_remote_wakeup) {			if (t1 & PORT_CONNECT) {				t2 |= PORT_WKOC_E | PORT_WKDISC_E;				t2 &= ~PORT_WKCONN_E;			} else {				t2 |= PORT_WKOC_E | PORT_WKCONN_E;				t2 &= ~PORT_WKDISC_E;			}		} else			t2 &= ~PORT_WAKE_BITS;		t1 = xhci_port_state_to_neutral(t1);		if (t1 != t2) {			xhci_writel(xhci, t2, port_array[port_index]);	}	hcd->state = HC_STATE_SUSPENDED;	bus_state->next_statechange = jiffies + msecs_to_jiffies(10);	spin_unlock_irqrestore(&xhci->lock, flags);	return 0;}int xhci_bus_resume(struct usb_hcd *hcd){	struct xhci_hcd	*xhci = hcd_to_xhci(hcd);	int max_ports, port_index;	__le32 __iomem **port_array;	struct xhci_bus_state *bus_state;	u32 temp;	unsigned long flags;	max_ports = xhci_get_ports(hcd, &port_array);	bus_state = &xhci->bus_state[hcd_index(hcd)];	if (time_before(jiffies, bus_state->next_statechange))		msleep(5);	spin_lock_irqsave(&xhci->lock, flags);	if (!HCD_HW_ACCESSIBLE(hcd)) {		spin_unlock_irqrestore(&xhci->lock, flags);		return -ESHUTDOWN;	}	/* delay the irqs */	temp = xhci_readl(xhci, &xhci->op_regs->command);	temp &= ~CMD_EIE;	xhci_writel(xhci, temp, &xhci->op_regs->command);	port_index = max_ports;	while (port_index--) {		/* Check whether need resume ports. If needed		   resume port and disable remote wakeup *///.........这里部分代码省略.........

int xhci_hub_control(struct usb_hcd *hcd, u16 typeReq, u16 wValue,		u16 wIndex, char *buf, u16 wLength){	struct xhci_hcd	*xhci = hcd_to_xhci(hcd);	int max_ports, max_portpmsc;	unsigned long flags;	u32 temp, status;	int retval = 0;	__le32 __iomem **port_array;	__le32 __iomem **portpmsc_array;	int slot_id;	struct xhci_bus_state *bus_state;	u16 link_state = 0;	u16 wake_mask = 0;	u8 selector;	max_ports = xhci_get_ports(hcd, &port_array);	max_portpmsc = xhci_get_portpmsc(hcd, &portpmsc_array);	bus_state = &xhci->bus_state[hcd_index(hcd)];	spin_lock_irqsave(&xhci->lock, flags);	switch (typeReq) {	case GetHubStatus:		/* No power source, over-current reported per port */		memset(buf, 0, 4);		break;	case GetHubDescriptor:		/* Check to make sure userspace is asking for the USB 3.0 hub		 * descriptor for the USB 3.0 roothub.  If not, we stall the		 * endpoint, like external hubs do.		 */		if (hcd->speed == HCD_USB3 &&				(wLength < USB_DT_SS_HUB_SIZE ||				 wValue != (USB_DT_SS_HUB << 8))) {			xhci_dbg(xhci, "Wrong hub descriptor type for "					"USB 3.0 roothub./n");			goto error;		}		xhci_hub_descriptor(hcd, xhci,				(struct usb_hub_descriptor *) buf);		break;	case DeviceRequest | USB_REQ_GET_DESCRIPTOR:		if ((wValue & 0xff00) != (USB_DT_BOS << 8))			goto error;		if (hcd->speed != HCD_USB3)			goto error;		memcpy(buf, &usb_bos_descriptor,				USB_DT_BOS_SIZE + USB_DT_USB_SS_CAP_SIZE);		temp = xhci_readl(xhci, &xhci->cap_regs->hcs_params3);		buf[12] = HCS_U1_LATENCY(temp);		put_unaligned_le16(HCS_U2_LATENCY(temp), &buf[13]);		spin_unlock_irqrestore(&xhci->lock, flags);		return USB_DT_BOS_SIZE + USB_DT_USB_SS_CAP_SIZE;	case GetPortStatus:		if (!wIndex || wIndex > max_ports)			goto error;		wIndex--;		status = 0;		temp = xhci_readl(xhci, port_array[wIndex]);		if (temp == 0xffffffff) {			retval = -ENODEV;			break;		}		xhci_dbg(xhci, "get port status, actual port %d status  = 0x%x/n", wIndex, temp);		/* wPortChange bits */		if (temp & PORT_CSC)			status |= USB_PORT_STAT_C_CONNECTION << 16;		if (temp & PORT_PEC)			status |= USB_PORT_STAT_C_ENABLE << 16;		if ((temp & PORT_OCC))			status |= USB_PORT_STAT_C_OVERCURRENT << 16;		if ((temp & PORT_RC))			status |= USB_PORT_STAT_C_RESET << 16;		/* USB3.0 only */		if (hcd->speed == HCD_USB3) {			if ((temp & PORT_PLC))				status |= USB_PORT_STAT_C_LINK_STATE << 16;			if ((temp & PORT_WRC))				status |= USB_PORT_STAT_C_BH_RESET << 16;			if ((temp & PORT_CEC))				status |= USB_PORT_STAT_C_CONFIG_ERROR << 16;		}		if (hcd->speed != HCD_USB3) {			if ((temp & PORT_PLS_MASK) == XDEV_U3					&& (temp & PORT_POWER))				status |= USB_PORT_STAT_SUSPEND;		}		if ((temp & PORT_PLS_MASK) == XDEV_RESUME &&				!DEV_SUPERSPEED(temp)) {			if ((temp & PORT_RESET) || !(temp & PORT_PE))				goto error;			if (time_after_eq(jiffies,					bus_state->resume_done[wIndex])) {				xhci_dbg(xhci, "Resume USB2 port %d/n",					wIndex + 1);//.........这里部分代码省略.........

int xhci_bus_resume(struct usb_hcd *hcd){	struct xhci_hcd	*xhci = hcd_to_xhci(hcd);	int max_ports, port_index;	__le32 __iomem **port_array;	struct xhci_bus_state *bus_state;	u32 temp;	unsigned long flags;	max_ports = xhci_get_ports(hcd, &port_array);	bus_state = &xhci->bus_state[hcd_index(hcd)];	if (time_before(jiffies, bus_state->next_statechange))		msleep(5);	spin_lock_irqsave(&xhci->lock, flags);	if (!HCD_HW_ACCESSIBLE(hcd)) {		spin_unlock_irqrestore(&xhci->lock, flags);		return -ESHUTDOWN;	}	/* delay the irqs */	temp = xhci_readl(xhci, &xhci->op_regs->command);	temp &= ~CMD_EIE;	xhci_writel(xhci, temp, &xhci->op_regs->command);	port_index = max_ports;	while (port_index--) {		/* Check whether need resume ports. If needed		   resume port and disable remote wakeup */		u32 temp;		int slot_id;		temp = xhci_readl(xhci, port_array[port_index]);		if (DEV_SUPERSPEED(temp))			temp &= ~(PORT_RWC_BITS | PORT_CEC | PORT_WAKE_BITS);		else			temp &= ~(PORT_RWC_BITS | PORT_WAKE_BITS);		if (test_bit(port_index, &bus_state->bus_suspended) &&		    (temp & PORT_PLS_MASK)) {			if (DEV_SUPERSPEED(temp)) {				xhci_set_link_state(xhci, port_array,							port_index, XDEV_U0);			} else {				xhci_set_link_state(xhci, port_array,						port_index, XDEV_RESUME);				/* need 1ms delay between access to USB2 PORTSC				 * and USB3 PORTSC to avoid Fabric Error.				 * */				mdelay(1);				spin_unlock_irqrestore(&xhci->lock, flags);				msleep(20);				spin_lock_irqsave(&xhci->lock, flags);				xhci_set_link_state(xhci, port_array,							port_index, XDEV_U0);			}			/* wait for the port to enter U0 and report port link			 * state change.			 */			spin_unlock_irqrestore(&xhci->lock, flags);			msleep(20);			spin_lock_irqsave(&xhci->lock, flags);			/* Clear PLC */			xhci_test_and_clear_bit(xhci, port_array, port_index,						PORT_PLC);			slot_id = xhci_find_slot_id_by_port(hcd,					xhci, port_index + 1);			if (slot_id)				xhci_ring_device(xhci, slot_id);		} else			xhci_writel(xhci, temp, port_array[port_index]);	}	(void) xhci_readl(xhci, &xhci->op_regs->command);	/* This is for wakeup IRQ case. For USB3 remote wakeup for S3 case,	 * the wakeup IRQ get immediately which before HCD set accessiable.	 * So the IRQ be disabled in usb_hcd_irq. For S3 case, after bus	 * resume done, the kernel will call their children directly. This	 * will cause children driver resume called before hcd_resume_work.	 *	 * The USB device corresponding port only be resume to U0/Enabled	 * state during xhci driver handle port change event. So this gap	 * will cause port haven't resumed when matched usb driver resume	 * callback be called. It will cause usb core try to disconnect the	 * usb device and cause some unexpected behavior.	 *	 * So we need to enable IRQ immediately at the end of bus_resume to	 * prevent above gap.	 **/	if (HCD_IRQ_DISABLED(hcd) && hcd->has_wakeup_irq) {		clear_bit(HCD_FLAG_IRQ_DISABLED, &hcd->flags);		enable_irq(hcd->irq);	}	bus_state->next_statechange = jiffies + msecs_to_jiffies(5);//.........这里部分代码省略.........

int xhci_downgrade_to_usb2(struct usb_hcd *hcd,		struct usb_device *udev){	struct xhci_hcd	*xhci = hcd_to_xhci(hcd);	__le32 __iomem **port_array;	struct xhci_bus_state *bus_state;	unsigned long flags;	int max_ports, slot_id, ret = -ENODEV;	u32 portsc;	switch(udev->descriptor.idVendor) {	case cpu_to_le16(0x1759):		if (udev->descriptor.idProduct == cpu_to_le16(0x5100))			goto err_done;		else			break;	case cpu_to_le16(0x054c):		if (udev->descriptor.idProduct == cpu_to_le16(0x05bf))			goto err_done;		else			break;	default:		break;	}	if (!(udev->parent && !udev->parent->parent))		goto err_done;	if (udev->speed != USB_SPEED_SUPER)		goto err_done;	if (udev->state == USB_STATE_NOTATTACHED)		goto err_done;	slot_id = etxhci_find_slot_id_by_port(hcd, xhci,					udev->portnum);	if(!(xhci_is_mass_storage_device(xhci, slot_id)))		goto err_done;	bus_state = &xhci->bus_state[hcd_index(hcd)];	max_ports = xhci_get_ports(hcd, &port_array);	if (udev->portnum > max_ports)		goto err_done;	spin_lock_irqsave(&xhci->lock, flags);	portsc = xhci_readl(xhci, port_array[udev->portnum - 1]);	if (portsc == 0xffffffff) {		spin_unlock_irqrestore(&xhci->lock, flags);		goto err_done;	}	if (!(portsc & 0x080) &&		(bus_state->downgraded_ports & (1 << (udev->portnum - 1)))) {		xhci_hub_power_port(hcd, udev->portnum, false);		xhci_hub_power_port(hcd->shared_hcd, udev->portnum, false);		spin_unlock_irqrestore(&xhci->lock, flags);		msleep(500);		spin_lock_irqsave(&xhci->lock, flags);		xhci_hub_power_port(hcd->shared_hcd, udev->portnum, true);		bus_state->port_c_connection |= 1 << (udev->portnum - 1);		ret = 0;		spin_unlock_irqrestore(&xhci->lock, flags);		msleep(500);		usb_hcd_poll_rh_status(hcd);		spin_lock_irqsave(&xhci->lock, flags);	}	spin_unlock_irqrestore(&xhci->lock, flags);err_done:	return ret;}

int xhci_bus_resume(struct usb_hcd *hcd){	struct xhci_hcd	*xhci = hcd_to_xhci(hcd);	int max_ports, port_index;	__le32 __iomem **port_array;	struct xhci_bus_state *bus_state;	u32 temp;	unsigned long flags;	max_ports = xhci_get_ports(hcd, &port_array);	bus_state = &xhci->bus_state[hcd_index(hcd)];	if (time_before_eq(jiffies, bus_state->next_statechange))		usleep_range(10000, 11000);	spin_lock_irqsave(&xhci->lock, flags);	if (!HCD_HW_ACCESSIBLE(hcd)) {		spin_unlock_irqrestore(&xhci->lock, flags);		return -ESHUTDOWN;	}	/* delay the irqs */	temp = xhci_readl(xhci, &xhci->op_regs->command);	temp &= ~CMD_EIE;	xhci_writel(xhci, temp, &xhci->op_regs->command);	if ((xhci->quirks & XHCI_RESET_RS_ON_RESUME_QUIRK) &&			HC_IS_SUSPENDED(xhci->main_hcd->state) &&				HC_IS_SUSPENDED(xhci->shared_hcd->state)) {		xhci_halt(xhci);		if (!xhci_start(xhci))			xhci->cmd_ring_state = CMD_RING_STATE_RUNNING;	}	port_index = max_ports;	while (port_index--) {		/* Check whether need resume ports. If needed		   resume port and disable remote wakeup */		u32 temp;		int slot_id;		temp = xhci_readl(xhci, port_array[port_index]);		if (DEV_SUPERSPEED(temp))			temp &= ~(PORT_RWC_BITS | PORT_CEC | PORT_WAKE_BITS);		else			temp &= ~(PORT_RWC_BITS | PORT_WAKE_BITS);		if (test_bit(port_index, &bus_state->bus_suspended) &&		    (temp & PORT_PLS_MASK)) {			if (DEV_SUPERSPEED(temp)) {				xhci_set_link_state(xhci, port_array,							port_index, XDEV_U0);			} else {				xhci_set_link_state(xhci, port_array,						port_index, XDEV_RESUME);				spin_unlock_irqrestore(&xhci->lock, flags);				usleep_range(20000, 21000);				spin_lock_irqsave(&xhci->lock, flags);				xhci_set_link_state(xhci, port_array,							port_index, XDEV_U0);			}			/* wait for the port to enter U0 and report port link			 * state change.			 */			spin_unlock_irqrestore(&xhci->lock, flags);			usleep_range(20000, 21000);			spin_lock_irqsave(&xhci->lock, flags);			/* Clear PLC */			xhci_test_and_clear_bit(xhci, port_array, port_index,						PORT_PLC);			slot_id = xhci_find_slot_id_by_port(hcd,					xhci, port_index + 1);			if (slot_id)				xhci_ring_device(xhci, slot_id);		} else {			xhci_writel(xhci, temp, port_array[port_index]);			if (xhci->quirks & XHCI_PORTSC_DELAY)				ndelay(100);		}		if (hcd->speed != HCD_USB3) {			/* disable remote wake up for USB 2.0 */			__le32 __iomem *addr;			u32 tmp;			/* Add one to the port status register address to get			 * the port power control register address.			 */			addr = port_array[port_index] + 1;			tmp = xhci_readl(xhci, addr);			tmp &= ~PORT_RWE;			xhci_writel(xhci, tmp, addr);			if (xhci->quirks & XHCI_PORTSC_DELAY)				ndelay(100);		}	}//.........这里部分代码省略.........

int xhci_bus_suspend(struct usb_hcd *hcd){	struct xhci_hcd	*xhci = hcd_to_xhci(hcd);	int max_ports, port_index;	__le32 __iomem **port_array;	struct xhci_bus_state *bus_state;	unsigned long flags;	max_ports = xhci_get_ports(hcd, &port_array);	bus_state = &xhci->bus_state[hcd_index(hcd)];	if (time_before_eq(jiffies, bus_state->next_statechange))		usleep_range(10000, 11000);	spin_lock_irqsave(&xhci->lock, flags);	if (hcd->self.root_hub->do_remote_wakeup) {		if (bus_state->resuming_ports ||	/* USB2 */		    bus_state->port_remote_wakeup) {	/* USB3 */			spin_unlock_irqrestore(&xhci->lock, flags);			xhci_dbg(xhci, "suspend failed because a port is resuming/n");			return -EBUSY;		}	}	port_index = max_ports;	bus_state->bus_suspended = 0;	while (port_index--) {		/* suspend the port if the port is not suspended */		u32 t1, t2;		int slot_id;		t1 = xhci_readl(xhci, port_array[port_index]);		t2 = xhci_port_state_to_neutral(t1);		if ((t1 & PORT_PE) && !(t1 & PORT_PLS_MASK)) {			xhci_dbg(xhci, "port %d not suspended/n", port_index);			slot_id = xhci_find_slot_id_by_port(hcd, xhci,					port_index + 1);			if (slot_id) {				spin_unlock_irqrestore(&xhci->lock, flags);				xhci_stop_device(xhci, slot_id, 1);				spin_lock_irqsave(&xhci->lock, flags);			}			t2 &= ~PORT_PLS_MASK;			t2 |= PORT_LINK_STROBE | XDEV_U3;			set_bit(port_index, &bus_state->bus_suspended);		}		/* USB core sets remote wake mask for USB 3.0 hubs,		 * including the USB 3.0 roothub, but only if CONFIG_PM_RUNTIME		 * is enabled, so also enable remote wake here.		 */		if (hcd->self.root_hub->do_remote_wakeup) {			if (t1 & PORT_CONNECT) {				t2 |= PORT_WKOC_E | PORT_WKDISC_E;				t2 &= ~PORT_WKCONN_E;			} else {				t2 |= PORT_WKOC_E | PORT_WKCONN_E;				t2 &= ~PORT_WKDISC_E;			}		} else			t2 &= ~PORT_WAKE_BITS;		t1 = xhci_port_state_to_neutral(t1);		if (t1 != t2) {			xhci_writel(xhci, t2, port_array[port_index]);			if (xhci->quirks & XHCI_PORTSC_DELAY)				ndelay(100);		}		if (hcd->speed != HCD_USB3) {			/* enable remote wake up for USB 2.0 */			__le32 __iomem *addr;			u32 tmp;			/* Add one to the port status register address to get			 * the port power control register address.			 */			addr = port_array[port_index] + 1;			tmp = xhci_readl(xhci, addr);			tmp |= PORT_RWE;			xhci_writel(xhci, tmp, addr);			if (xhci->quirks & XHCI_PORTSC_DELAY)				ndelay(100);		}	}	hcd->state = HC_STATE_SUSPENDED;	bus_state->next_statechange = jiffies + msecs_to_jiffies(10);	spin_unlock_irqrestore(&xhci->lock, flags);	return 0;}