Commit b2497509 authored by Xenia Ragiadakou's avatar Xenia Ragiadakou Committed by Sarah Sharp
Browse files

xhci: remove CONFIG_USB_XHCI_HCD_DEBUGGING and unused code 



CONFIG_USB_XHCI_HCD_DEBUGGING option is used to enable
verbose debugging output for the xHCI host controller
driver.

In the current version of the xhci-hcd driver, this
option must be turned on, in order for the debugging
log messages to be displayed, and users may need to
recompile the linux kernel to obtain debugging
information that will help them track down problems.

This patch removes the above debug option to enable
debugging log messages at all times.
The aim of this is to rely on the debugfs and the
dynamic debugging feature for fine-grained management
of debugging messages and to not force users to set
the debug config option and compile the linux kernel
in order to have access in that information.

This patch, also, removes the XHCI_DEBUG symbol and the
functions dma_to_stream_ring(), xhci_test_radix_tree()
and xhci_event_ring_work() that are not useful anymore.

Signed-off-by: default avatarXenia Ragiadakou <burzalodowa@gmail.com>
Signed-off-by: default avatarSarah Sharp <sarah.a.sharp@linux.intel.com>
parent 5c1127d3

drivers/usb/host/Kconfig

+0 −9
Original line number Diff line number Diff line
@@ -29,15 +29,6 @@ if USB_XHCI_HCD 
config USB_XHCI_PLATFORM

	tristate



config USB_XHCI_HCD_DEBUGGING

	bool "Debugging for the xHCI host controller"

	---help---

	  Say 'Y' to turn on debugging for the xHCI host controller driver.

	  This will spew debugging output, even in interrupt context.

	  This should only be used for debugging xHCI driver bugs.



	  If unsure, say N.



endif # USB_XHCI_HCD



config USB_EHCI_HCD

drivers/usb/host/xhci-mem.c

+0 −70
Original line number Diff line number Diff line
@@ -481,17 +481,6 @@ struct xhci_ring *xhci_dma_to_transfer_ring( 
	return ep->ring;

}



/* Only use this when you know stream_info is valid */

#ifdef CONFIG_USB_XHCI_HCD_DEBUGGING

static struct xhci_ring *dma_to_stream_ring(

		struct xhci_stream_info *stream_info,

		u64 address)

{

	return radix_tree_lookup(&stream_info->trb_address_map,

			address >> TRB_SEGMENT_SHIFT);

}

#endif	/* CONFIG_USB_XHCI_HCD_DEBUGGING */



