Commit 63a0d9ab authored by Sarah Sharp's avatar Sarah Sharp Committed by Greg Kroah-Hartman
Browse files

USB: xhci: Endpoint representation refactoring. 



The xhci_ring structure contained information that is really related to an
endpoint, not a ring.  This will cause problems later when endpoint
streams are supported and there are multiple rings per endpoint.

Move the endpoint state and cancellation information into a new virtual
endpoint structure, xhci_virt_ep.  The list of TRBs to be cancelled should
be per endpoint, not per ring, for easy access.  There can be only one TRB
that the endpoint stopped on after a stop endpoint command (even with
streams enabled); move the stopped TRB information into the new virtual
endpoint structure.  Also move the 31 endpoint rings and temporary ring
storage from the virtual device structure (xhci_virt_device) into the
virtual endpoint structure (xhci_virt_ep).

Signed-off-by: default avatarSarah Sharp <sarah.a.sharp@linux.intel.com>
Signed-off-by: default avatarGreg Kroah-Hartman <gregkh@suse.de>
parent 9e221be8

drivers/usb/host/xhci-hcd.c

+31 −28
Original line number Diff line number Diff line
@@ -351,13 +351,14 @@ void xhci_event_ring_work(unsigned long arg) 
	xhci_dbg_ring_ptrs(xhci, xhci->cmd_ring);

	xhci_dbg_cmd_ptrs(xhci);

	for (i = 0; i < MAX_HC_SLOTS; ++i) {

		if (xhci->devs[i]) {

		if (!xhci->devs[i])

			continue;

		for (j = 0; j < 31; ++j) {

				if (xhci->devs[i]->ep_rings[j]) {

			struct xhci_ring *ring = xhci->devs[i]->eps[j].ring;

			if (!ring)

				continue;

			xhci_dbg(xhci, "Dev %d endpoint ring %d:\n", i, j);

					xhci_debug_segment(xhci, xhci->devs[i]->ep_rings[j]->deq_seg);

				}

			}

			xhci_debug_segment(xhci, ring->deq_seg);

		}

	}
@@ -778,6 +779,7 @@ int xhci_urb_dequeue(struct usb_hcd *hcd, struct urb *urb, int status) 
	struct xhci_td *td;

	unsigned int ep_index;

	struct xhci_ring *ep_ring;

	struct xhci_virt_ep *ep;



	xhci = hcd_to_xhci(hcd);

	spin_lock_irqsave(&xhci->lock, flags);
