Donate to e Foundation | Murena handsets with /e/OS | Own a part of Murena! Learn more

Commit c8844f2d authored by Lu Baolu's avatar Lu Baolu Committed by Greg Kroah-Hartman
Browse files

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: default avatarLu Baolu <baolu.lu@linux.intel.com>
Signed-off-by: default avatarMathias Nyman <mathias.nyman@linux.intel.com>
Signed-off-by: default avatarGreg Kroah-Hartman <gregkh@linuxfoundation.org>
parent 8c10152e

drivers/usb/host/xhci-dbg.c

+0 −143
Original line number Diff line number Diff line
@@ -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, ...)

{

drivers/usb/host/xhci.c

+0 −37
Original line number Diff line number Diff line
@@ -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;

}

drivers/usb/host/xhci.h

+0 −1
Original line number Diff line number Diff line
@@ -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 *),