Merge "usb: dwc3: Keep track of interrupt statistics" (33affceb) · Commits · e / devices / android_kernel_sony_msm8994

drivers/usb/dwc3/core.h

+32 −0

Original line number	Diff line number	Diff line
		@@ -445,6 +445,35 @@ struct dwc3_event_buffer {
		struct dwc3 *dwc;
		};

		struct dwc3_gadget_events {
		unsigned int disconnect;
		unsigned int reset;
		unsigned int connect;
		unsigned int wakeup;
		unsigned int link_status_change;
		unsigned int eopf;
		unsigned int suspend;
		unsigned int sof;
		unsigned int erratic_error;
		unsigned int overflow;
		unsigned int vendor_dev_test_lmp;
		unsigned int cmdcmplt;
		unsigned int unknown_event;
		};

		struct dwc3_ep_events {
		unsigned int xfercomplete;
		unsigned int xfernotready;
		unsigned int control_data;
		unsigned int control_status;
		unsigned int xferinprogress;
		unsigned int rxtxfifoevent;
		unsigned int streamevent;
		unsigned int epcmdcomplete;
		unsigned int cmdcmplt;
		unsigned int unknown_event;
		};

		#define DWC3_EP_FLAG_STALLED (1 << 0)
		#define DWC3_EP_FLAG_WEDGED (1 << 1)

		@@ -475,6 +504,7 @@ struct dwc3_event_buffer {
		* @name: a human readable name e.g. ep1out-bulk
		* @direction: true for TX, false for RX
		* @stream_capable: true when streams are enabled
		* @dbg_ep_events: different events counter for endpoint
		*/
		struct dwc3_ep {
		struct usb_ep endpoint;
		@@ -511,6 +541,7 @@ struct dwc3_ep {

		unsigned direction:1;
		unsigned stream_capable:1;
		struct dwc3_ep_events dbg_ep_events;
		};

		enum dwc3_phy {
		@@ -834,6 +865,7 @@ struct dwc3 {
		bool core_reset_after_phy_init;
		bool err_evt_seen;
		bool hsphy_auto_suspend_disable;
		struct dwc3_gadget_events dbg_gadget_events;
		};

		/* -------------------------------------------------------------------------- */

drivers/usb/dwc3/debugfs.c

+111 −0

Original line number	Diff line number	Diff line
		@@ -1040,6 +1040,109 @@ const struct file_operations dwc3_gadget_dbg_data_fops = {
		.release = single_release,
		};

		static ssize_t dwc3_store_int_events(struct file *file,
		const char __user ubuf, size_t count, loff_t ppos)
		{
		int clear_stats, i;
		unsigned long flags;
		struct seq_file *s = file->private_data;
		struct dwc3 *dwc = s->private;
		struct dwc3_ep *dep;

		if (ubuf == NULL) {
		pr_err("[%s] EINVAL\n", __func__);
		goto done;
		}

		if (sscanf(ubuf, "%u", &clear_stats) != 1 \|\| clear_stats != 0) {
		pr_err("Wrong value. To clear stats, enter value as 0.\n");
		goto done;
		}

		spin_lock_irqsave(&dwc->lock, flags);

		pr_debug("%s(): clearing debug interrupt buffers\n", __func__);
		for (i = 0; i < DWC3_ENDPOINTS_NUM; i++) {
		dep = dwc->eps[i];
		memset(&dep->dbg_ep_events, 0, sizeof(dep->dbg_ep_events));
		}
		memset(&dwc->dbg_gadget_events, 0, sizeof(dwc->dbg_gadget_events));

		spin_unlock_irqrestore(&dwc->lock, flags);

		done:
		return count;
		}

		static int dwc3_gadget_int_events_show(struct seq_file s, void unused)
		{
		unsigned long flags;
		struct dwc3 *dwc = s->private;
		struct dwc3_gadget_events *dbg_gadget_events;
		struct dwc3_ep *dep;
		int i;

		spin_lock_irqsave(&dwc->lock, flags);
		dbg_gadget_events = &dwc->dbg_gadget_events;

		for (i = 0; i < DWC3_ENDPOINTS_NUM; i++) {
		dep = dwc->eps[i];

		if (dep == NULL)
		continue;

		seq_printf(s, "\n\n===== dbg_ep_events for EP(%d) =====\n", i);
		seq_printf(s, "xfercomplete:%u\n xfernotready:%u\n",
		dep->dbg_ep_events.xfercomplete,
		dep->dbg_ep_events.xfernotready);
		seq_printf(s, "control_data:%u\n control_status:%u\n",
		dep->dbg_ep_events.control_data,
		dep->dbg_ep_events.control_status);
		seq_printf(s, "xferinprogress:%u\n rxtxfifoevent:%u\n",
		dep->dbg_ep_events.xferinprogress,
		dep->dbg_ep_events.rxtxfifoevent);
		seq_printf(s, "streamevent:%u\n epcmdcomplt:%u\n",
		dep->dbg_ep_events.streamevent,
		dep->dbg_ep_events.epcmdcomplete);
		seq_printf(s, "cmdcmplt:%u\n unknown:%u\n",
		dep->dbg_ep_events.cmdcmplt,
		dep->dbg_ep_events.unknown_event);
		}

		seq_puts(s, "\n=== dbg_gadget events ==\n");
		seq_printf(s, "disconnect:%u\n reset:%u\n",
		dbg_gadget_events->disconnect, dbg_gadget_events->reset);
		seq_printf(s, "connect:%u\n wakeup:%u\n",
		dbg_gadget_events->connect, dbg_gadget_events->wakeup);
		seq_printf(s, "link_status_change:%u\n eopf:%u\n",
		dbg_gadget_events->link_status_change, dbg_gadget_events->eopf);
		seq_printf(s, "sof:%u\n suspend:%u\n",
		dbg_gadget_events->sof, dbg_gadget_events->suspend);
		seq_printf(s, "erratic_error:%u\n overflow:%u\n",
		dbg_gadget_events->erratic_error,
		dbg_gadget_events->overflow);
		seq_printf(s, "vendor_dev_test_lmp:%u\n cmdcmplt:%u\n",
		dbg_gadget_events->vendor_dev_test_lmp,
		dbg_gadget_events->cmdcmplt);
		seq_printf(s, "unknown_event:%u\n", dbg_gadget_events->unknown_event);

		spin_unlock_irqrestore(&dwc->lock, flags);
		return 0;
		}

		static int dwc3_gadget_events_open(struct inode inode, struct file f)
		{
		return single_open(f, dwc3_gadget_int_events_show, inode->i_private);
		}

		const struct file_operations dwc3_gadget_dbg_events_fops = {
		.open = dwc3_gadget_events_open,
		.read = seq_read,
		.write = dwc3_store_int_events,
		.llseek = seq_lseek,
		.release = single_release,
		};

		int dwc3_debugfs_init(struct dwc3 *dwc)
		{
		struct dentry *root;
		@@ -1123,6 +1226,14 @@ int dwc3_debugfs_init(struct dwc3 *dwc)
		ret = -ENOMEM;
		goto err1;
		}

		file = debugfs_create_file("int_events", S_IRUGO \| S_IWUSR, root,
		dwc, &dwc3_gadget_dbg_events_fops);
		if (!file) {
		ret = -ENOMEM;
		goto err1;
		}

		return 0;

		err1:

drivers/usb/dwc3/ep0.c

+15 −0

Original line number	Diff line number	Diff line
		@@ -1027,13 +1027,16 @@ static void dwc3_ep0_xfernotready(struct dwc3 *dwc,
		{
		u8 epnum;
		int ret;
		struct dwc3_ep *dep;

		dwc->setup_packet_pending = true;
		epnum = event->endpoint_number;
		dep = dwc->eps[epnum];

		switch (event->status) {
		case DEPEVT_STATUS_CONTROL_DATA:
		dev_vdbg(dwc->dev, "Control Data\n");
		dep->dbg_ep_events.control_data++;

		/*
		* We already have a DATA transfer in the controller's cache,
		@@ -1066,6 +1069,7 @@ static void dwc3_ep0_xfernotready(struct dwc3 *dwc,
		break;

		case DEPEVT_STATUS_CONTROL_STATUS:
		dep->dbg_ep_events.control_status++;
		if (dwc->ep0_next_event != DWC3_EP0_NRDY_STATUS)
		return;

		@@ -1090,25 +1094,36 @@ void dwc3_ep0_interrupt(struct dwc3 *dwc,
		const struct dwc3_event_depevt *event)
		{
		u8 epnum = event->endpoint_number;
		struct dwc3_ep *dep;

		dev_dbg(dwc->dev, "%s while ep%d%s in state '%s'\n",
		dwc3_ep_event_string(event->endpoint_event),
		epnum >> 1, (epnum & 1) ? "in" : "out",
		dwc3_ep0_state_string(dwc->ep0state));

		dep = dwc->eps[epnum];
		switch (event->endpoint_event) {
		case DWC3_DEPEVT_XFERCOMPLETE:
		dwc3_ep0_xfer_complete(dwc, event);
		dep->dbg_ep_events.xfercomplete++;
		break;

		case DWC3_DEPEVT_XFERNOTREADY:
		dwc3_ep0_xfernotready(dwc, event);
		dep->dbg_ep_events.xfernotready++;
		break;

		case DWC3_DEPEVT_XFERINPROGRESS:
		dep->dbg_ep_events.xferinprogress++;
		break;
		case DWC3_DEPEVT_RXTXFIFOEVT:
		dep->dbg_ep_events.rxtxfifoevent++;
		break;
		case DWC3_DEPEVT_STREAMEVT:
		dep->dbg_ep_events.streamevent++;
		break;
		case DWC3_DEPEVT_EPCMDCMPLT:
		dep->dbg_ep_events.epcmdcomplete++;
		break;
		}
		}

drivers/usb/dwc3/gadget.c

+19 −0

Original line number	Diff line number	Diff line
		@@ -2302,6 +2302,7 @@ static void dwc3_endpoint_interrupt(struct dwc3 *dwc,
		switch (event->endpoint_event) {
		case DWC3_DEPEVT_XFERCOMPLETE:
		dep->resource_index = 0;
		dep->dbg_ep_events.xfercomplete++;

		if (usb_endpoint_xfer_isoc(dep->endpoint.desc)) {
		dev_dbg(dwc->dev, "%s is an Isochronous endpoint\n",
		@@ -2313,6 +2314,7 @@ static void dwc3_endpoint_interrupt(struct dwc3 *dwc,
		dwc3_endpoint_transfer_complete(dwc, dep, event, 1);
		break;
		case DWC3_DEPEVT_XFERINPROGRESS:
		dep->dbg_ep_events.xferinprogress++;
		if (!usb_endpoint_xfer_isoc(dep->endpoint.desc)) {
		dev_dbg(dwc->dev, "%s is not an Isochronous endpoint\n",
		dep->name);
		@@ -2324,6 +2326,7 @@ static void dwc3_endpoint_interrupt(struct dwc3 *dwc,
		break;
		case DWC3_DEPEVT_XFERNOTREADY:
		dbg_event(dep->number, "XFRNRDY", 0);
		dep->dbg_ep_events.xfernotready++;
		if (usb_endpoint_xfer_isoc(dep->endpoint.desc)) {
		dwc3_gadget_start_isoc(dwc, dep, event);
		} else {
		@@ -2347,6 +2350,7 @@ static void dwc3_endpoint_interrupt(struct dwc3 *dwc,

		break;
		case DWC3_DEPEVT_STREAMEVT:
		dep->dbg_ep_events.streamevent++;
		if (!usb_endpoint_xfer_bulk(dep->endpoint.desc)) {
		dev_err(dwc->dev, "Stream event for non-Bulk %s\n",
		dep->name);
		@@ -2367,9 +2371,11 @@ static void dwc3_endpoint_interrupt(struct dwc3 *dwc,
		break;
		case DWC3_DEPEVT_RXTXFIFOEVT:
		dev_dbg(dwc->dev, "%s FIFO Overrun\n", dep->name);
		dep->dbg_ep_events.rxtxfifoevent++;
		break;
		case DWC3_DEPEVT_EPCMDCMPLT:
		dev_vdbg(dwc->dev, "Endpoint Command Complete\n");
		dep->dbg_ep_events.epcmdcomplete++;
		break;
		}
		}
		@@ -2889,30 +2895,38 @@ static void dwc3_gadget_interrupt(struct dwc3 *dwc,
		switch (event->type) {
		case DWC3_DEVICE_EVENT_DISCONNECT:
		dwc3_gadget_disconnect_interrupt(dwc);
		dwc->dbg_gadget_events.disconnect++;
		break;
		case DWC3_DEVICE_EVENT_RESET:
		dwc3_gadget_reset_interrupt(dwc);
		dwc->dbg_gadget_events.reset++;
		break;
		case DWC3_DEVICE_EVENT_CONNECT_DONE:
		dwc3_gadget_conndone_interrupt(dwc);
		dwc->dbg_gadget_events.connect++;
		break;
		case DWC3_DEVICE_EVENT_WAKEUP:
		dwc3_gadget_wakeup_interrupt(dwc);
		dwc->dbg_gadget_events.wakeup++;
		break;
		case DWC3_DEVICE_EVENT_LINK_STATUS_CHANGE:
		dwc3_gadget_linksts_change_interrupt(dwc, event->event_info);
		dwc->dbg_gadget_events.link_status_change++;
		break;
		case DWC3_DEVICE_EVENT_SUSPEND:
		if (dwc->revision < DWC3_REVISION_230A) {
		dev_vdbg(dwc->dev, "End of Periodic Frame\n");
		dwc->dbg_gadget_events.eopf++;
		} else {
		dev_vdbg(dwc->dev, "U3/L1-L2 Suspend Event\n");
		dbg_event(0xFF, "SUSPEND", 0);
		dwc->dbg_gadget_events.suspend++;
		dwc3_gadget_suspend_interrupt(dwc, event->event_info);
		}
		break;
		case DWC3_DEVICE_EVENT_SOF:
		dev_vdbg(dwc->dev, "Start of Periodic Frame\n");
		dwc->dbg_gadget_events.sof++;
		break;
		case DWC3_DEVICE_EVENT_ERRATIC_ERROR:
		if (!dwc->err_evt_seen) {
		@@ -2920,9 +2934,11 @@ static void dwc3_gadget_interrupt(struct dwc3 *dwc,
		dev_vdbg(dwc->dev, "Erratic Error\n");
		dwc3_dump_reg_info(dwc);
		}
		dwc->dbg_gadget_events.erratic_error++;
		break;
		case DWC3_DEVICE_EVENT_CMD_CMPL:
		dev_vdbg(dwc->dev, "Command Complete\n");
		dwc->dbg_gadget_events.cmdcmplt++;
		break;
		case DWC3_DEVICE_EVENT_OVERFLOW:
		dbg_event(0xFF, "OVERFL", 0);
		@@ -2939,6 +2955,7 @@ static void dwc3_gadget_interrupt(struct dwc3 *dwc,
		*/
		if (dwc->revision < DWC3_REVISION_230A)
		dev_warn(dwc->dev, "Unacknowledged event overwritten\n");
		dwc->dbg_gadget_events.overflow++;
		break;
		case DWC3_DEVICE_EVENT_VENDOR_DEV_TEST_LMP:
		/*
		@@ -2955,9 +2972,11 @@ static void dwc3_gadget_interrupt(struct dwc3 *dwc,
		dbg_event(0xFF, "TSTLMP", 0);
		if (dwc->revision < DWC3_REVISION_230A)
		dev_warn(dwc->dev, "Vendor Device Test LMP Received\n");
		dwc->dbg_gadget_events.vendor_dev_test_lmp++;
		break;
		default:
		dev_dbg(dwc->dev, "UNKNOWN IRQ %d\n", event->type);
		dwc->dbg_gadget_events.unknown_event++;
		}

		dwc->err_evt_seen = (event->type == DWC3_DEVICE_EVENT_ERRATIC_ERROR);