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: Sarah Sharp <sarah.a.sharp@linux.intel.com>
Signed-off-by: Greg Kroah-Hartman <gregkh@suse.de>

4 files changed, 115 insertions, 100 deletions

diff --git a/drivers/usb/host/xhci-hcd.c b/drivers/usb/host/xhci-hcd.c
index e478a63488fb..3ab9090c22dc 100644
--- a/drivers/usb/host/xhci-hcd.c
+++ b/drivers/usb/host/xhci-hcd.c
@@ -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]) {
-                        for (j = 0; j < 31; ++j) {
-                                if (xhci->devs[i]->ep_rings[j]) {
-                                        xhci_dbg(xhci, "Dev %d endpoint ring %d:\n", i, j);
-                                        xhci_debug_segment(xhci, xhci->devs[i]->ep_rings[j]->deq_seg);
-                                }
-                        }
+                if (!xhci->devs[i])
+                        continue;
+                for (j = 0; j < 31; ++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, 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);
diff --git a/drivers/usb/host/xhci-mem.c b/drivers/usb/host/xhci-mem.c
index 55920b39d106..75458ecc8eab 100644
--- a/drivers/usb/host/xhci-mem.c
+++ b/drivers/usb/host/xhci-mem.c
@@ -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);
diff --git a/drivers/usb/host/xhci-ring.c b/drivers/usb/host/xhci-ring.c
index ff5e6bc2299d..6a72d2022b45 100644
--- a/drivers/usb/host/xhci-ring.c
+++ b/drivers/usb/host/xhci-ring.c
@@ -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
diff --git a/drivers/usb/host/xhci.h b/drivers/usb/host/xhci.h
index a7728aa91582..627092286d1b 100644
--- a/drivers/usb/host/xhci.h
+++ b/drivers/usb/host/xhci.h
@@ -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);