1 files changed, 43 insertions, 42 deletions

diff --git a/drivers/usb/host/xhci-mem.c b/drivers/usb/host/xhci-mem.c
index fcb7f7efc86..d718033dc53 100644
--- a/drivers/usb/host/xhci-mem.c
+++ b/drivers/usb/host/xhci-mem.c
@@ -81,7 +81,7 @@ static void xhci_segment_free(struct xhci_hcd *xhci, struct xhci_segment *seg)
  * related flags, such as End TRB, Toggle Cycle, and no snoop.
  */
 static void xhci_link_segments(struct xhci_hcd *xhci, struct xhci_segment *prev,
-                struct xhci_segment *next, bool link_trbs)
+                struct xhci_segment *next, bool link_trbs, bool isoc)
 {
         u32 val;
 
@@ -89,15 +89,17 @@ static void xhci_link_segments(struct xhci_hcd *xhci, struct xhci_segment *prev,
                 return;
         prev->next = next;
         if (link_trbs) {
-                prev->trbs[TRBS_PER_SEGMENT-1].link.
-                        segment_ptr = cpu_to_le64(next->dma);
+                prev->trbs[TRBS_PER_SEGMENT-1].link.segment_ptr =
+                        cpu_to_le64(next->dma);
 
                 /* Set the last TRB in the segment to have a TRB type ID of Link TRB */
                 val = le32_to_cpu(prev->trbs[TRBS_PER_SEGMENT-1].link.control);
                 val &= ~TRB_TYPE_BITMASK;
                 val |= TRB_TYPE(TRB_LINK);
                 /* Always set the chain bit with 0.95 hardware */
-                if (xhci_link_trb_quirk(xhci))
+                /* Set chain bit for isoc rings on AMD 0.96 host */
+                if (xhci_link_trb_quirk(xhci) ||
+                                (isoc && (xhci->quirks & XHCI_AMD_0x96_HOST)))
                         val |= TRB_CHAIN;
                 prev->trbs[TRBS_PER_SEGMENT-1].link.control = cpu_to_le32(val);
         }
@@ -112,18 +114,20 @@ void xhci_ring_free(struct xhci_hcd *xhci, struct xhci_ring *ring)
         struct xhci_segment *seg;
         struct xhci_segment *first_seg;
 
-        if (!ring || !ring->first_seg)
+        if (!ring)
                 return;
-        first_seg = ring->first_seg;
-        seg = first_seg->next;
-        xhci_dbg(xhci, "Freeing ring at %p\n", ring);
-        while (seg != first_seg) {
-                struct xhci_segment *next = seg->next;
-                xhci_segment_free(xhci, seg);
-                seg = next;
+        if (ring->first_seg) {
+                first_seg = ring->first_seg;
+                seg = first_seg->next;
+                xhci_dbg(xhci, "Freeing ring at %p\n", ring);
+                while (seg != first_seg) {
+                        struct xhci_segment *next = seg->next;
+                        xhci_segment_free(xhci, seg);
+                        seg = next;
+                }
+                xhci_segment_free(xhci, first_seg);
+                ring->first_seg = NULL;
         }
-        xhci_segment_free(xhci, first_seg);
-        ring->first_seg = NULL;
         kfree(ring);
 }
 
@@ -152,7 +156,7 @@ static void xhci_initialize_ring_info(struct xhci_ring *ring)
  * See section 4.9.1 and figures 15 and 16.
  */
 static struct xhci_ring *xhci_ring_alloc(struct xhci_hcd *xhci,
-                unsigned int num_segs, bool link_trbs, gfp_t flags)
+                unsigned int num_segs, bool link_trbs, bool isoc, gfp_t flags)
 {
         struct xhci_ring        *ring;
         struct xhci_segment     *prev;
@@ -178,17 +182,17 @@ static struct xhci_ring *xhci_ring_alloc(struct xhci_hcd *xhci,
                 next = xhci_segment_alloc(xhci, flags);
                 if (!next)
                         goto fail;
-                xhci_link_segments(xhci, prev, next, link_trbs);
+                xhci_link_segments(xhci, prev, next, link_trbs, isoc);
 
                 prev = next;
                 num_segs--;
         }
-        xhci_link_segments(xhci, prev, ring->first_seg, link_trbs);
+        xhci_link_segments(xhci, prev, ring->first_seg, link_trbs, isoc);
 
         if (link_trbs) {
                 /* See section 4.9.2.1 and 6.4.4.1 */
-                prev->trbs[TRBS_PER_SEGMENT-1].link.
-                        control |= cpu_to_le32(LINK_TOGGLE);
+                prev->trbs[TRBS_PER_SEGMENT-1].link.control |=
+                        cpu_to_le32(LINK_TOGGLE);
                 xhci_dbg(xhci, "Wrote link toggle flag to"
                                 " segment %p (virtual), 0x%llx (DMA)\n",
                                 prev, (unsigned long long)prev->dma);
@@ -229,14 +233,14 @@ void xhci_free_or_cache_endpoint_ring(struct xhci_hcd *xhci,
  * pointers to the beginning of the ring.
  */
 static void xhci_reinit_cached_ring(struct xhci_hcd *xhci,
-                struct xhci_ring *ring)
+                struct xhci_ring *ring, bool isoc)
 {
         struct xhci_segment     *seg = ring->first_seg;
         do {
                 memset(seg->trbs, 0,
                                 sizeof(union xhci_trb)*TRBS_PER_SEGMENT);
                 /* All endpoint rings have link TRBs */
-                xhci_link_segments(xhci, seg, seg->next, 1);
+                xhci_link_segments(xhci, seg, seg->next, 1, isoc);
                 seg = seg->next;
         } while (seg != ring->first_seg);
         xhci_initialize_ring_info(ring);
@@ -540,7 +544,7 @@ struct xhci_stream_info *xhci_alloc_stream_info(struct xhci_hcd *xhci,
          */
         for (cur_stream = 1; cur_stream < num_streams; cur_stream++) {
                 stream_info->stream_rings[cur_stream] =
-                        xhci_ring_alloc(xhci, 1, true, mem_flags);
+                        xhci_ring_alloc(xhci, 1, true, false, mem_flags);
                 cur_ring = stream_info->stream_rings[cur_stream];
                 if (!cur_ring)
                         goto cleanup_rings;
@@ -549,8 +553,8 @@ struct xhci_stream_info *xhci_alloc_stream_info(struct xhci_hcd *xhci,
                 addr = cur_ring->first_seg->dma |
                         SCT_FOR_CTX(SCT_PRI_TR) |
                         cur_ring->cycle_state;
-                stream_info->stream_ctx_array[cur_stream].
-                        stream_ring = cpu_to_le64(addr);
+                stream_info->stream_ctx_array[cur_stream].stream_ring =
+                        cpu_to_le64(addr);
                 xhci_dbg(xhci, "Setting stream %d ring ptr to 0x%08llx\n",
                                 cur_stream, (unsigned long long) addr);
 
@@ -765,7 +769,7 @@ int xhci_alloc_virt_device(struct xhci_hcd *xhci, int slot_id,
         }
 
         /* Allocate endpoint 0 ring */
-        dev->eps[0].ring = xhci_ring_alloc(xhci, 1, true, flags);
+        dev->eps[0].ring = xhci_ring_alloc(xhci, 1, true, false, flags);
         if (!dev->eps[0].ring)
                 goto fail;
 
@@ -786,7 +790,7 @@ int xhci_alloc_virt_device(struct xhci_hcd *xhci, int slot_id,
         xhci_dbg(xhci, "Set slot id %d dcbaa entry %p to 0x%llx\n",
                  slot_id,
                  &xhci->dcbaa->dev_context_ptrs[slot_id],
-                 (unsigned long long) le64_to_cpu(xhci->dcbaa->dev_context_ptrs[slot_id]));
+                 le64_to_cpu(xhci->dcbaa->dev_context_ptrs[slot_id]));
 
         return 1;
 fail:
@@ -871,7 +875,6 @@ int xhci_setup_addressable_virt_dev(struct xhci_hcd *xhci, struct usb_device *ud
         struct xhci_virt_device *dev;
         struct xhci_ep_ctx      *ep0_ctx;
         struct xhci_slot_ctx    *slot_ctx;
-        struct xhci_input_control_ctx *ctrl_ctx;
         u32                     port_num;
         struct usb_device *top_dev;
 
@@ -883,26 +886,22 @@ int xhci_setup_addressable_virt_dev(struct xhci_hcd *xhci, struct usb_device *ud
                 return -EINVAL;
         }
         ep0_ctx = xhci_get_ep_ctx(xhci, dev->in_ctx, 0);
-        ctrl_ctx = xhci_get_input_control_ctx(xhci, dev->in_ctx);
         slot_ctx = xhci_get_slot_ctx(xhci, dev->in_ctx);
 
-        /* 2) New slot context and endpoint 0 context are valid*/
-        ctrl_ctx->add_flags = cpu_to_le32(SLOT_FLAG | EP0_FLAG);
-
         /* 3) Only the control endpoint is valid - one endpoint context */
-        slot_ctx->dev_info |= cpu_to_le32(LAST_CTX(1) | (u32) udev->route);
+        slot_ctx->dev_info |= cpu_to_le32(LAST_CTX(1) | udev->route);
         switch (udev->speed) {
         case USB_SPEED_SUPER:
-                slot_ctx->dev_info |= cpu_to_le32((u32) SLOT_SPEED_SS);
+                slot_ctx->dev_info |= cpu_to_le32(SLOT_SPEED_SS);
                 break;
         case USB_SPEED_HIGH:
-                slot_ctx->dev_info |= cpu_to_le32((u32) SLOT_SPEED_HS);
+                slot_ctx->dev_info |= cpu_to_le32(SLOT_SPEED_HS);
                 break;
         case USB_SPEED_FULL:
-                slot_ctx->dev_info |= cpu_to_le32((u32) SLOT_SPEED_FS);
+                slot_ctx->dev_info |= cpu_to_le32(SLOT_SPEED_FS);
                 break;
         case USB_SPEED_LOW:
-                slot_ctx->dev_info |= cpu_to_le32((u32) SLOT_SPEED_LS);
+                slot_ctx->dev_info |= cpu_to_le32(SLOT_SPEED_LS);
                 break;
         case USB_SPEED_WIRELESS:
                 xhci_dbg(xhci, "FIXME xHCI doesn't support wireless speeds\n");
@@ -916,7 +915,7 @@ int xhci_setup_addressable_virt_dev(struct xhci_hcd *xhci, struct usb_device *ud
         port_num = xhci_find_real_port_number(xhci, udev);
         if (!port_num)
                 return -EINVAL;
-        slot_ctx->dev_info2 |= cpu_to_le32((u32) ROOT_HUB_PORT(port_num));
+        slot_ctx->dev_info2 |= cpu_to_le32(ROOT_HUB_PORT(port_num));
         /* Set the port number in the virtual_device to the faked port number */
         for (top_dev = udev; top_dev->parent && top_dev->parent->parent;
                         top_dev = top_dev->parent)
@@ -1175,10 +1174,10 @@ int xhci_endpoint_init(struct xhci_hcd *xhci,
          */
         if (usb_endpoint_xfer_isoc(&ep->desc))
                 virt_dev->eps[ep_index].new_ring =
-                        xhci_ring_alloc(xhci, 8, true, mem_flags);
+                        xhci_ring_alloc(xhci, 8, true, true, mem_flags);
         else
                 virt_dev->eps[ep_index].new_ring =
-                        xhci_ring_alloc(xhci, 1, true, mem_flags);
+                        xhci_ring_alloc(xhci, 1, true, false, mem_flags);
         if (!virt_dev->eps[ep_index].new_ring) {
                 /* Attempt to use the ring cache */
                 if (virt_dev->num_rings_cached == 0)
@@ -1187,7 +1186,8 @@ int xhci_endpoint_init(struct xhci_hcd *xhci,
                         virt_dev->ring_cache[virt_dev->num_rings_cached];
                 virt_dev->ring_cache[virt_dev->num_rings_cached] = NULL;
                 virt_dev->num_rings_cached--;
-                xhci_reinit_cached_ring(xhci, virt_dev->eps[ep_index].new_ring);
+                xhci_reinit_cached_ring(xhci, virt_dev->eps[ep_index].new_ring,
+                        usb_endpoint_xfer_isoc(&ep->desc) ? true : false);
         }
         virt_dev->eps[ep_index].skip = false;
         ep_ring = virt_dev->eps[ep_index].new_ring;
@@ -2001,7 +2001,7 @@ int xhci_mem_init(struct xhci_hcd *xhci, gfp_t flags)
                 goto fail;
 
         /* Set up the command ring to have one segments for now. */
-        xhci->cmd_ring = xhci_ring_alloc(xhci, 1, true, flags);
+        xhci->cmd_ring = xhci_ring_alloc(xhci, 1, true, false, flags);
         if (!xhci->cmd_ring)
                 goto fail;
         xhci_dbg(xhci, "Allocated command ring at %p\n", xhci->cmd_ring);
@@ -2032,7 +2032,8 @@ int xhci_mem_init(struct xhci_hcd *xhci, gfp_t flags)
          * the event ring segment table (ERST).  Section 4.9.3.
          */
         xhci_dbg(xhci, "// Allocating event ring\n");
-        xhci->event_ring = xhci_ring_alloc(xhci, ERST_NUM_SEGS, false, flags);
+        xhci->event_ring = xhci_ring_alloc(xhci, ERST_NUM_SEGS, false, false,
+                                                flags);
         if (!xhci->event_ring)
                 goto fail;
         if (xhci_check_trb_in_td_math(xhci, flags) < 0)