struct xhci_ring *xhci_stream_id_to_ring(

		struct xhci_virt_device *dev,

		unsigned int ep_index,
@@ -509,58 +498,6 @@ struct xhci_ring *xhci_stream_id_to_ring( 
	return ep->stream_info->stream_rings[stream_id];

}



#ifdef CONFIG_USB_XHCI_HCD_DEBUGGING

static int xhci_test_radix_tree(struct xhci_hcd *xhci,

		unsigned int num_streams,

		struct xhci_stream_info *stream_info)

{

	u32 cur_stream;

	struct xhci_ring *cur_ring;

	u64 addr;



	for (cur_stream = 1; cur_stream < num_streams; cur_stream++) {

		struct xhci_ring *mapped_ring;

		int trb_size = sizeof(union xhci_trb);



		cur_ring = stream_info->stream_rings[cur_stream];

		for (addr = cur_ring->first_seg->dma;

				addr < cur_ring->first_seg->dma + TRB_SEGMENT_SIZE;

				addr += trb_size) {

			mapped_ring = dma_to_stream_ring(stream_info, addr);

			if (cur_ring != mapped_ring) {

				xhci_warn(xhci, "WARN: DMA address 0x%08llx "

						"didn't map to stream ID %u; "

						"mapped to ring %p\n",

						(unsigned long long) addr,

						cur_stream,

						mapped_ring);

				return -EINVAL;

			}

		}

		/* One TRB after the end of the ring segment shouldn't return a

		 * pointer to the current ring (although it may be a part of a

		 * different ring).

		 */

		mapped_ring = dma_to_stream_ring(stream_info, addr);

		if (mapped_ring != cur_ring) {

			/* One TRB before should also fail */

			addr = cur_ring->first_seg->dma - trb_size;

			mapped_ring = dma_to_stream_ring(stream_info, addr);

		}

		if (mapped_ring == cur_ring) {

			xhci_warn(xhci, "WARN: Bad DMA address 0x%08llx "

					"mapped to valid stream ID %u; "

					"mapped ring = %p\n",

					(unsigned long long) addr,

					cur_stream,

					mapped_ring);

			return -EINVAL;

		}

	}

	return 0;

}

#endif	/* CONFIG_USB_XHCI_HCD_DEBUGGING */



/*

 * Change an endpoint's internal structure so it supports stream IDs.  The

 * number of requested streams includes stream 0, which cannot be used by device
@@ -687,13 +624,6 @@ struct xhci_stream_info *xhci_alloc_stream_info(struct xhci_hcd *xhci, 
	 * was any other way, the host controller would assume the ring is

	 * "empty" and wait forever for data to be queued to that stream ID).

	 */

#if XHCI_DEBUG

	/* Do a little test on the radix tree to make sure it returns the

	 * correct values.

	 */

	if (xhci_test_radix_tree(xhci, num_streams, stream_info))

		goto cleanup_rings;

#endif



	return stream_info;

drivers/usb/host/xhci.c

+0 −74
Original line number Diff line number Diff line
@@ -528,57 +528,6 @@ int xhci_init(struct usb_hcd *hcd) 
/*-------------------------------------------------------------------------*/





#ifdef CONFIG_USB_XHCI_HCD_DEBUGGING

static void xhci_event_ring_work(unsigned long arg)

{

	unsigned long flags;

	int temp;

	u64 temp_64;

	struct xhci_hcd *xhci = (struct xhci_hcd *) arg;

	int i, j;



	xhci_dbg(xhci, "Poll event ring: %lu\n", jiffies);



	spin_lock_irqsave(&xhci->lock, flags);

	temp = xhci_readl(xhci, &xhci->op_regs->status);

	xhci_dbg(xhci, "op reg status = 0x%x\n", temp);

	if (temp == 0xffffffff || (xhci->xhc_state & XHCI_STATE_DYING) ||

			(xhci->xhc_state & XHCI_STATE_HALTED)) {

		xhci_dbg(xhci, "HW died, polling stopped.\n");

		spin_unlock_irqrestore(&xhci->lock, flags);

		return;

	}



	temp = xhci_readl(xhci, &xhci->ir_set->irq_pending);

	xhci_dbg(xhci, "ir_set 0 pending = 0x%x\n", temp);

	xhci_dbg(xhci, "HC error bitmask = 0x%x\n", xhci->error_bitmask);

	xhci->error_bitmask = 0;

	xhci_dbg(xhci, "Event ring:\n");

	xhci_debug_segment(xhci, xhci->event_ring->deq_seg);

	xhci_dbg_ring_ptrs(xhci, xhci->event_ring);

	temp_64 = xhci_read_64(xhci, &xhci->ir_set->erst_dequeue);

	temp_64 &= ~ERST_PTR_MASK;

	xhci_dbg(xhci, "ERST deq = 64'h%0lx\n", (long unsigned int) temp_64);

	xhci_dbg(xhci, "Command ring:\n");

	xhci_debug_segment(xhci, xhci->cmd_ring->deq_seg);

	xhci_dbg_ring_ptrs(xhci, xhci->cmd_ring);

	xhci_dbg_cmd_ptrs(xhci);

	for (i = 0; i < MAX_HC_SLOTS; ++i) {

		if (!xhci->devs[i])

			continue;

		for (j = 0; j < 31; ++j) {

			xhci_dbg_ep_rings(xhci, i, j, &xhci->devs[i]->eps[j]);

		}

	}

	spin_unlock_irqrestore(&xhci->lock, flags);



	if (!xhci->zombie)

		mod_timer(&xhci->event_ring_timer, jiffies + POLL_TIMEOUT * HZ);

	else

		xhci_dbg(xhci, "Quit polling the event ring.\n");

}

#endif



static int xhci_run_finished(struct xhci_hcd *xhci)

{

	if (xhci_start(xhci)) {
@@ -628,17 +577,6 @@ int xhci_run(struct usb_hcd *hcd) 
	if (ret)

		return ret;



#ifdef CONFIG_USB_XHCI_HCD_DEBUGGING

	init_timer(&xhci->event_ring_timer);

	xhci->event_ring_timer.data = (unsigned long) xhci;

	xhci->event_ring_timer.function = xhci_event_ring_work;

	/* Poll the event ring */

	xhci->event_ring_timer.expires = jiffies + POLL_TIMEOUT * HZ;

	xhci->zombie = 0;

	xhci_dbg(xhci, "Setting event ring polling timer\n");

	add_timer(&xhci->event_ring_timer);

#endif



	xhci_dbg(xhci, "Command ring memory map follows:\n");

	xhci_debug_ring(xhci, xhci->cmd_ring);

	xhci_dbg_ring_ptrs(xhci, xhci->cmd_ring);
@@ -725,12 +663,6 @@ void xhci_stop(struct usb_hcd *hcd) 


	xhci_cleanup_msix(xhci);



#ifdef CONFIG_USB_XHCI_HCD_DEBUGGING

	/* Tell the event ring poll function not to reschedule */

	xhci->zombie = 1;

	del_timer_sync(&xhci->event_ring_timer);

#endif



	/* Deleting Compliance Mode Recovery Timer */

	if ((xhci->quirks & XHCI_COMP_MODE_QUIRK) &&

			(!(xhci_all_ports_seen_u0(xhci)))) {
@@ -1011,12 +943,6 @@ int xhci_resume(struct xhci_hcd *xhci, bool hibernated) 
		spin_unlock_irq(&xhci->lock);

		xhci_cleanup_msix(xhci);



#ifdef CONFIG_USB_XHCI_HCD_DEBUGGING

		/* Tell the event ring poll function not to reschedule */

		xhci->zombie = 1;

		del_timer_sync(&xhci->event_ring_timer);

#endif



		xhci_dbg(xhci, "// Disabling event ring interrupts\n");

		temp = xhci_readl(xhci, &xhci->op_regs->status);

		xhci_writel(xhci, temp & ~STS_EINT, &xhci->op_regs->status);

drivers/usb/host/xhci.h

+1 −12
Original line number Diff line number Diff line
@@ -1490,11 +1490,6 @@ struct xhci_hcd { 
	struct dma_pool	*small_streams_pool;

	struct dma_pool	*medium_streams_pool;



#ifdef CONFIG_USB_XHCI_HCD_DEBUGGING

	/* Poll the rings - for debugging */

	struct timer_list	event_ring_timer;

	int			zombie;

#endif

	/* Host controller watchdog timer structures */

	unsigned int		xhc_state;
@@ -1579,14 +1574,8 @@ static inline struct usb_hcd *xhci_to_hcd(struct xhci_hcd *xhci) 
	return xhci->main_hcd;

}



#ifdef CONFIG_USB_XHCI_HCD_DEBUGGING

#define XHCI_DEBUG	1

#else

#define XHCI_DEBUG	0

#endif



#define xhci_dbg(xhci, fmt, args...) \

	do { if (XHCI_DEBUG) dev_dbg(xhci_to_hcd(xhci)->self.controller , fmt , ## args); } while (0)

	dev_dbg(xhci_to_hcd(xhci)->self.controller , fmt , ## args)

#define xhci_err(xhci, fmt, args...) \

	dev_err(xhci_to_hcd(xhci)->self.controller , fmt , ## args)

#define xhci_warn(xhci, fmt, args...) \

CRA Git | Maintained and supported by SUSTech CRA and CCSE