USB: xhci: Always align output device contexts to 64 bytes.

Make sure the xHCI output device context is 64-byte aligned.  Previous
code was using the same structure for both the output device context and
the input control context.  Since the structure had 32 bytes of flags
before the device context, the output device context wouldn't be 64-byte
aligned.  Define a new structure to use for the output device context and
clean up the debugging for these two structures.

The copy of the device context in the input control context does *not*
need to be 64-byte aligned.

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

1 files changed, 63 insertions, 38 deletions

diff --git a/drivers/usb/host/xhci-dbg.c b/drivers/usb/host/xhci-dbg.c
index 6d62e4abe3c6..d77f8de11256 100644
--- a/drivers/usb/host/xhci-dbg.c
+++ b/drivers/usb/host/xhci-dbg.c
@@ -393,78 +393,103 @@ void xhci_dbg_cmd_ptrs(struct xhci_hcd *xhci)
                         upper_32_bits(val));
 }
 
-void xhci_dbg_ctx(struct xhci_hcd *xhci, struct xhci_device_control *ctx, dma_addr_t dma, unsigned int last_ep)
+dma_addr_t xhci_dbg_slot_ctx(struct xhci_hcd *xhci, struct xhci_slot_ctx *slot, dma_addr_t dma)
 {
-        int i, j;
-        int last_ep_ctx = 31;
         /* Fields are 32 bits wide, DMA addresses are in bytes */
         int field_size = 32 / 8;
-
-        xhci_dbg(xhci, "@%p (virt) @%08llx (dma) %#08x - drop flags\n",
-                        &ctx->drop_flags, (unsigned long long)dma,
-                        ctx->drop_flags);
-        dma += field_size;
-        xhci_dbg(xhci, "@%p (virt) @%08llx (dma) %#08x - add flags\n",
-                        &ctx->add_flags, (unsigned long long)dma,
-                        ctx->add_flags);
-        dma += field_size;
-        for (i = 0; i < 6; ++i) {
-                xhci_dbg(xhci, "@%p (virt) @%08llx (dma) %#08x - rsvd[%d]\n",
-                                &ctx->rsvd[i], (unsigned long long)dma,
-                                ctx->rsvd[i], i);
-                dma += field_size;
-        }
+        int i;
 
         xhci_dbg(xhci, "Slot Context:\n");
         xhci_dbg(xhci, "@%p (virt) @%08llx (dma) %#08x - dev_info\n",
-                        &ctx->slot.dev_info,
-                        (unsigned long long)dma, ctx->slot.dev_info);
+                        &slot->dev_info,
+                        (unsigned long long)dma, slot->dev_info);
         dma += field_size;
         xhci_dbg(xhci, "@%p (virt) @%08llx (dma) %#08x - dev_info2\n",
-                        &ctx->slot.dev_info2,
-                        (unsigned long long)dma, ctx->slot.dev_info2);
+                        &slot->dev_info2,
+                        (unsigned long long)dma, slot->dev_info2);
         dma += field_size;
         xhci_dbg(xhci, "@%p (virt) @%08llx (dma) %#08x - tt_info\n",
-                        &ctx->slot.tt_info,
-                        (unsigned long long)dma, ctx->slot.tt_info);
+                        &slot->tt_info,
+                        (unsigned long long)dma, slot->tt_info);
         dma += field_size;
         xhci_dbg(xhci, "@%p (virt) @%08llx (dma) %#08x - dev_state\n",
-                        &ctx->slot.dev_state,
-                        (unsigned long long)dma, ctx->slot.dev_state);
+                        &slot->dev_state,
+                        (unsigned long long)dma, slot->dev_state);
         dma += field_size;
         for (i = 0; i < 4; ++i) {
                 xhci_dbg(xhci, "@%p (virt) @%08llx (dma) %#08x - rsvd[%d]\n",
-                                &ctx->slot.reserved[i], (unsigned long long)dma,
-                                ctx->slot.reserved[i], i);
+                                &slot->reserved[i], (unsigned long long)dma,
+                                slot->reserved[i], i);
                 dma += field_size;
         }
 