@@ -790,17 +792,18 @@ int xhci_urb_dequeue(struct usb_hcd *hcd, struct urb *urb, int status) 
	xhci_dbg(xhci, "Event ring:\n");

	xhci_debug_ring(xhci, xhci->event_ring);

	ep_index = xhci_get_endpoint_index(&urb->ep->desc);

	ep_ring = xhci->devs[urb->dev->slot_id]->ep_rings[ep_index];

	ep = &xhci->devs[urb->dev->slot_id]->eps[ep_index];

	ep_ring = ep->ring;

	xhci_dbg(xhci, "Endpoint ring:\n");

	xhci_debug_ring(xhci, ep_ring);

	td = (struct xhci_td *) urb->hcpriv;



	ep_ring->cancels_pending++;

	list_add_tail(&td->cancelled_td_list, &ep_ring->cancelled_td_list);

	ep->cancels_pending++;

	list_add_tail(&td->cancelled_td_list, &ep->cancelled_td_list);

	/* Queue a stop endpoint command, but only if this is

	 * the first cancellation to be handled.

	 */

	if (ep_ring->cancels_pending == 1) {

	if (ep->cancels_pending == 1) {

		xhci_queue_stop_endpoint(xhci, urb->dev->slot_id, ep_index);

		xhci_ring_cmd_db(xhci);

	}
@@ -1206,10 +1209,10 @@ int xhci_check_bandwidth(struct usb_hcd *hcd, struct usb_device *udev) 
	xhci_zero_in_ctx(xhci, virt_dev);

	/* Free any old rings */

	for (i = 1; i < 31; ++i) {

		if (virt_dev->new_ep_rings[i]) {

			xhci_ring_free(xhci, virt_dev->ep_rings[i]);

			virt_dev->ep_rings[i] = virt_dev->new_ep_rings[i];

			virt_dev->new_ep_rings[i] = NULL;

		if (virt_dev->eps[i].new_ring) {

			xhci_ring_free(xhci, virt_dev->eps[i].ring);

			virt_dev->eps[i].ring = virt_dev->eps[i].new_ring;

			virt_dev->eps[i].new_ring = NULL;

		}

	}
@@ -1236,9 +1239,9 @@ void xhci_reset_bandwidth(struct usb_hcd *hcd, struct usb_device *udev) 
	virt_dev = xhci->devs[udev->slot_id];

	/* Free any rings allocated for added endpoints */

	for (i = 0; i < 31; ++i) {

		if (virt_dev->new_ep_rings[i]) {

			xhci_ring_free(xhci, virt_dev->new_ep_rings[i]);

			virt_dev->new_ep_rings[i] = NULL;

		if (virt_dev->eps[i].new_ring) {

			xhci_ring_free(xhci, virt_dev->eps[i].new_ring);

			virt_dev->eps[i].new_ring = NULL;

		}

	}

	xhci_zero_in_ctx(xhci, virt_dev);
@@ -1281,17 +1284,18 @@ void xhci_setup_input_ctx_for_quirk(struct xhci_hcd *xhci, 
}



void xhci_cleanup_stalled_ring(struct xhci_hcd *xhci,

		struct usb_device *udev,

		unsigned int ep_index, struct xhci_ring *ep_ring)

		struct usb_device *udev, unsigned int ep_index)

{

	struct xhci_dequeue_state deq_state;

	struct xhci_virt_ep *ep;



	xhci_dbg(xhci, "Cleaning up stalled endpoint ring\n");

	ep = &xhci->devs[udev->slot_id]->eps[ep_index];

	/* We need to move the HW's dequeue pointer past this TD,

	 * or it will attempt to resend it on the next doorbell ring.

	 */

	xhci_find_new_dequeue_state(xhci, udev->slot_id,

			ep_index, ep_ring->stopped_td,

			ep_index, ep->stopped_td,

			&deq_state);



	/* HW with the reset endpoint quirk will use the saved dequeue state to
@@ -1299,8 +1303,7 @@ void xhci_cleanup_stalled_ring(struct xhci_hcd *xhci, 
	 */

	if (!(xhci->quirks & XHCI_RESET_EP_QUIRK)) {

		xhci_dbg(xhci, "Queueing new dequeue state\n");

		xhci_queue_new_dequeue_state(xhci, ep_ring,

				udev->slot_id,

		xhci_queue_new_dequeue_state(xhci, udev->slot_id,

				ep_index, &deq_state);

	} else {

		/* Better hope no one uses the input context between now and the
@@ -1327,7 +1330,7 @@ void xhci_endpoint_reset(struct usb_hcd *hcd, 
	unsigned int ep_index;

	unsigned long flags;

	int ret;

	struct xhci_ring *ep_ring;

	struct xhci_virt_ep *virt_ep;



	xhci = hcd_to_xhci(hcd);

	udev = (struct usb_device *) ep->hcpriv;
@@ -1337,8 +1340,8 @@ void xhci_endpoint_reset(struct usb_hcd *hcd, 
	if (!ep->hcpriv)

		return;

	ep_index = xhci_get_endpoint_index(&ep->desc);

	ep_ring = xhci->devs[udev->slot_id]->ep_rings[ep_index];

	if (!ep_ring->stopped_td) {

	virt_ep = &xhci->devs[udev->slot_id]->eps[ep_index];

	if (!virt_ep->stopped_td) {

		xhci_dbg(xhci, "Endpoint 0x%x not halted, refusing to reset.\n",

				ep->desc.bEndpointAddress);

		return;
@@ -1357,8 +1360,8 @@ void xhci_endpoint_reset(struct usb_hcd *hcd, 
	 * command.  Better hope that last command worked!

	 */

	if (!ret) {

		xhci_cleanup_stalled_ring(xhci, udev, ep_index, ep_ring);

		kfree(ep_ring->stopped_td);

		xhci_cleanup_stalled_ring(xhci, udev, ep_index);

		kfree(virt_ep->stopped_td);

		xhci_ring_cmd_db(xhci);

	}

	spin_unlock_irqrestore(&xhci->lock, flags);

drivers/usb/host/xhci-mem.c

+15 −10
Original line number Diff line number Diff line
@@ -144,7 +144,6 @@ static struct xhci_ring *xhci_ring_alloc(struct xhci_hcd *xhci, 
		return 0;



	INIT_LIST_HEAD(&ring->td_list);

	INIT_LIST_HEAD(&ring->cancelled_td_list);

	if (num_segs == 0)

		return ring;
@@ -265,8 +264,8 @@ void xhci_free_virt_device(struct xhci_hcd *xhci, int slot_id) 
		return;



	for (i = 0; i < 31; ++i)

		if (dev->ep_rings[i])

			xhci_ring_free(xhci, dev->ep_rings[i]);

		if (dev->eps[i].ring)

			xhci_ring_free(xhci, dev->eps[i].ring);



	if (dev->in_ctx)

		xhci_free_container_ctx(xhci, dev->in_ctx);
@@ -281,6 +280,7 @@ int xhci_alloc_virt_device(struct xhci_hcd *xhci, int slot_id, 
		struct usb_device *udev, gfp_t flags)

{

	struct xhci_virt_device *dev;

	int i;



	/* Slot ID 0 is reserved */

	if (slot_id == 0 || xhci->devs[slot_id]) {
@@ -309,9 +309,13 @@ int xhci_alloc_virt_device(struct xhci_hcd *xhci, int slot_id, 
	xhci_dbg(xhci, "Slot %d input ctx = 0x%llx (dma)\n", slot_id,

			(unsigned long long)dev->in_ctx->dma);



	/* Initialize the cancellation list for each endpoint */

	for (i = 0; i < 31; i++)

		INIT_LIST_HEAD(&dev->eps[i].cancelled_td_list);



	/* Allocate endpoint 0 ring */

	dev->ep_rings[0] = xhci_ring_alloc(xhci, 1, true, flags);

	if (!dev->ep_rings[0])

	dev->eps[0].ring = xhci_ring_alloc(xhci, 1, true, flags);

	if (!dev->eps[0].ring)

		goto fail;



	init_completion(&dev->cmd_completion);
@@ -428,8 +432,8 @@ int xhci_setup_addressable_virt_dev(struct xhci_hcd *xhci, struct usb_device *ud 
	ep0_ctx->ep_info2 |= ERROR_COUNT(3);



	ep0_ctx->deq =

		dev->ep_rings[0]->first_seg->dma;

	ep0_ctx->deq |= dev->ep_rings[0]->cycle_state;

		dev->eps[0].ring->first_seg->dma;

	ep0_ctx->deq |= dev->eps[0].ring->cycle_state;



	/* Steps 7 and 8 were done in xhci_alloc_virt_device() */
@@ -539,10 +543,11 @@ int xhci_endpoint_init(struct xhci_hcd *xhci, 
	ep_ctx = xhci_get_ep_ctx(xhci, virt_dev->in_ctx, ep_index);



	/* Set up the endpoint ring */

	virt_dev->new_ep_rings[ep_index] = xhci_ring_alloc(xhci, 1, true, mem_flags);

	if (!virt_dev->new_ep_rings[ep_index])

	virt_dev->eps[ep_index].new_ring =

		xhci_ring_alloc(xhci, 1, true, mem_flags);

	if (!virt_dev->eps[ep_index].new_ring)

		return -ENOMEM;

	ep_ring = virt_dev->new_ep_rings[ep_index];

	ep_ring = virt_dev->eps[ep_index].new_ring;

	ep_ctx->deq = ep_ring->first_seg->dma | ep_ring->cycle_state;



	ep_ctx->ep_info = xhci_get_endpoint_interval(udev, ep);

drivers/usb/host/xhci-ring.c

+48 −42
Original line number Diff line number Diff line
@@ -296,16 +296,18 @@ static void ring_ep_doorbell(struct xhci_hcd *xhci, 
		unsigned int slot_id,

		unsigned int ep_index)

{

	struct xhci_ring *ep_ring;

	struct xhci_virt_ep *ep;

	unsigned int ep_state;

	u32 field;

	__u32 __iomem *db_addr = &xhci->dba->doorbell[slot_id];



	ep_ring = xhci->devs[slot_id]->ep_rings[ep_index];

	ep = &xhci->devs[slot_id]->eps[ep_index];

	ep_state = ep->ep_state;

	/* Don't ring the doorbell for this endpoint if there are pending

	 * cancellations because the we don't want to interrupt processing.

	 */

	if (!ep_ring->cancels_pending && !(ep_ring->state & SET_DEQ_PENDING)

			&& !(ep_ring->state & EP_HALTED)) {

	if (!ep->cancels_pending && !(ep_state & SET_DEQ_PENDING)

			&& !(ep_state & EP_HALTED)) {

		field = xhci_readl(xhci, db_addr) & DB_MASK;

		xhci_writel(xhci, field | EPI_TO_DB(ep_index), db_addr);

		/* Flush PCI posted writes - FIXME Matthew Wilcox says this
@@ -361,7 +363,7 @@ void xhci_find_new_dequeue_state(struct xhci_hcd *xhci, 
		struct xhci_td *cur_td, struct xhci_dequeue_state *state)

{

	struct xhci_virt_device *dev = xhci->devs[slot_id];

	struct xhci_ring *ep_ring = dev->ep_rings[ep_index];

	struct xhci_ring *ep_ring = dev->eps[ep_index].ring;

	struct xhci_generic_trb *trb;

	struct xhci_ep_ctx *ep_ctx;

	dma_addr_t addr;
@@ -369,7 +371,7 @@ void xhci_find_new_dequeue_state(struct xhci_hcd *xhci, 
	state->new_cycle_state = 0;

	xhci_dbg(xhci, "Finding segment containing stopped TRB.\n");

	state->new_deq_seg = find_trb_seg(cur_td->start_seg,

			ep_ring->stopped_trb,

			dev->eps[ep_index].stopped_trb,

			&state->new_cycle_state);

	if (!state->new_deq_seg)

		BUG();
@@ -449,9 +451,11 @@ static int queue_set_tr_deq(struct xhci_hcd *xhci, int slot_id, 
		union xhci_trb *deq_ptr, u32 cycle_state);



void xhci_queue_new_dequeue_state(struct xhci_hcd *xhci,

		struct xhci_ring *ep_ring, unsigned int slot_id,

		unsigned int ep_index, struct xhci_dequeue_state *deq_state)

		unsigned int slot_id, unsigned int ep_index,

		struct xhci_dequeue_state *deq_state)

{

	struct xhci_virt_ep *ep = &xhci->devs[slot_id]->eps[ep_index];



	xhci_dbg(xhci, "Set TR Deq Ptr cmd, new deq seg = %p (0x%llx dma), "

			"new deq ptr = %p (0x%llx dma), new cycle = %u\n",

			deq_state->new_deq_seg,
@@ -468,7 +472,7 @@ void xhci_queue_new_dequeue_state(struct xhci_hcd *xhci, 
	 * if the ring is running, and ringing the doorbell starts the

	 * ring running.

	 */

	ep_ring->state |= SET_DEQ_PENDING;

	ep->ep_state |= SET_DEQ_PENDING;

}



/*
@@ -487,6 +491,7 @@ static void handle_stopped_endpoint(struct xhci_hcd *xhci, 
	unsigned int slot_id;

	unsigned int ep_index;

	struct xhci_ring *ep_ring;

	struct xhci_virt_ep *ep;

	struct list_head *entry;

	struct xhci_td *cur_td = 0;

	struct xhci_td *last_unlinked_td;
@@ -499,9 +504,10 @@ static void handle_stopped_endpoint(struct xhci_hcd *xhci, 
	memset(&deq_state, 0, sizeof(deq_state));

	slot_id = TRB_TO_SLOT_ID(trb->generic.field[3]);

	ep_index = TRB_TO_EP_INDEX(trb->generic.field[3]);

	ep_ring = xhci->devs[slot_id]->ep_rings[ep_index];

	ep = &xhci->devs[slot_id]->eps[ep_index];

	ep_ring = ep->ring;



	if (list_empty(&ep_ring->cancelled_td_list))

	if (list_empty(&ep->cancelled_td_list))

		return;



	/* Fix up the ep ring first, so HW stops executing cancelled TDs.
@@ -509,7 +515,7 @@ static void handle_stopped_endpoint(struct xhci_hcd *xhci, 
	 * it.  We're also in the event handler, so we can't get re-interrupted

	 * if another Stop Endpoint command completes

	 */

	list_for_each(entry, &ep_ring->cancelled_td_list) {

	list_for_each(entry, &ep->cancelled_td_list) {

		cur_td = list_entry(entry, struct xhci_td, cancelled_td_list);

		xhci_dbg(xhci, "Cancelling TD starting at %p, 0x%llx (dma).\n",

				cur_td->first_trb,
@@ -518,7 +524,7 @@ static void handle_stopped_endpoint(struct xhci_hcd *xhci, 
		 * If we stopped on the TD we need to cancel, then we have to

		 * move the xHC endpoint ring dequeue pointer past this TD.

		 */

		if (cur_td == ep_ring->stopped_td)

		if (cur_td == ep->stopped_td)

			xhci_find_new_dequeue_state(xhci, slot_id, ep_index, cur_td,

					&deq_state);

		else
@@ -529,13 +535,13 @@ static void handle_stopped_endpoint(struct xhci_hcd *xhci, 
		 * the cancelled TD list for URB completion later.

		 */

		list_del(&cur_td->td_list);

		ep_ring->cancels_pending--;

		ep->cancels_pending--;

	}

	last_unlinked_td = cur_td;



	/* If necessary, queue a Set Transfer Ring Dequeue Pointer command */

	if (deq_state.new_deq_ptr && deq_state.new_deq_seg) {

		xhci_queue_new_dequeue_state(xhci, ep_ring,

		xhci_queue_new_dequeue_state(xhci,

				slot_id, ep_index, &deq_state);

		xhci_ring_cmd_db(xhci);

	} else {
@@ -550,7 +556,7 @@ static void handle_stopped_endpoint(struct xhci_hcd *xhci, 
	 * So stop when we've completed the URB for the last TD we unlinked.

	 */

	do {

		cur_td = list_entry(ep_ring->cancelled_td_list.next,

		cur_td = list_entry(ep->cancelled_td_list.next,

				struct xhci_td, cancelled_td_list);

		list_del(&cur_td->cancelled_td_list);
@@ -597,7 +603,7 @@ static void handle_set_deq_completion(struct xhci_hcd *xhci, 
	slot_id = TRB_TO_SLOT_ID(trb->generic.field[3]);

	ep_index = TRB_TO_EP_INDEX(trb->generic.field[3]);

	dev = xhci->devs[slot_id];

	ep_ring = dev->ep_rings[ep_index];

	ep_ring = dev->eps[ep_index].ring;

	ep_ctx = xhci_get_ep_ctx(xhci, dev->out_ctx, ep_index);

	slot_ctx = xhci_get_slot_ctx(xhci, dev->out_ctx);
@@ -641,7 +647,7 @@ static void handle_set_deq_completion(struct xhci_hcd *xhci, 
				ep_ctx->deq);

	}



	ep_ring->state &= ~SET_DEQ_PENDING;

	dev->eps[ep_index].ep_state &= ~SET_DEQ_PENDING;

	ring_ep_doorbell(xhci, slot_id, ep_index);

}
@@ -655,7 +661,7 @@ static void handle_reset_ep_completion(struct xhci_hcd *xhci, 


	slot_id = TRB_TO_SLOT_ID(trb->generic.field[3]);

	ep_index = TRB_TO_EP_INDEX(trb->generic.field[3]);

	ep_ring = xhci->devs[slot_id]->ep_rings[ep_index];

	ep_ring = xhci->devs[slot_id]->eps[ep_index].ring;

	/* This command will only fail if the endpoint wasn't halted,

	 * but we don't care.

	 */
@@ -673,7 +679,7 @@ static void handle_reset_ep_completion(struct xhci_hcd *xhci, 
		xhci_ring_cmd_db(xhci);

	} else {

		/* Clear our internal halted state and restart the ring */

		ep_ring->state &= ~EP_HALTED;

		xhci->devs[slot_id]->eps[ep_index].ep_state &= ~EP_HALTED;

		ring_ep_doorbell(xhci, slot_id, ep_index);

	}

}
@@ -726,7 +732,7 @@ static void handle_cmd_completion(struct xhci_hcd *xhci, 
				xhci->devs[slot_id]->in_ctx);

		/* Input ctx add_flags are the endpoint index plus one */

		ep_index = xhci_last_valid_endpoint(ctrl_ctx->add_flags) - 1;

		ep_ring = xhci->devs[slot_id]->ep_rings[ep_index];

		ep_ring = xhci->devs[slot_id]->eps[ep_index].ring;

		if (!ep_ring) {

			/* This must have been an initial configure endpoint */

			xhci->devs[slot_id]->cmd_status =
@@ -734,13 +740,13 @@ static void handle_cmd_completion(struct xhci_hcd *xhci, 
			complete(&xhci->devs[slot_id]->cmd_completion);

			break;

		}

		ep_state = ep_ring->state;

		ep_state = xhci->devs[slot_id]->eps[ep_index].ep_state;

		xhci_dbg(xhci, "Completed config ep cmd - last ep index = %d, "

				"state = %d\n", ep_index, ep_state);

		if (xhci->quirks & XHCI_RESET_EP_QUIRK &&

				ep_state & EP_HALTED) {

			/* Clear our internal halted state and restart ring */

			xhci->devs[slot_id]->ep_rings[ep_index]->state &=

			xhci->devs[slot_id]->eps[ep_index].ep_state &=

				~EP_HALTED;

			ring_ep_doorbell(xhci, slot_id, ep_index);

		} else {
@@ -864,6 +870,7 @@ static int handle_tx_event(struct xhci_hcd *xhci, 
		struct xhci_transfer_event *event)

{

	struct xhci_virt_device *xdev;

	struct xhci_virt_ep *ep;

	struct xhci_ring *ep_ring;

	unsigned int slot_id;

	int ep_index;
@@ -887,7 +894,8 @@ static int handle_tx_event(struct xhci_hcd *xhci, 
	/* Endpoint ID is 1 based, our index is zero based */

	ep_index = TRB_TO_EP_ID(event->flags) - 1;

	xhci_dbg(xhci, "%s - ep index = %d\n", __func__, ep_index);

	ep_ring = xdev->ep_rings[ep_index];

	ep = &xdev->eps[ep_index];

	ep_ring = ep->ring;

	ep_ctx = xhci_get_ep_ctx(xhci, xdev->out_ctx, ep_index);

	if (!ep_ring || (ep_ctx->ep_info & EP_STATE_MASK) == EP_STATE_DISABLED) {

		xhci_err(xhci, "ERROR Transfer event pointed to disabled endpoint\n");
@@ -948,7 +956,7 @@ static int handle_tx_event(struct xhci_hcd *xhci, 
		break;

	case COMP_STALL:

		xhci_warn(xhci, "WARN: Stalled endpoint\n");

		ep_ring->state |= EP_HALTED;

		ep->ep_state |= EP_HALTED;

		status = -EPIPE;

		break;

	case COMP_TRB_ERR:
@@ -1016,12 +1024,10 @@ static int handle_tx_event(struct xhci_hcd *xhci, 
			else

				td->urb->actual_length = 0;



			ep_ring->stopped_td = td;

			ep_ring->stopped_trb = event_trb;

			ep->stopped_td = td;

			ep->stopped_trb = event_trb;

			xhci_queue_reset_ep(xhci, slot_id, ep_index);

			xhci_cleanup_stalled_ring(xhci,

					td->urb->dev,

					ep_index, ep_ring);

			xhci_cleanup_stalled_ring(xhci, td->urb->dev, ep_index);

			xhci_ring_cmd_db(xhci);

			goto td_cleanup;

		default:
@@ -1161,8 +1167,8 @@ static int handle_tx_event(struct xhci_hcd *xhci, 
		 * stopped TDs.  A stopped TD may be restarted, so don't update

		 * the ring dequeue pointer or take this TD off any lists yet.

		 */

		ep_ring->stopped_td = td;

		ep_ring->stopped_trb = event_trb;

		ep->stopped_td = td;

		ep->stopped_trb = event_trb;

	} else {

		if (trb_comp_code == COMP_STALL ||

				trb_comp_code == COMP_BABBLE) {
@@ -1172,8 +1178,8 @@ static int handle_tx_event(struct xhci_hcd *xhci, 
			 * pointer past the TD.  We can't do that here because

			 * the halt condition must be cleared first.

			 */

			ep_ring->stopped_td = td;

			ep_ring->stopped_trb = event_trb;

			ep->stopped_td = td;

			ep->stopped_trb = event_trb;

		} else {

			/* Update ring dequeue pointer */

			while (ep_ring->dequeue != td->last_trb)
@@ -1206,7 +1212,7 @@ td_cleanup: 
		/* Was this TD slated to be cancelled but completed anyway? */

		if (!list_empty(&td->cancelled_td_list)) {

			list_del(&td->cancelled_td_list);

			ep_ring->cancels_pending--;

			ep->cancels_pending--;

		}

		/* Leave the TD around for the reset endpoint function to use

		 * (but only if it's not a control endpoint, since we already
@@ -1369,7 +1375,7 @@ static int prepare_transfer(struct xhci_hcd *xhci, 
{

	int ret;

	struct xhci_ep_ctx *ep_ctx = xhci_get_ep_ctx(xhci, xdev->out_ctx, ep_index);

	ret = prepare_ring(xhci, xdev->ep_rings[ep_index],

	ret = prepare_ring(xhci, xdev->eps[ep_index].ring,

			ep_ctx->ep_info & EP_STATE_MASK,

			num_trbs, mem_flags);

	if (ret)
@@ -1389,9 +1395,9 @@ static int prepare_transfer(struct xhci_hcd *xhci, 
	(*td)->urb = urb;

	urb->hcpriv = (void *) (*td);

	/* Add this TD to the tail of the endpoint ring's TD list */

	list_add_tail(&(*td)->td_list, &xdev->ep_rings[ep_index]->td_list);

	(*td)->start_seg = xdev->ep_rings[ep_index]->enq_seg;

	(*td)->first_trb = xdev->ep_rings[ep_index]->enqueue;

	list_add_tail(&(*td)->td_list, &xdev->eps[ep_index].ring->td_list);

	(*td)->start_seg = xdev->eps[ep_index].ring->enq_seg;

	(*td)->first_trb = xdev->eps[ep_index].ring->enqueue;



	return 0;

}
@@ -1525,7 +1531,7 @@ static int queue_bulk_sg_tx(struct xhci_hcd *xhci, gfp_t mem_flags, 
	struct xhci_generic_trb *start_trb;

	int start_cycle;



	ep_ring = xhci->devs[slot_id]->ep_rings[ep_index];

	ep_ring = xhci->devs[slot_id]->eps[ep_index].ring;

	num_trbs = count_sg_trbs_needed(xhci, urb);

	num_sgs = urb->num_sgs;
@@ -1658,7 +1664,7 @@ int xhci_queue_bulk_tx(struct xhci_hcd *xhci, gfp_t mem_flags, 
	if (urb->sg)

		return queue_bulk_sg_tx(xhci, mem_flags, urb, slot_id, ep_index);



	ep_ring = xhci->devs[slot_id]->ep_rings[ep_index];

	ep_ring = xhci->devs[slot_id]->eps[ep_index].ring;



	num_trbs = 0;

	/* How much data is (potentially) left before the 64KB boundary? */
@@ -1769,7 +1775,7 @@ int xhci_queue_ctrl_tx(struct xhci_hcd *xhci, gfp_t mem_flags, 
	u32 field, length_field;

	struct xhci_td *td;



	ep_ring = xhci->devs[slot_id]->ep_rings[ep_index];

	ep_ring = xhci->devs[slot_id]->eps[ep_index].ring;



	/*

	 * Need to copy setup packet into setup TRB, so we can't use the setup

drivers/usb/host/xhci.h

+21 −20
Original line number Diff line number Diff line
@@ -625,6 +625,23 @@ struct xhci_input_control_ctx { 
/* add context bitmasks */

#define	ADD_EP(x)	(0x1 << x)



struct xhci_virt_ep {

	struct xhci_ring		*ring;

	/* Temporary storage in case the configure endpoint command fails and we

	 * have to restore the device state to the previous state

	 */

	struct xhci_ring		*new_ring;

	unsigned int			ep_state;

#define SET_DEQ_PENDING		(1 << 0)

#define EP_HALTED		(1 << 1)

	/* ----  Related to URB cancellation ---- */

	struct list_head	cancelled_td_list;

	unsigned int		cancels_pending;

	/* The TRB that was last reported in a stopped endpoint ring */

	union xhci_trb		*stopped_trb;

	struct xhci_td		*stopped_td;

};



struct xhci_virt_device {

	/*

	 * Commands to the hardware are passed an "input context" that
@@ -637,13 +654,7 @@ struct xhci_virt_device { 
	struct xhci_container_ctx       *out_ctx;

	/* Used for addressing devices and configuration changes */

	struct xhci_container_ctx       *in_ctx;



	/* FIXME when stream support is added */

	struct xhci_ring		*ep_rings[31];

	/* Temporary storage in case the configure endpoint command fails and we

	 * have to restore the device state to the previous state

	 */

	struct xhci_ring		*new_ep_rings[31];

	struct xhci_virt_ep		eps[31];

	struct completion		cmd_completion;

	/* Status of the last command issued for this device */

	u32				cmd_status;
@@ -945,15 +956,6 @@ struct xhci_ring { 
	struct xhci_segment	*deq_seg;

	unsigned int		deq_updates;

	struct list_head	td_list;

	/* ----  Related to URB cancellation ---- */

	struct list_head	cancelled_td_list;

	unsigned int		cancels_pending;

	unsigned int		state;

#define SET_DEQ_PENDING		(1 << 0)

#define EP_HALTED		(1 << 1)

	/* The TRB that was last reported in a stopped endpoint ring */

	union xhci_trb		*stopped_trb;

	struct xhci_td		*stopped_td;

	/*

	 * Write the cycle state into the TRB cycle field to give ownership of

	 * the TRB to the host controller (if we are the producer), or to check
@@ -1236,11 +1238,10 @@ void xhci_find_new_dequeue_state(struct xhci_hcd *xhci, 
		unsigned int slot_id, unsigned int ep_index,

		struct xhci_td *cur_td, struct xhci_dequeue_state *state);

void xhci_queue_new_dequeue_state(struct xhci_hcd *xhci,

		struct xhci_ring *ep_ring, unsigned int slot_id,

		unsigned int ep_index, struct xhci_dequeue_state *deq_state);

		unsigned int slot_id, unsigned int ep_index,

		struct xhci_dequeue_state *deq_state);

void xhci_cleanup_stalled_ring(struct xhci_hcd *xhci,

		struct usb_device *udev,

		unsigned int ep_index, struct xhci_ring *ep_ring);

		struct usb_device *udev, unsigned int ep_index);

void xhci_queue_config_ep_quirk(struct xhci_hcd *xhci,

		unsigned int slot_id, unsigned int ep_index,

		struct xhci_dequeue_state *deq_state);

CRA Git | Maintained and supported by SUSTech CRA and CCSE