usb: xhci: remove xhci_dbg_ctx()

XHCI context changes have already been traced by the trace
events. It's unnecessary to put the same message in kernel
log. This patch removes the use of xhci_dbg_ctx().

Signed-off-by: Lu Baolu <baolu.lu@linux.intel.com>
Signed-off-by: Mathias Nyman <mathias.nyman@linux.intel.com>
Signed-off-by: Greg Kroah-Hartman <gregkh@linuxfoundation.org>

3 files changed, 0 insertions, 181 deletions

diff --git a/drivers/usb/host/xhci-dbg.c b/drivers/usb/host/xhci-dbg.c
index dc0194b87b74..2c83b37ae8f2 100644
--- a/drivers/usb/host/xhci-dbg.c
+++ b/drivers/usb/host/xhci-dbg.c
@@ -283,19 +283,6 @@ void xhci_dbg_cmd_ptrs(struct xhci_hcd *xhci)
                         upper_32_bits(val));
 }
 
-/* Print the last 32 bytes for 64-byte contexts */
-static void dbg_rsvd64(struct xhci_hcd *xhci, u64 *ctx, dma_addr_t dma)
-{
-        int i;
-        for (i = 0; i < 4; i++) {
-                xhci_dbg(xhci, "@%p (virt) @%08llx "
-                         "(dma) %#08llx - rsvd64[%d]\n",
-                         &ctx[4 + i], (unsigned long long)dma,
-                         ctx[4 + i], i);
-                dma += 8;
-        }
-}
-
 char *xhci_get_slot_state(struct xhci_hcd *xhci,
                 struct xhci_container_ctx *ctx)
 {
@@ -305,136 +292,6 @@ char *xhci_get_slot_state(struct xhci_hcd *xhci,
         return xhci_slot_state_string(state);
 }
 
-static void xhci_dbg_slot_ctx(struct xhci_hcd *xhci, struct xhci_container_ctx *ctx)
-{
-        /* Fields are 32 bits wide, DMA addresses are in bytes */
-        int field_size = 32 / 8;
-        int i;
-
-        struct xhci_slot_ctx *slot_ctx = xhci_get_slot_ctx(xhci, ctx);
-        dma_addr_t dma = ctx->dma +
-                ((unsigned long)slot_ctx - (unsigned long)ctx->bytes);
-        int csz = HCC_64BYTE_CONTEXT(xhci->hcc_params);
-
-        xhci_dbg(xhci, "Slot Context:\n");
-        xhci_dbg(xhci, "@%p (virt) @%08llx (dma) %#08x - dev_info\n",
-                        &slot_ctx->dev_info,
-                        (unsigned long long)dma, slot_ctx->dev_info);
-        dma += field_size;
-        xhci_dbg(xhci, "@%p (virt) @%08llx (dma) %#08x - dev_info2\n",
-                        &slot_ctx->dev_info2,
-                        (unsigned long long)dma, slot_ctx->dev_info2);
-        dma += field_size;
-        xhci_dbg(xhci, "@%p (virt) @%08llx (dma) %#08x - tt_info\n",
-                        &slot_ctx->tt_info,
-                        (unsigned long long)dma, slot_ctx->tt_info);
-        dma += field_size;
-        xhci_dbg(xhci, "@%p (virt) @%08llx (dma) %#08x - dev_state\n",
-                        &slot_ctx->dev_state,
-                        (unsigned long long)dma, slot_ctx->dev_state);
-        dma += field_size;
-        for (i = 0; i < 4; i++) {
-                xhci_dbg(xhci, "@%p (virt) @%08llx (dma) %#08x - rsvd[%d]\n",
-                                &slot_ctx->reserved[i], (unsigned long long)dma,
-                                slot_ctx->reserved[i], i);
-                dma += field_size;
-        }
-
-        if (csz)
-                dbg_rsvd64(xhci, (u64 *)slot_ctx, dma);
-}
-
-static void xhci_dbg_ep_ctx(struct xhci_hcd *xhci,
-                     struct xhci_container_ctx *ctx,
-                     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;
-        int csz = HCC_64BYTE_CONTEXT(xhci->hcc_params);
-
-        if (last_ep < 31)
-                last_ep_ctx = last_ep + 1;
-        for (i = 0; i < last_ep_ctx; i++) {
-                unsigned int epaddr = xhci_get_endpoint_address(i);
-                struct xhci_ep_ctx *ep_ctx = xhci_get_ep_ctx(xhci, ctx, i);
-                dma_addr_t dma = ctx->dma +
-                        ((unsigned long)ep_ctx - (unsigned long)ctx->bytes);
-
-                xhci_dbg(xhci, "%s Endpoint %02d Context (ep_index %02d):\n",
-                                usb_endpoint_out(epaddr) ? "OUT" : "IN",
-                                epaddr & USB_ENDPOINT_NUMBER_MASK, i);
-                xhci_dbg(xhci, "@%p (virt) @%08llx (dma) %#08x - ep_info\n",
-                                &ep_ctx->ep_info,
-                                (unsigned long long)dma, ep_ctx->ep_info);
-                dma += field_size;
-                xhci_dbg(xhci, "@%p (virt) @%08llx (dma) %#08x - ep_info2\n",
-                                &ep_ctx->ep_info2,
-                                (unsigned long long)dma, ep_ctx->ep_info2);
-                dma += field_size;
-                xhci_dbg(xhci, "@%p (virt) @%08llx (dma) %#08llx - deq\n",
-                                &ep_ctx->deq,
-                                (unsigned long long)dma, ep_ctx->deq);
-                dma += 2*field_size;
-                xhci_dbg(xhci, "@%p (virt) @%08llx (dma) %#08x - tx_info\n",
-                                &ep_ctx->tx_info,
-                                (unsigned long long)dma, ep_ctx->tx_info);
-                dma += field_size;
-                for (j = 0; j < 3; j++) {
-                        xhci_dbg(xhci, "@%p (virt) @%08llx (dma) %#08x - rsvd[%d]\n",
-                                        &ep_ctx->reserved[j],
-                                        (unsigned long long)dma,
-                                        ep_ctx->reserved[j], j);
-                        dma += field_size;
-                }
-
-                if (csz)
-                        dbg_rsvd64(xhci, (u64 *)ep_ctx, dma);
-        }
-}
-
-void xhci_dbg_ctx(struct xhci_hcd *xhci,
-                  struct xhci_container_ctx *ctx,
-                  unsigned int last_ep)
-{
-        int i;
-        /* Fields are 32 bits wide, DMA addresses are in bytes */
-        int field_size = 32 / 8;
-        dma_addr_t dma = ctx->dma;
-        int csz = HCC_64BYTE_CONTEXT(xhci->hcc_params);
-
-        if (ctx->type == XHCI_CTX_TYPE_INPUT) {
-                struct xhci_input_control_ctx *ctrl_ctx =
-                        xhci_get_input_control_ctx(ctx);
-                if (!ctrl_ctx) {
-                        xhci_warn(xhci, "Could not get input context, bad type.\n");
-                        return;
-                }
-
-                xhci_dbg(xhci, "@%p (virt) @%08llx (dma) %#08x - drop flags\n",
-                         &ctrl_ctx->drop_flags, (unsigned long long)dma,
-                         ctrl_ctx->drop_flags);
-                dma += field_size;
-                xhci_dbg(xhci, "@%p (virt) @%08llx (dma) %#08x - add flags\n",
-                         &ctrl_ctx->add_flags, (unsigned long long)dma,
-                         ctrl_ctx->add_flags);
-                dma += field_size;
-                for (i = 0; i < 6; i++) {
-                        xhci_dbg(xhci, "@%p (virt) @%08llx (dma) %#08x - rsvd2[%d]\n",
-                                 &ctrl_ctx->rsvd2[i], (unsigned long long)dma,
-                                 ctrl_ctx->rsvd2[i], i);
-                        dma += field_size;
-                }
-
-                if (csz)
-                        dbg_rsvd64(xhci, (u64 *)ctrl_ctx, dma);
-        }
-
-        xhci_dbg_slot_ctx(xhci, ctx);
-        xhci_dbg_ep_ctx(xhci, ctx, last_ep);
-}
-
 void xhci_dbg_trace(struct xhci_hcd *xhci, void (*trace)(struct va_format *),
                         const char *fmt, ...)
 {
diff --git a/drivers/usb/host/xhci.c b/drivers/usb/host/xhci.c
index 245ed40ea864..ba0e0e44c031 100644
--- a/drivers/usb/host/xhci.c
+++ b/drivers/usb/host/xhci.c
@@ -1305,11 +1305,6 @@ static int xhci_check_maxpacket(struct xhci_hcd *xhci, unsigned int slot_id,
                 ctrl_ctx->add_flags = cpu_to_le32(EP0_FLAG);
                 ctrl_ctx->drop_flags = 0;
 
-                xhci_dbg(xhci, "Slot %d input context\n", slot_id);
-                xhci_dbg_ctx(xhci, command->in_ctx, ep_index);
-                xhci_dbg(xhci, "Slot %d output context\n", slot_id);
-                xhci_dbg_ctx(xhci, out_ctx, ep_index);
-
                 ret = xhci_configure_endpoint(xhci, urb->dev, command,
                                 true, false);
 
@@ -1857,7 +1852,6 @@ static int xhci_evaluate_context_result(struct xhci_hcd *xhci,
                 struct usb_device *udev, u32 *cmd_status)
 {
         int ret;
-        struct xhci_virt_device *virt_dev = xhci->devs[udev->slot_id];
 
         switch (*cmd_status) {
         case COMP_COMMAND_ABORTED:
@@ -1878,7 +1872,6 @@ static int xhci_evaluate_context_result(struct xhci_hcd *xhci,
         case COMP_CONTEXT_STATE_ERROR:
                 dev_warn(&udev->dev,
                         "WARN: invalid context state for evaluate context command.\n");
-                xhci_dbg_ctx(xhci, virt_dev->out_ctx, 1);
                 ret = -EINVAL;
                 break;
         case COMP_INCOMPATIBLE_DEVICE_ERROR:
@@ -2757,9 +2750,6 @@ static int xhci_check_bandwidth(struct usb_hcd *hcd, struct usb_device *udev)
                         break;
                 }
         }
-        xhci_dbg(xhci, "New Input Control Context:\n");
-        xhci_dbg_ctx(xhci, virt_dev->in_ctx,
-                     LAST_CTX_TO_EP_NUM(le32_to_cpu(slot_ctx->dev_info)));
 
         ret = xhci_configure_endpoint(xhci, udev, command,
                         false, false);
@@ -2767,10 +2757,6 @@ static int xhci_check_bandwidth(struct usb_hcd *hcd, struct usb_device *udev)
                 /* Callee should call reset_bandwidth() */
                 goto command_cleanup;
 
-        xhci_dbg(xhci, "Output context after successful config ep cmd:\n");
-        xhci_dbg_ctx(xhci, virt_dev->out_ctx,
-                     LAST_CTX_TO_EP_NUM(le32_to_cpu(slot_ctx->dev_info)));
-
         /* Free any rings that were dropped, but not changed. */
         for (i = 1; i < 31; i++) {
                 if ((le32_to_cpu(ctrl_ctx->drop_flags) & (1 << (i + 1))) &&
@@ -2837,9 +2823,6 @@ static void xhci_setup_input_ctx_for_config_ep(struct xhci_hcd *xhci,
         ctrl_ctx->drop_flags = cpu_to_le32(drop_flags);
         xhci_slot_copy(xhci, in_ctx, out_ctx);
         ctrl_ctx->add_flags |= cpu_to_le32(SLOT_FLAG);
-
-        xhci_dbg(xhci, "Input Context:\n");
-        xhci_dbg_ctx(xhci, in_ctx, xhci_last_valid_endpoint(add_flags));
 }
 
 static void xhci_setup_input_ctx_for_quirk(struct xhci_hcd *xhci,
@@ -3552,9 +3535,6 @@ static int xhci_discover_or_reset_device(struct usb_hcd *hcd,
         }
         /* If necessary, update the number of active TTs on this root port */
         xhci_update_tt_active_eps(xhci, virt_dev, old_active_eps);
-
-        xhci_dbg(xhci, "Output context after successful reset device cmd:\n");
-        xhci_dbg_ctx(xhci, virt_dev->out_ctx, last_freed_endpoint);
         ret = 0;
 
 command_cleanup:
@@ -3854,8 +3834,6 @@ static int xhci_setup_device(struct usb_hcd *hcd, struct usb_device *udev,
         ctrl_ctx->add_flags = cpu_to_le32(SLOT_FLAG | EP0_FLAG);
         ctrl_ctx->drop_flags = 0;
 
-        xhci_dbg(xhci, "Slot ID %d Input Context:\n", udev->slot_id);
-        xhci_dbg_ctx(xhci, virt_dev->in_ctx, 2);
         trace_xhci_address_ctx(xhci, virt_dev->in_ctx,
                                 le32_to_cpu(slot_ctx->dev_info) >> 27);
 
@@ -3908,8 +3886,6 @@ static int xhci_setup_device(struct usb_hcd *hcd, struct usb_device *udev,
                 xhci_err(xhci,
                          "ERROR: unexpected setup %s command completion code 0x%x.\n",
                          act, command->status);
-                xhci_dbg(xhci, "Slot ID %d Output Context:\n", udev->slot_id);
-                xhci_dbg_ctx(xhci, virt_dev->out_ctx, 2);
                 trace_xhci_address_ctx(xhci, virt_dev->out_ctx, 1);
                 ret = -EINVAL;
                 break;
@@ -3928,12 +3904,8 @@ static int xhci_setup_device(struct usb_hcd *hcd, struct usb_device *udev,
         xhci_dbg_trace(xhci, trace_xhci_dbg_address,
                         "Output Context DMA address = %#08llx",
                         (unsigned long long)virt_dev->out_ctx->dma);
-        xhci_dbg(xhci, "Slot ID %d Input Context:\n", udev->slot_id);
-        xhci_dbg_ctx(xhci, virt_dev->in_ctx, 2);
         trace_xhci_address_ctx(xhci, virt_dev->in_ctx,
                                 le32_to_cpu(slot_ctx->dev_info) >> 27);
-        xhci_dbg(xhci, "Slot ID %d Output Context:\n", udev->slot_id);
-        xhci_dbg_ctx(xhci, virt_dev->out_ctx, 2);
         /*
          * USB core uses address 1 for the roothubs, so we add one to the
          * address given back to us by the HC.
@@ -4038,14 +4010,10 @@ static int __maybe_unused xhci_change_max_exit_latency(struct xhci_hcd *xhci,
 
         xhci_dbg_trace(xhci, trace_xhci_dbg_context_change,
                         "Set up evaluate context for LPM MEL change.");
-        xhci_dbg(xhci, "Slot %u Input Context:\n", udev->slot_id);
-        xhci_dbg_ctx(xhci, command->in_ctx, 0);
 
         /* Issue and wait for the evaluate context command. */
         ret = xhci_configure_endpoint(xhci, udev, command,
                         true, true);
-        xhci_dbg(xhci, "Slot %u Output Context:\n", udev->slot_id);
-        xhci_dbg_ctx(xhci, virt_dev->out_ctx, 0);
 
         if (!ret) {
                 spin_lock_irqsave(&xhci->lock, flags);
@@ -4813,8 +4781,6 @@ static int xhci_update_hub_device(struct usb_hcd *hcd, struct usb_device *hdev,
         xhci_dbg(xhci, "Set up %s for hub device.\n",
                         (xhci->hci_version > 0x95) ?
                         "configure endpoint" : "evaluate context");
-        xhci_dbg(xhci, "Slot %u Input Context:\n", hdev->slot_id);
-        xhci_dbg_ctx(xhci, config_cmd->in_ctx, 0);
 
         /* Issue and wait for the configure endpoint or
          * evaluate context command.
@@ -4826,9 +4792,6 @@ static int xhci_update_hub_device(struct usb_hcd *hcd, struct usb_device *hdev,
                 ret = xhci_configure_endpoint(xhci, hdev, config_cmd,
                                 true, false);
 
-        xhci_dbg(xhci, "Slot %u Output Context:\n", hdev->slot_id);
-        xhci_dbg_ctx(xhci, vdev->out_ctx, 0);
-
         xhci_free_command(xhci, config_cmd);
         return ret;
 }
diff --git a/drivers/usb/host/xhci.h b/drivers/usb/host/xhci.h
index aef4fd55f3dc..04e041feba3c 100644
--- a/drivers/usb/host/xhci.h
+++ b/drivers/usb/host/xhci.h
@@ -1923,7 +1923,6 @@ void xhci_dbg_regs(struct xhci_hcd *xhci);
 void xhci_print_run_regs(struct xhci_hcd *xhci);
 void xhci_dbg_erst(struct xhci_hcd *xhci, struct xhci_erst *erst);
 void xhci_dbg_cmd_ptrs(struct xhci_hcd *xhci);
-void xhci_dbg_ctx(struct xhci_hcd *xhci, struct xhci_container_ctx *ctx, unsigned int last_ep);
 char *xhci_get_slot_state(struct xhci_hcd *xhci,
                 struct xhci_container_ctx *ctx);
 void xhci_dbg_trace(struct xhci_hcd *xhci, void (*trace)(struct va_format *),