| From d28bc3b64ca7c8cc5b061893105679fe20c54542 Mon Sep 17 00:00:00 2001 |
| From: Lu Baolu <baolu.lu@linux.intel.com> |
| Date: Fri, 7 Apr 2017 17:57:09 +0300 |
| Subject: [PATCH 195/286] 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> |
| (cherry picked from commit c8844f2ddb0d2bc42a813c567ad4240759f373bd) |
| Signed-off-by: Simon Horman <horms+renesas@verge.net.au> |
| --- |
| drivers/usb/host/xhci-dbg.c | 143 -------------------------------------------- |
| drivers/usb/host/xhci.c | 37 ----------- |
| drivers/usb/host/xhci.h | 1 |
| 3 files changed, 181 deletions(-) |
| |
| --- 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 * |
| 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_hc |
| 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, ...) |
| { |
| --- a/drivers/usb/host/xhci.c |
| +++ b/drivers/usb/host/xhci.c |
| @@ -1308,11 +1308,6 @@ static int xhci_check_maxpacket(struct x |
| 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); |
| |
| @@ -1860,7 +1855,6 @@ static int xhci_evaluate_context_result( |
| 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: |
| @@ -1881,7 +1875,6 @@ static int xhci_evaluate_context_result( |
| 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: |
| @@ -2760,9 +2753,6 @@ static int xhci_check_bandwidth(struct u |
| 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); |
| @@ -2770,10 +2760,6 @@ static int xhci_check_bandwidth(struct u |
| /* 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))) && |
| @@ -2840,9 +2826,6 @@ static void xhci_setup_input_ctx_for_con |
| 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, |
| @@ -3555,9 +3538,6 @@ static int xhci_discover_or_reset_device |
| } |
| /* 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: |
| @@ -3857,8 +3837,6 @@ static int xhci_setup_device(struct usb_ |
| 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); |
| |
| @@ -3911,8 +3889,6 @@ static int xhci_setup_device(struct usb_ |
| 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; |
| @@ -3931,12 +3907,8 @@ static int xhci_setup_device(struct usb_ |
| 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. |
| @@ -4041,14 +4013,10 @@ static int __maybe_unused xhci_change_ma |
| |
| 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); |
| @@ -4816,8 +4784,6 @@ static int xhci_update_hub_device(struct |
| 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. |
| @@ -4829,9 +4795,6 @@ static int xhci_update_hub_device(struct |
| 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; |
| } |
| --- a/drivers/usb/host/xhci.h |
| +++ b/drivers/usb/host/xhci.h |
| @@ -1926,7 +1926,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 *), |