+        return dma;
+}
+
+dma_addr_t xhci_dbg_ep_ctx(struct xhci_hcd *xhci, struct xhci_ep_ctx *ep, dma_addr_t dma, unsigned int last_ep)
+{
+        int i, j;
+        int last_ep_ctx = 31;
+        /* Fields are 32 bits wide, DMA addresses are in bytes */
+        int field_size = 32 / 8;
+
         if (last_ep < 31)
                 last_ep_ctx = last_ep + 1;
         for (i = 0; i < last_ep_ctx; ++i) {
                 xhci_dbg(xhci, "Endpoint %02d Context:\n", i);
                 xhci_dbg(xhci, "@%p (virt) @%08llx (dma) %#08x - ep_info\n",
-                                &ctx->ep[i].ep_info,
-                                (unsigned long long)dma, ctx->ep[i].ep_info);
+                                &ep[i].ep_info,
+                                (unsigned long long)dma, ep[i].ep_info);
                 dma += field_size;
                 xhci_dbg(xhci, "@%p (virt) @%08llx (dma) %#08x - ep_info2\n",
-                                &ctx->ep[i].ep_info2,
-                                (unsigned long long)dma, ctx->ep[i].ep_info2);
+                                &ep[i].ep_info2,
+                                (unsigned long long)dma, ep[i].ep_info2);
                 dma += field_size;
                 xhci_dbg(xhci, "@%p (virt) @%08llx (dma) %#08llx - deq\n",
-                                &ctx->ep[i].deq,
-                                (unsigned long long)dma, ctx->ep[i].deq);
+                                &ep[i].deq,
+                                (unsigned long long)dma, ep[i].deq);
                 dma += 2*field_size;
                 xhci_dbg(xhci, "@%p (virt) @%08llx (dma) %#08x - tx_info\n",
-                                &ctx->ep[i].tx_info,
-                                (unsigned long long)dma, ctx->ep[i].tx_info);
+                                &ep[i].tx_info,
+                                (unsigned long long)dma, ep[i].tx_info);
                 dma += field_size;
                 for (j = 0; j < 3; ++j) {
                         xhci_dbg(xhci, "@%p (virt) @%08llx (dma) %#08x - rsvd[%d]\n",
-                                        &ctx->ep[i].reserved[j],
+                                        &ep[i].reserved[j],
                                         (unsigned long long)dma,
-                                        ctx->ep[i].reserved[j], j);
+                                        ep[i].reserved[j], j);
                         dma += field_size;
                 }
         }
+        return dma;
+}
+
+void xhci_dbg_ctx(struct xhci_hcd *xhci, struct xhci_device_control *ctx, dma_addr_t dma, unsigned int last_ep)
+{
+        int i;
+        /* Fields are 32 bits wide, DMA addresses are in bytes */
+        int field_size = 32 / 8;
+
+        xhci_dbg(xhci, "@%p (virt) @%08llx (dma) %#08x - drop flags\n",
+                        &ctx->drop_flags, (unsigned long long)dma,
+                        ctx->drop_flags);
+        dma += field_size;
+        xhci_dbg(xhci, "@%p (virt) @%08llx (dma) %#08x - add flags\n",
+                        &ctx->add_flags, (unsigned long long)dma,
+                        ctx->add_flags);
+        dma += field_size;
+        for (i = 0; i < 6; ++i) {
+                xhci_dbg(xhci, "@%p (virt) @%08llx (dma) %#08x - rsvd[%d]\n",
+                                &ctx->rsvd[i], (unsigned long long)dma,
+                                ctx->rsvd[i], i);
+                dma += field_size;
+        }
+        dma = xhci_dbg_slot_ctx(xhci, &ctx->slot, dma);
+        dma = xhci_dbg_ep_ctx(xhci, ctx->ep, dma, last_ep);
+}
+
+void xhci_dbg_device_ctx(struct xhci_hcd *xhci, struct xhci_device_ctx *ctx, dma_addr_t dma, unsigned int last_ep)
+{
+        dma = xhci_dbg_slot_ctx(xhci, &ctx->slot, dma);
+        dma = xhci_dbg_ep_ctx(xhci, ctx->ep, dma, last_ep);
 }