xhci: rework command timeout and cancellation, (c311e391) · Commits · 戴 / test

drivers/usb/host/xhci-hub.c

+4 −7

Original line number	Diff line number	Diff line
		@@ -271,7 +271,6 @@ static int xhci_stop_device(struct xhci_hcd *xhci, int slot_id, int suspend)
		struct xhci_virt_device *virt_dev;
		struct xhci_command *cmd;
		unsigned long flags;
		int timeleft;
		int ret;
		int i;

		@@ -304,12 +303,10 @@ static int xhci_stop_device(struct xhci_hcd *xhci, int slot_id, int suspend)
		spin_unlock_irqrestore(&xhci->lock, flags);

		/* Wait for last stop endpoint command to finish */
		timeleft = wait_for_completion_interruptible_timeout(
		cmd->completion,
		XHCI_CMD_DEFAULT_TIMEOUT);
		if (timeleft <= 0) {
		xhci_warn(xhci, "%s while waiting for stop endpoint command\n",
		timeleft == 0 ? "Timeout" : "Signal");
		wait_for_completion(cmd->completion);

		if (cmd->status == COMP_CMD_ABORT \|\| cmd->status == COMP_CMD_STOP) {
		xhci_warn(xhci, "Timeout while waiting for stop endpoint command\n");
		ret = -ETIME;
		}
		xhci_free_command(xhci, cmd);

drivers/usb/host/xhci-mem.c

+7 −7

Original line number	Diff line number	Diff line
		@@ -1793,10 +1793,11 @@ void xhci_free_command(struct xhci_hcd *xhci,
		void xhci_mem_cleanup(struct xhci_hcd *xhci)
		{
		struct device *dev = xhci_to_hcd(xhci)->self.controller;
		struct xhci_cd cur_cd, next_cd;
		int size;
		int i, j, num_ports;

		del_timer_sync(&xhci->cmd_timer);

		/* Free the Event Ring Segment Table and the actual Event Ring */
		size = sizeof(struct xhci_erst_entry)*(xhci->erst.num_entries);
		if (xhci->erst.entries)
		@@ -1815,11 +1816,6 @@ void xhci_mem_cleanup(struct xhci_hcd *xhci)
		xhci_ring_free(xhci, xhci->cmd_ring);
		xhci->cmd_ring = NULL;
		xhci_dbg_trace(xhci, trace_xhci_dbg_init, "Freed command ring");
		list_for_each_entry_safe(cur_cd, next_cd,
		&xhci->cancel_cmd_list, cancel_cmd_list) {
		list_del(&cur_cd->cancel_cmd_list);
		kfree(cur_cd);
		}
		xhci_cleanup_command_queue(xhci);

		for (i = 1; i < MAX_HC_SLOTS; ++i)
		@@ -2323,7 +2319,6 @@ int xhci_mem_init(struct xhci_hcd *xhci, gfp_t flags)
		u32 page_size, temp;
		int i;

		INIT_LIST_HEAD(&xhci->cancel_cmd_list);
		INIT_LIST_HEAD(&xhci->cmd_list);

		page_size = readl(&xhci->op_regs->page_size);
		@@ -2510,6 +2505,11 @@ int xhci_mem_init(struct xhci_hcd *xhci, gfp_t flags)
		"Wrote ERST address to ir_set 0.");
		xhci_print_ir_set(xhci, 0);

		/* init command timeout timer */
		init_timer(&xhci->cmd_timer);
		xhci->cmd_timer.data = (unsigned long) xhci;
		xhci->cmd_timer.function = xhci_handle_command_timeout;

		/*
		* XXX: Might need to set the Interrupter Moderation Register to
		* something other than the default (~1ms minimum between interrupts).

drivers/usb/host/xhci-ring.c

+128 −250

Original line number	Diff line number	Diff line
		@@ -287,17 +287,7 @@ static int xhci_abort_cmd_ring(struct xhci_hcd *xhci)

		xhci_dbg(xhci, "Abort command ring\n");

		if (!(xhci->cmd_ring_state & CMD_RING_STATE_RUNNING)) {
		xhci_dbg(xhci, "The command ring isn't running, "
		"Have the command ring been stopped?\n");
		return 0;
		}

		temp_64 = xhci_read_64(xhci, &xhci->op_regs->cmd_ring);
		if (!(temp_64 & CMD_RING_RUNNING)) {
		xhci_dbg(xhci, "Command ring had been stopped\n");
		return 0;
		}
		xhci->cmd_ring_state = CMD_RING_STATE_ABORTED;
		xhci_write_64(xhci, temp_64 \| CMD_RING_ABORT,
		&xhci->op_regs->cmd_ring);
		@@ -323,71 +313,6 @@ static int xhci_abort_cmd_ring(struct xhci_hcd *xhci)
		return 0;
		}

		static int xhci_queue_cd(struct xhci_hcd *xhci,
		struct xhci_command *command,
		union xhci_trb *cmd_trb)
		{
		struct xhci_cd *cd;
		cd = kzalloc(sizeof(struct xhci_cd), GFP_ATOMIC);
		if (!cd)
		return -ENOMEM;
		INIT_LIST_HEAD(&cd->cancel_cmd_list);

		cd->command = command;
		cd->cmd_trb = cmd_trb;
		list_add_tail(&cd->cancel_cmd_list, &xhci->cancel_cmd_list);

		return 0;
		}

		/*
		* Cancel the command which has issue.
		*
		* Some commands may hang due to waiting for acknowledgement from
		* usb device. It is outside of the xHC's ability to control and
		* will cause the command ring is blocked. When it occurs software
		* should intervene to recover the command ring.
		* See Section 4.6.1.1 and 4.6.1.2
		*/
		int xhci_cancel_cmd(struct xhci_hcd xhci, struct xhci_command command,
		union xhci_trb *cmd_trb)
		{
		int retval = 0;
		unsigned long flags;

		spin_lock_irqsave(&xhci->lock, flags);

		if (xhci->xhc_state & XHCI_STATE_DYING) {
		xhci_warn(xhci, "Abort the command ring,"
		" but the xHCI is dead.\n");
		retval = -ESHUTDOWN;
		goto fail;
		}

		/* queue the cmd desriptor to cancel_cmd_list */
		retval = xhci_queue_cd(xhci, command, cmd_trb);
		if (retval) {
		xhci_warn(xhci, "Queuing command descriptor failed.\n");
		goto fail;
		}

		/* abort command ring */
		retval = xhci_abort_cmd_ring(xhci);
		if (retval) {
		xhci_err(xhci, "Abort command ring failed\n");
		if (unlikely(retval == -ESHUTDOWN)) {
		spin_unlock_irqrestore(&xhci->lock, flags);
		usb_hc_died(xhci_to_hcd(xhci)->primary_hcd);
		xhci_dbg(xhci, "xHCI host controller is dead.\n");
		return retval;
		}
		}

		fail:
		spin_unlock_irqrestore(&xhci->lock, flags);
		return retval;
		}

		void xhci_ring_ep_doorbell(struct xhci_hcd *xhci,
		unsigned int slot_id,
		unsigned int ep_index,
		@@ -1206,164 +1131,6 @@ static void xhci_handle_cmd_reset_ep(struct xhci_hcd *xhci, int slot_id,
		}
		}

		/* Complete the command and detele it from the devcie's command queue.
		*/
		static void xhci_complete_cmd_in_cmd_wait_list(struct xhci_hcd *xhci,
		struct xhci_command *command, u32 status)
		{
		command->status = status;
		list_del(&command->cmd_list);
		if (command->completion)
		complete(command->completion);
		else
		xhci_free_command(xhci, command);
		}


		/*
		* Finding the command trb need to be cancelled and modifying it to
		* NO OP command. And if the command is in device's command wait
		* list, finishing and freeing it.
		*
		* If we can't find the command trb, we think it had already been
		* executed.
		*/
		static void xhci_cmd_to_noop(struct xhci_hcd xhci, struct xhci_cd cur_cd)
		{
		struct xhci_segment *cur_seg;
		union xhci_trb *cmd_trb;
		u32 cycle_state;

		if (xhci->cmd_ring->dequeue == xhci->cmd_ring->enqueue)
		return;

		/* find the current segment of command ring */
		cur_seg = find_trb_seg(xhci->cmd_ring->first_seg,
		xhci->cmd_ring->dequeue, &cycle_state);

		if (!cur_seg) {
		xhci_warn(xhci, "Command ring mismatch, dequeue = %p %llx (dma)\n",
		xhci->cmd_ring->dequeue,
		(unsigned long long)
		xhci_trb_virt_to_dma(xhci->cmd_ring->deq_seg,
		xhci->cmd_ring->dequeue));
		xhci_debug_ring(xhci, xhci->cmd_ring);
		xhci_dbg_ring_ptrs(xhci, xhci->cmd_ring);
		return;
		}

		/* find the command trb matched by cd from command ring */
		for (cmd_trb = xhci->cmd_ring->dequeue;
		cmd_trb != xhci->cmd_ring->enqueue;
		next_trb(xhci, xhci->cmd_ring, &cur_seg, &cmd_trb)) {
		/* If the trb is link trb, continue */
		if (TRB_TYPE_LINK_LE32(cmd_trb->generic.field[3]))
		continue;

		if (cur_cd->cmd_trb == cmd_trb) {

		/* If the command in device's command list, we should
		* finish it and free the command structure.
		*/
		if (cur_cd->command)
		xhci_complete_cmd_in_cmd_wait_list(xhci,
		cur_cd->command, COMP_CMD_STOP);

		/* get cycle state from the origin command trb */
		cycle_state = le32_to_cpu(cmd_trb->generic.field[3])
		& TRB_CYCLE;

		/* modify the command trb to NO OP command */
		cmd_trb->generic.field[0] = 0;
		cmd_trb->generic.field[1] = 0;
		cmd_trb->generic.field[2] = 0;
		cmd_trb->generic.field[3] = cpu_to_le32(
		TRB_TYPE(TRB_CMD_NOOP) \| cycle_state);
		break;
		}
		}
		}

		static void xhci_cancel_cmd_in_cd_list(struct xhci_hcd *xhci)
		{
		struct xhci_cd cur_cd, next_cd;

		if (list_empty(&xhci->cancel_cmd_list))
		return;

		list_for_each_entry_safe(cur_cd, next_cd,
		&xhci->cancel_cmd_list, cancel_cmd_list) {
		xhci_cmd_to_noop(xhci, cur_cd);
		list_del(&cur_cd->cancel_cmd_list);
		kfree(cur_cd);
		}
		}

		/*
		* traversing the cancel_cmd_list. If the command descriptor according
		* to cmd_trb is found, the function free it and return 1, otherwise
		* return 0.
		*/
		static int xhci_search_cmd_trb_in_cd_list(struct xhci_hcd *xhci,
		union xhci_trb *cmd_trb)
		{
		struct xhci_cd cur_cd, next_cd;

		if (list_empty(&xhci->cancel_cmd_list))
		return 0;

		list_for_each_entry_safe(cur_cd, next_cd,
		&xhci->cancel_cmd_list, cancel_cmd_list) {
		if (cur_cd->cmd_trb == cmd_trb) {
		if (cur_cd->command)
		xhci_complete_cmd_in_cmd_wait_list(xhci,
		cur_cd->command, COMP_CMD_STOP);
		list_del(&cur_cd->cancel_cmd_list);
		kfree(cur_cd);
		return 1;
		}
		}

		return 0;
		}

		/*
		* If the cmd_trb_comp_code is COMP_CMD_ABORT, we just check whether the
		* trb pointed by the command ring dequeue pointer is the trb we want to
		* cancel or not. And if the cmd_trb_comp_code is COMP_CMD_STOP, we will
		* traverse the cancel_cmd_list to trun the all of the commands according
		* to command descriptor to NO-OP trb.
		*/
		static int handle_stopped_cmd_ring(struct xhci_hcd *xhci,
		int cmd_trb_comp_code)
		{
		int cur_trb_is_good = 0;

		/* Searching the cmd trb pointed by the command ring dequeue
		* pointer in command descriptor list. If it is found, free it.
		*/
		cur_trb_is_good = xhci_search_cmd_trb_in_cd_list(xhci,
		xhci->cmd_ring->dequeue);

		if (cmd_trb_comp_code == COMP_CMD_ABORT)
		xhci->cmd_ring_state = CMD_RING_STATE_STOPPED;
		else if (cmd_trb_comp_code == COMP_CMD_STOP) {
		/* traversing the cancel_cmd_list and canceling
		* the command according to command descriptor
		*/
		xhci_cancel_cmd_in_cd_list(xhci);

		xhci->cmd_ring_state = CMD_RING_STATE_RUNNING;
		/*
		* ring command ring doorbell again to restart the
		* command ring
		*/
		if (xhci->cmd_ring->dequeue != xhci->cmd_ring->enqueue)
		xhci_ring_cmd_db(xhci);
		}
		return cur_trb_is_good;
		}

		static void xhci_handle_cmd_enable_slot(struct xhci_hcd *xhci, int slot_id,
		u32 cmd_comp_code)
		{
		@@ -1480,6 +1247,97 @@ void xhci_cleanup_command_queue(struct xhci_hcd *xhci)
		xhci_complete_del_and_free_cmd(cur_cmd, COMP_CMD_ABORT);
		}

		/*
		* Turn all commands on command ring with status set to "aborted" to no-op trbs.
		* If there are other commands waiting then restart the ring and kick the timer.
		* This must be called with command ring stopped and xhci->lock held.
		*/
		static void xhci_handle_stopped_cmd_ring(struct xhci_hcd *xhci,
		struct xhci_command *cur_cmd)
		{
		struct xhci_command i_cmd, tmp_cmd;
		u32 cycle_state;

		/* Turn all aborted commands in list to no-ops, then restart */
		list_for_each_entry_safe(i_cmd, tmp_cmd, &xhci->cmd_list,
		cmd_list) {

		if (i_cmd->status != COMP_CMD_ABORT)
		continue;

		i_cmd->status = COMP_CMD_STOP;

		xhci_dbg(xhci, "Turn aborted command %p to no-op\n",
		i_cmd->command_trb);
		/* get cycle state from the original cmd trb */
		cycle_state = le32_to_cpu(
		i_cmd->command_trb->generic.field[3]) & TRB_CYCLE;
		/* modify the command trb to no-op command */
		i_cmd->command_trb->generic.field[0] = 0;
		i_cmd->command_trb->generic.field[1] = 0;
		i_cmd->command_trb->generic.field[2] = 0;
		i_cmd->command_trb->generic.field[3] = cpu_to_le32(
		TRB_TYPE(TRB_CMD_NOOP) \| cycle_state);

		/*
		* caller waiting for completion is called when command
		* completion event is received for these no-op commands
		*/
		}

		xhci->cmd_ring_state = CMD_RING_STATE_RUNNING;

		/* ring command ring doorbell to restart the command ring */
		if ((xhci->cmd_ring->dequeue != xhci->cmd_ring->enqueue) &&
		!(xhci->xhc_state & XHCI_STATE_DYING)) {
		xhci->current_cmd = cur_cmd;
		mod_timer(&xhci->cmd_timer, jiffies + XHCI_CMD_DEFAULT_TIMEOUT);
		xhci_ring_cmd_db(xhci);
		}
		return;
		}


		void xhci_handle_command_timeout(unsigned long data)
		{
		struct xhci_hcd *xhci;
		int ret;
		unsigned long flags;
		u64 hw_ring_state;
		struct xhci_command *cur_cmd = NULL;
		xhci = (struct xhci_hcd *) data;

		/* mark this command to be cancelled */
		spin_lock_irqsave(&xhci->lock, flags);
		if (xhci->current_cmd) {
		cur_cmd = xhci->current_cmd;
		cur_cmd->status = COMP_CMD_ABORT;
		}


		/* Make sure command ring is running before aborting it */
		hw_ring_state = xhci_read_64(xhci, &xhci->op_regs->cmd_ring);
		if ((xhci->cmd_ring_state & CMD_RING_STATE_RUNNING) &&
		(hw_ring_state & CMD_RING_RUNNING)) {

		spin_unlock_irqrestore(&xhci->lock, flags);
		xhci_dbg(xhci, "Command timeout\n");
		ret = xhci_abort_cmd_ring(xhci);
		if (unlikely(ret == -ESHUTDOWN)) {
		xhci_err(xhci, "Abort command ring failed\n");
		xhci_cleanup_command_queue(xhci);
		usb_hc_died(xhci_to_hcd(xhci)->primary_hcd);
		xhci_dbg(xhci, "xHCI host controller is dead.\n");
		}
		return;
		}
		/* command timeout on stopped ring, ring can't be aborted */
		xhci_dbg(xhci, "Command timeout on stopped ring\n");
		xhci_handle_stopped_cmd_ring(xhci, xhci->current_cmd);
		spin_unlock_irqrestore(&xhci->lock, flags);
		return;
		}

		static void handle_cmd_completion(struct xhci_hcd *xhci,
		struct xhci_event_cmd *event)
		{
		@@ -1513,26 +1371,28 @@ static void handle_cmd_completion(struct xhci_hcd *xhci,
		"Command completion event does not match command\n");
		return;
		}

		del_timer(&xhci->cmd_timer);

		trace_xhci_cmd_completion(cmd_trb, (struct xhci_generic_trb *) event);

		cmd_comp_code = GET_COMP_CODE(le32_to_cpu(event->status));
		if (cmd_comp_code == COMP_CMD_ABORT \|\| cmd_comp_code == COMP_CMD_STOP) {
		/* If the return value is 0, we think the trb pointed by
		* command ring dequeue pointer is a good trb. The good
		* trb means we don't want to cancel the trb, but it have
		* been stopped by host. So we should handle it normally.
		* Otherwise, driver should invoke inc_deq() and return.
		*/
		if (handle_stopped_cmd_ring(xhci, cmd_comp_code)) {
		inc_deq(xhci, xhci->cmd_ring);

		/* If CMD ring stopped we own the trbs between enqueue and dequeue */
		if (cmd_comp_code == COMP_CMD_STOP) {
		xhci_handle_stopped_cmd_ring(xhci, cmd);
		return;
		}
		/* There is no command to handle if we get a stop event when the
		* command ring is empty, event->cmd_trb points to the next
		* unset command
		/*
		* Host aborted the command ring, check if the current command was
		* supposed to be aborted, otherwise continue normally.
		* The command ring is stopped now, but the xHC will issue a Command
		* Ring Stopped event which will cause us to restart it.
		*/
		if (xhci->cmd_ring->dequeue == xhci->cmd_ring->enqueue)
		return;
		if (cmd_comp_code == COMP_CMD_ABORT) {
		xhci->cmd_ring_state = CMD_RING_STATE_STOPPED;
		if (cmd->status == COMP_CMD_ABORT)
		goto event_handled;
		}

		cmd_type = TRB_FIELD_TO_TYPE(le32_to_cpu(cmd_trb->generic.field[3]));
		@@ -1563,6 +1423,9 @@ static void handle_cmd_completion(struct xhci_hcd *xhci,
		xhci_handle_cmd_set_deq(xhci, slot_id, cmd_trb, cmd_comp_code);
		break;
		case TRB_CMD_NOOP:
		/* Is this an aborted command turned to NO-OP? */
		if (cmd->status == COMP_CMD_STOP)
		cmd_comp_code = COMP_CMD_STOP;
		break;
		case TRB_RESET_EP:
		WARN_ON(slot_id != TRB_TO_SLOT_ID(
		@@ -1583,6 +1446,14 @@ static void handle_cmd_completion(struct xhci_hcd *xhci,
		break;
		}

		/* restart timer if this wasn't the last command */
		if (cmd->cmd_list.next != &xhci->cmd_list) {
		xhci->current_cmd = list_entry(cmd->cmd_list.next,
		struct xhci_command, cmd_list);
		mod_timer(&xhci->cmd_timer, jiffies + XHCI_CMD_DEFAULT_TIMEOUT);
		}

		event_handled:
		xhci_complete_del_and_free_cmd(cmd, cmd_comp_code);

		inc_deq(xhci, xhci->cmd_ring);
		@@ -3988,6 +3859,13 @@ static int queue_command(struct xhci_hcd xhci, struct xhci_command cmd,
		cmd->command_trb = xhci->cmd_ring->enqueue;
		list_add_tail(&cmd->cmd_list, &xhci->cmd_list);

		/* if there are no other commands queued we start the timeout timer */
		if (xhci->cmd_list.next == &cmd->cmd_list &&
		!timer_pending(&xhci->cmd_timer)) {
		xhci->current_cmd = cmd;
		mod_timer(&xhci->cmd_timer, jiffies + XHCI_CMD_DEFAULT_TIMEOUT);
		}

		queue_trb(xhci, xhci->cmd_ring, false, field1, field2, field3,
		field4 \| xhci->cmd_ring->cycle_state);
		return 0;

drivers/usb/host/xhci.c

+26 −52

Original line number	Diff line number	Diff line
		@@ -1820,6 +1820,11 @@ static int xhci_configure_endpoint_result(struct xhci_hcd *xhci,
		int ret;

		switch (*cmd_status) {
		case COMP_CMD_ABORT:
		case COMP_CMD_STOP:
		xhci_warn(xhci, "Timeout while waiting for configure endpoint command\n");
		ret = -ETIME;
		break;
		case COMP_ENOMEM:
		dev_warn(&udev->dev, "Not enough host controller resources "
		"for new device state.\n");
		@@ -1866,6 +1871,11 @@ static int xhci_evaluate_context_result(struct xhci_hcd *xhci,
		struct xhci_virt_device *virt_dev = xhci->devs[udev->slot_id];

		switch (*cmd_status) {
		case COMP_CMD_ABORT:
		case COMP_CMD_STOP:
		xhci_warn(xhci, "Timeout while waiting for evaluate context command\n");
		ret = -ETIME;
		break;
		case COMP_EINVAL:
		dev_warn(&udev->dev, "WARN: xHCI driver setup invalid evaluate "
		"context command.\n");
		@@ -2590,7 +2600,6 @@ static int xhci_configure_endpoint(struct xhci_hcd *xhci,
		bool ctx_change, bool must_succeed)
		{
		int ret;
		int timeleft;
		unsigned long flags;
		struct xhci_input_control_ctx *ctrl_ctx;
		struct xhci_virt_device *virt_dev;
		@@ -2646,21 +2655,7 @@ static int xhci_configure_endpoint(struct xhci_hcd *xhci,
		spin_unlock_irqrestore(&xhci->lock, flags);

		/* Wait for the configure endpoint command to complete */
		timeleft = wait_for_completion_interruptible_timeout(
		command->completion,
		XHCI_CMD_DEFAULT_TIMEOUT);
		if (timeleft <= 0) {
		xhci_warn(xhci, "%s while waiting for %s command\n",
		timeleft == 0 ? "Timeout" : "Signal",
		ctx_change == 0 ?
		"configure endpoint" :
		"evaluate context");
		/* cancel the configure endpoint command */
		ret = xhci_cancel_cmd(xhci, command, command->command_trb);
		if (ret < 0)
		return ret;
		return -ETIME;
		}
		wait_for_completion(command->completion);

		if (!ctx_change)
		ret = xhci_configure_endpoint_result(xhci, udev,
		@@ -3438,7 +3433,6 @@ int xhci_discover_or_reset_device(struct usb_hcd hcd, struct usb_device udev)
		unsigned int slot_id;
		struct xhci_virt_device *virt_dev;
		struct xhci_command *reset_device_cmd;
		int timeleft;
		int last_freed_endpoint;
		struct xhci_slot_ctx *slot_ctx;
		int old_active_eps = 0;
		@@ -3506,15 +3500,7 @@ int xhci_discover_or_reset_device(struct usb_hcd hcd, struct usb_device udev)
		spin_unlock_irqrestore(&xhci->lock, flags);

		/* Wait for the Reset Device command to finish */
		timeleft = wait_for_completion_interruptible_timeout(
		reset_device_cmd->completion,
		XHCI_CMD_DEFAULT_TIMEOUT);
		if (timeleft <= 0) {
		xhci_warn(xhci, "%s while waiting for reset device command\n",
		timeleft == 0 ? "Timeout" : "Signal");
		ret = -ETIME;
		goto command_cleanup;
		}
		wait_for_completion(reset_device_cmd->completion);

		/* The Reset Device command can't fail, according to the 0.95/0.96 spec,
		* unless we tried to reset a slot ID that wasn't enabled,
		@@ -3522,6 +3508,11 @@ int xhci_discover_or_reset_device(struct usb_hcd hcd, struct usb_device udev)
		*/
		ret = reset_device_cmd->status;
		switch (ret) {
		case COMP_CMD_ABORT:
		case COMP_CMD_STOP:
		xhci_warn(xhci, "Timeout waiting for reset device command\n");
		ret = -ETIME;
		goto command_cleanup;
		case COMP_EBADSLT: /* 0.95 completion code for bad slot ID */
		case COMP_CTX_STATE: /* 0.96 completion code for same thing */
		xhci_dbg(xhci, "Can't reset device (slot ID %u) in %s state\n",
		@@ -3691,7 +3682,6 @@ int xhci_alloc_dev(struct usb_hcd hcd, struct usb_device udev)
		{
		struct xhci_hcd *xhci = hcd_to_xhci(hcd);
		unsigned long flags;
		int timeleft;
		int ret;
		struct xhci_command *command;

		@@ -3711,19 +3701,9 @@ int xhci_alloc_dev(struct usb_hcd hcd, struct usb_device udev)
		xhci_ring_cmd_db(xhci);
		spin_unlock_irqrestore(&xhci->lock, flags);

		/* XXX: how much time for xHC slot assignment? */
		timeleft = wait_for_completion_interruptible_timeout(
		command->completion,
		XHCI_CMD_DEFAULT_TIMEOUT);
		if (timeleft <= 0) {
		xhci_warn(xhci, "%s while waiting for a slot\n",
		timeleft == 0 ? "Timeout" : "Signal");
		/* cancel the enable slot request */
		ret = xhci_cancel_cmd(xhci, NULL, command->command_trb);
		return ret;
		}
		wait_for_completion(command->completion);

		if (!xhci->slot_id) {
		if (!xhci->slot_id \|\| command->status != COMP_SUCCESS) {
		xhci_err(xhci, "Error while assigning device slot ID\n");
		xhci_err(xhci, "Max number of devices this xHCI host supports is %u.\n",
		HCS_MAX_SLOTS(
		@@ -3792,7 +3772,6 @@ static int xhci_setup_device(struct usb_hcd hcd, struct usb_device udev,
		{
		const char *act = setup == SETUP_CONTEXT_ONLY ? "context" : "address";
		unsigned long flags;
		int timeleft;
		struct xhci_virt_device *virt_dev;
		int ret = 0;
		struct xhci_hcd *xhci = hcd_to_xhci(hcd);
		@@ -3867,23 +3846,18 @@ static int xhci_setup_device(struct usb_hcd hcd, struct usb_device udev,
		spin_unlock_irqrestore(&xhci->lock, flags);

		/* ctrl tx can take up to 5 sec; XXX: need more time for xHC? */
		timeleft = wait_for_completion_interruptible_timeout(
		command->completion, XHCI_CMD_DEFAULT_TIMEOUT);
		wait_for_completion(command->completion);

		/* FIXME: From section 4.3.4: "Software shall be responsible for timing
		* the SetAddress() "recovery interval" required by USB and aborting the
		* command on a timeout.
		*/
		if (timeleft <= 0) {
		xhci_warn(xhci, "%s while waiting for setup %s command\n",
		timeleft == 0 ? "Timeout" : "Signal", act);
		/* cancel the address device command */
		ret = xhci_cancel_cmd(xhci, NULL, command->command_trb);
		if (ret < 0)
		return ret;
		return -ETIME;
		}

		switch (command->status) {
		case COMP_CMD_ABORT:
		case COMP_CMD_STOP:
		xhci_warn(xhci, "Timeout while waiting for setup device command\n");
		ret = -ETIME;
		break;
		case COMP_CTX_STATE:
		case COMP_EBADSLT:
		xhci_err(xhci, "Setup ERROR: setup %s command for slot %d.\n",

drivers/usb/host/xhci.h

+4 −4

Original line number	Diff line number	Diff line
		@@ -1295,7 +1295,6 @@ struct xhci_td {

		/* command descriptor */
		struct xhci_cd {
		struct list_head cancel_cmd_list;
		struct xhci_command *command;
		union xhci_trb *cmd_trb;
		};
		@@ -1480,9 +1479,10 @@ struct xhci_hcd {
		#define CMD_RING_STATE_RUNNING (1 << 0)
		#define CMD_RING_STATE_ABORTED (1 << 1)
		#define CMD_RING_STATE_STOPPED (1 << 2)
		struct list_head cancel_cmd_list;
		struct list_head cmd_list;
		unsigned int cmd_ring_reserved_trbs;
		struct timer_list cmd_timer;
		struct xhci_command *current_cmd;
		struct xhci_ring *event_ring;
		struct xhci_erst erst;
		/* Scratchpad */
		@@ -1845,8 +1845,8 @@ void xhci_queue_config_ep_quirk(struct xhci_hcd *xhci,
		unsigned int slot_id, unsigned int ep_index,
		struct xhci_dequeue_state *deq_state);
		void xhci_stop_endpoint_command_watchdog(unsigned long arg);
		int xhci_cancel_cmd(struct xhci_hcd xhci, struct xhci_command command,
		union xhci_trb *cmd_trb);
		void xhci_handle_command_timeout(unsigned long data);

		void xhci_ring_ep_doorbell(struct xhci_hcd *xhci, unsigned int slot_id,
		unsigned int ep_index, unsigned int stream_id);
		void xhci_cleanup_command_queue(struct xhci_hcd *xhci);

Admin message