[linux.git] / drivers / usb / dwc3 / debug.h

/**
 * debug.h - DesignWare USB3 DRD Controller Debug Header
 *
 * Copyright (C) 2010-2011 Texas Instruments Incorporated - http://www.ti.com
 *
 * Authors: Felipe Balbi <[email protected]>,
 *	    Sebastian Andrzej Siewior <[email protected]>
 *
 * This program is free software: you can redistribute it and/or modify
 * it under the terms of the GNU General Public License version 2  of
 * the License as published by the Free Software Foundation.
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 */

#ifndef __DWC3_DEBUG_H
#define __DWC3_DEBUG_H

#include "core.h"

/**
 * dwc3_gadget_ep_cmd_string - returns endpoint command string
 * @cmd: command code
 */
static inline const char *
dwc3_gadget_ep_cmd_string(u8 cmd)
{
	switch (cmd) {
	case DWC3_DEPCMD_DEPSTARTCFG:
		return "Start New Configuration";
	case DWC3_DEPCMD_ENDTRANSFER:
		return "End Transfer";
	case DWC3_DEPCMD_UPDATETRANSFER:
		return "Update Transfer";
	case DWC3_DEPCMD_STARTTRANSFER:
		return "Start Transfer";
	case DWC3_DEPCMD_CLEARSTALL:
		return "Clear Stall";
	case DWC3_DEPCMD_SETSTALL:
		return "Set Stall";
	case DWC3_DEPCMD_GETEPSTATE:
		return "Get Endpoint State";
	case DWC3_DEPCMD_SETTRANSFRESOURCE:
		return "Set Endpoint Transfer Resource";
	case DWC3_DEPCMD_SETEPCONFIG:
		return "Set Endpoint Configuration";
	default:
		return "UNKNOWN command";
	}
}

/**
 * dwc3_gadget_generic_cmd_string - returns generic command string
 * @cmd: command code
 */
static inline const char *
dwc3_gadget_generic_cmd_string(u8 cmd)
{
	switch (cmd) {
	case DWC3_DGCMD_SET_LMP:
		return "Set LMP";
	case DWC3_DGCMD_SET_PERIODIC_PAR:
		return "Set Periodic Parameters";
	case DWC3_DGCMD_XMIT_FUNCTION:
		return "Transmit Function Wake Device Notification";
	case DWC3_DGCMD_SET_SCRATCHPAD_ADDR_LO:
		return "Set Scratchpad Buffer Array Address Lo";
	case DWC3_DGCMD_SET_SCRATCHPAD_ADDR_HI:
		return "Set Scratchpad Buffer Array Address Hi";
	case DWC3_DGCMD_SELECTED_FIFO_FLUSH:
		return "Selected FIFO Flush";
	case DWC3_DGCMD_ALL_FIFO_FLUSH:
		return "All FIFO Flush";
	case DWC3_DGCMD_SET_ENDPOINT_NRDY:
		return "Set Endpoint NRDY";
	case DWC3_DGCMD_RUN_SOC_BUS_LOOPBACK:
		return "Run SoC Bus Loopback Test";
	default:
		return "UNKNOWN";
	}
}

/**
 * dwc3_gadget_link_string - returns link name
 * @link_state: link state code
 */
static inline const char *
dwc3_gadget_link_string(enum dwc3_link_state link_state)
{
	switch (link_state) {
	case DWC3_LINK_STATE_U0:
		return "U0";
	case DWC3_LINK_STATE_U1:
		return "U1";
	case DWC3_LINK_STATE_U2:
		return "U2";
	case DWC3_LINK_STATE_U3:
		return "U3";
	case DWC3_LINK_STATE_SS_DIS:
		return "SS.Disabled";
	case DWC3_LINK_STATE_RX_DET:
		return "RX.Detect";
	case DWC3_LINK_STATE_SS_INACT:
		return "SS.Inactive";
	case DWC3_LINK_STATE_POLL:
		return "Polling";
	case DWC3_LINK_STATE_RECOV:
		return "Recovery";
	case DWC3_LINK_STATE_HRESET:
		return "Hot Reset";
	case DWC3_LINK_STATE_CMPLY:
		return "Compliance";
	case DWC3_LINK_STATE_LPBK:
		return "Loopback";
	case DWC3_LINK_STATE_RESET:
		return "Reset";
	case DWC3_LINK_STATE_RESUME:
		return "Resume";
	default:
		return "UNKNOWN link state\n";
	}
}

static inline const char *dwc3_ep0_state_string(enum dwc3_ep0_state state)
{
	switch (state) {
	case EP0_UNCONNECTED:
		return "Unconnected";
	case EP0_SETUP_PHASE:
		return "Setup Phase";
	case EP0_DATA_PHASE:
		return "Data Phase";
	case EP0_STATUS_PHASE:
		return "Status Phase";
	default:
		return "UNKNOWN";
	}
}

/**
 * dwc3_gadget_event_string - returns event name
 * @event: the event code
 */
static inline const char *
dwc3_gadget_event_string(const struct dwc3_event_devt *event)
{
	static char str[256];
	enum dwc3_link_state state = event->event_info & DWC3_LINK_STATE_MASK;

	switch (event->type) {
	case DWC3_DEVICE_EVENT_DISCONNECT:
		sprintf(str, "Disconnect: [%s]",
				dwc3_gadget_link_string(state));
		break;
	case DWC3_DEVICE_EVENT_RESET:
		sprintf(str, "Reset [%s]", dwc3_gadget_link_string(state));
		break;
	case DWC3_DEVICE_EVENT_CONNECT_DONE:
		sprintf(str, "Connection Done [%s]",
				dwc3_gadget_link_string(state));
		break;
	case DWC3_DEVICE_EVENT_LINK_STATUS_CHANGE:
		sprintf(str, "Link Change [%s]",
				dwc3_gadget_link_string(state));
		break;
	case DWC3_DEVICE_EVENT_WAKEUP:
		sprintf(str, "WakeUp [%s]", dwc3_gadget_link_string(state));
		break;
	case DWC3_DEVICE_EVENT_EOPF:
		sprintf(str, "End-Of-Frame [%s]",
				dwc3_gadget_link_string(state));
		break;
	case DWC3_DEVICE_EVENT_SOF:
		sprintf(str, "Start-Of-Frame [%s]",
				dwc3_gadget_link_string(state));
		break;
	case DWC3_DEVICE_EVENT_ERRATIC_ERROR:
		sprintf(str, "Erratic Error [%s]",
				dwc3_gadget_link_string(state));
		break;
	case DWC3_DEVICE_EVENT_CMD_CMPL:
		sprintf(str, "Command Complete [%s]",
				dwc3_gadget_link_string(state));
		break;
	case DWC3_DEVICE_EVENT_OVERFLOW:
		sprintf(str, "Overflow [%s]", dwc3_gadget_link_string(state));
		break;
	default:
		sprintf(str, "UNKNOWN");
	}

	return str;
}

/**
 * dwc3_ep_event_string - returns event name
 * @event: then event code
 */
static inline const char *
dwc3_ep_event_string(const struct dwc3_event_depevt *event, u32 ep0state)
{
	u8 epnum = event->endpoint_number;
	static char str[256];
	size_t len;
	int status;
	int ret;

	ret = sprintf(str, "ep%d%s: ", epnum >> 1,
			(epnum & 1) ? "in" : "out");
	if (ret < 0)
		return "UNKNOWN";

	switch (event->endpoint_event) {
	case DWC3_DEPEVT_XFERCOMPLETE:
		strcat(str, "Transfer Complete");
		len = strlen(str);

		if (epnum <= 1)
			sprintf(str + len, " [%s]", dwc3_ep0_state_string(ep0state));
		break;
	case DWC3_DEPEVT_XFERINPROGRESS:
		strcat(str, "Transfer In-Progress");
		break;
	case DWC3_DEPEVT_XFERNOTREADY:
		strcat(str, "Transfer Not Ready");
		status = event->status & DEPEVT_STATUS_TRANSFER_ACTIVE;
		strcat(str, status ? " (Active)" : " (Not Active)");

		/* Control Endpoints */
		if (epnum <= 1) {
			int phase = DEPEVT_STATUS_CONTROL_PHASE(event->status);

			switch (phase) {
			case DEPEVT_STATUS_CONTROL_DATA:
				strcat(str, " [Data Phase]");
				break;
			case DEPEVT_STATUS_CONTROL_STATUS:
				strcat(str, " [Status Phase]");
			}
		}
		break;
	case DWC3_DEPEVT_RXTXFIFOEVT:
		strcat(str, "FIFO");
		break;
	case DWC3_DEPEVT_STREAMEVT:
		status = event->status;

		switch (status) {
		case DEPEVT_STREAMEVT_FOUND:
			sprintf(str + ret, " Stream %d Found",
					event->parameters);
			break;
		case DEPEVT_STREAMEVT_NOTFOUND:
		default:
			strcat(str, " Stream Not Found");
			break;
		}

		break;
	case DWC3_DEPEVT_EPCMDCMPLT:
		strcat(str, "Endpoint Command Complete");
		break;
	default:
		sprintf(str, "UNKNOWN");
	}

	return str;
}

/**
 * dwc3_gadget_event_type_string - return event name
 * @event: the event code
 */
static inline const char *dwc3_gadget_event_type_string(u8 event)
{
	switch (event) {
	case DWC3_DEVICE_EVENT_DISCONNECT:
		return "Disconnect";
	case DWC3_DEVICE_EVENT_RESET:
		return "Reset";
	case DWC3_DEVICE_EVENT_CONNECT_DONE:
		return "Connect Done";
	case DWC3_DEVICE_EVENT_LINK_STATUS_CHANGE:
		return "Link Status Change";
	case DWC3_DEVICE_EVENT_WAKEUP:
		return "Wake-Up";
	case DWC3_DEVICE_EVENT_HIBER_REQ:
		return "Hibernation";
	case DWC3_DEVICE_EVENT_EOPF:
		return "End of Periodic Frame";
	case DWC3_DEVICE_EVENT_SOF:
		return "Start of Frame";
	case DWC3_DEVICE_EVENT_ERRATIC_ERROR:
		return "Erratic Error";
	case DWC3_DEVICE_EVENT_CMD_CMPL:
		return "Command Complete";
	case DWC3_DEVICE_EVENT_OVERFLOW:
		return "Overflow";
	default:
		return "UNKNOWN";
	}
}

static inline const char *dwc3_decode_event(u32 event, u32 ep0state)
{
	const union dwc3_event evt = (union dwc3_event) event;

	if (evt.type.is_devspec)
		return dwc3_gadget_event_string(&evt.devt);
	else
		return dwc3_ep_event_string(&evt.depevt, ep0state);
}

static inline const char *dwc3_ep_cmd_status_string(int status)
{
	switch (status) {
	case -ETIMEDOUT:
		return "Timed Out";
	case 0:
		return "Successful";
	case DEPEVT_TRANSFER_NO_RESOURCE:
		return "No Resource";
	case DEPEVT_TRANSFER_BUS_EXPIRY:
		return "Bus Expiry";
	default:
		return "UNKNOWN";
	}
}

static inline const char *dwc3_gadget_generic_cmd_status_string(int status)
{
	switch (status) {
	case -ETIMEDOUT:
		return "Timed Out";
	case 0:
		return "Successful";
	case 1:
		return "Error";
	default:
		return "UNKNOWN";
	}
}


#ifdef CONFIG_DEBUG_FS
extern void dwc3_debugfs_init(struct dwc3 *);
extern void dwc3_debugfs_exit(struct dwc3 *);
#else
static inline void dwc3_debugfs_init(struct dwc3 *d)
{  }
static inline void dwc3_debugfs_exit(struct dwc3 *d)
{  }
#endif
#endif /* __DWC3_DEBUG_H */
Commit	Line	Data
72246da4 FB	1	/**
	2	* debug.h - DesignWare USB3 DRD Controller Debug Header
	3	*
	4	* Copyright (C) 2010-2011 Texas Instruments Incorporated - http://www.ti.com
72246da4 FB	5	*
	6	* Authors: Felipe Balbi <[email protected]>,
	7	* Sebastian Andrzej Siewior <[email protected]>
	8	*
5945f789 FB	9	* This program is free software: you can redistribute it and/or modify
	10	* it under the terms of the GNU General Public License version 2 of
	11	* the License as published by the Free Software Foundation.
72246da4	12	*
5945f789 FB	13	* This program is distributed in the hope that it will be useful,
	14	* but WITHOUT ANY WARRANTY; without even the implied warranty of
	15	* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
	16	* GNU General Public License for more details.
72246da4 FB	17	*/
72246da4 FB	18
80977dc9 FB	19	#ifndef __DWC3_DEBUG_H
	20	#define __DWC3_DEBUG_H
	21
72246da4 FB	22	#include "core.h"
72246da4 FB	23
80977dc9 FB	24	/**
	25	* dwc3_gadget_ep_cmd_string - returns endpoint command string
	26	* @cmd: command code
	27	*/
	28	static inline const char *
	29	dwc3_gadget_ep_cmd_string(u8 cmd)
	30	{
	31	switch (cmd) {
	32	case DWC3_DEPCMD_DEPSTARTCFG:
	33	return "Start New Configuration";
	34	case DWC3_DEPCMD_ENDTRANSFER:
	35	return "End Transfer";
	36	case DWC3_DEPCMD_UPDATETRANSFER:
	37	return "Update Transfer";
	38	case DWC3_DEPCMD_STARTTRANSFER:
	39	return "Start Transfer";
	40	case DWC3_DEPCMD_CLEARSTALL:
	41	return "Clear Stall";
	42	case DWC3_DEPCMD_SETSTALL:
	43	return "Set Stall";
	44	case DWC3_DEPCMD_GETEPSTATE:
	45	return "Get Endpoint State";
	46	case DWC3_DEPCMD_SETTRANSFRESOURCE:
	47	return "Set Endpoint Transfer Resource";
	48	case DWC3_DEPCMD_SETEPCONFIG:
	49	return "Set Endpoint Configuration";
	50	default:
	51	return "UNKNOWN command";
	52	}
	53	}
	54
	55	/**
	56	* dwc3_gadget_generic_cmd_string - returns generic command string
	57	* @cmd: command code
	58	*/
	59	static inline const char *
	60	dwc3_gadget_generic_cmd_string(u8 cmd)
	61	{
	62	switch (cmd) {
	63	case DWC3_DGCMD_SET_LMP:
	64	return "Set LMP";
	65	case DWC3_DGCMD_SET_PERIODIC_PAR:
	66	return "Set Periodic Parameters";
	67	case DWC3_DGCMD_XMIT_FUNCTION:
	68	return "Transmit Function Wake Device Notification";
	69	case DWC3_DGCMD_SET_SCRATCHPAD_ADDR_LO:
	70	return "Set Scratchpad Buffer Array Address Lo";
	71	case DWC3_DGCMD_SET_SCRATCHPAD_ADDR_HI:
	72	return "Set Scratchpad Buffer Array Address Hi";
	73	case DWC3_DGCMD_SELECTED_FIFO_FLUSH:
	74	return "Selected FIFO Flush";
	75	case DWC3_DGCMD_ALL_FIFO_FLUSH:
	76	return "All FIFO Flush";
	77	case DWC3_DGCMD_SET_ENDPOINT_NRDY:
	78	return "Set Endpoint NRDY";
	79	case DWC3_DGCMD_RUN_SOC_BUS_LOOPBACK:
	80	return "Run SoC Bus Loopback Test";
	81	default:
	82	return "UNKNOWN";
	83	}
	84	}
	85
	86	/**
	87	* dwc3_gadget_link_string - returns link name
88	* @link_state: link state code
89	*/
90	static inline const char *
91	dwc3_gadget_link_string(enum dwc3_link_state link_state)
92	{
93	switch (link_state) {
94	case DWC3_LINK_STATE_U0:
95	return "U0";
96	case DWC3_LINK_STATE_U1:
97	return "U1";
98	case DWC3_LINK_STATE_U2:
99	return "U2";
100	case DWC3_LINK_STATE_U3:
101	return "U3";
102	case DWC3_LINK_STATE_SS_DIS:
103	return "SS.Disabled";
104	case DWC3_LINK_STATE_RX_DET:
105	return "RX.Detect";
106	case DWC3_LINK_STATE_SS_INACT:
107	return "SS.Inactive";
108	case DWC3_LINK_STATE_POLL:
109	return "Polling";
110	case DWC3_LINK_STATE_RECOV:
111	return "Recovery";
112	case DWC3_LINK_STATE_HRESET:
113	return "Hot Reset";
114	case DWC3_LINK_STATE_CMPLY:
115	return "Compliance";
116	case DWC3_LINK_STATE_LPBK:
117	return "Loopback";
118	case DWC3_LINK_STATE_RESET:
119	return "Reset";
120	case DWC3_LINK_STATE_RESUME:
121	return "Resume";
122	default:
123	return "UNKNOWN link state\n";
124	}
125	}
126
cdd72ac2 FB	127	static inline const char *dwc3_ep0_state_string(enum dwc3_ep0_state state)
	128	{
	129	switch (state) {
	130	case EP0_UNCONNECTED:
	131	return "Unconnected";
	132	case EP0_SETUP_PHASE:
	133	return "Setup Phase";
	134	case EP0_DATA_PHASE:
	135	return "Data Phase";
	136	case EP0_STATUS_PHASE:
	137	return "Status Phase";
	138	default:
	139	return "UNKNOWN";
	140	}
	141	}
	142
80977dc9 FB	143	/**
	144	* dwc3_gadget_event_string - returns event name
	145	* @event: the event code
	146	*/
f75cacc4 FB	147	static inline const char *
f75cacc4 FB	148	dwc3_gadget_event_string(const struct dwc3_event_devt *event)
80977dc9	149	{
f75cacc4 FB	150	static char str[256];
	151	enum dwc3_link_state state = event->event_info & DWC3_LINK_STATE_MASK;
	152
	153	switch (event->type) {
80977dc9	154	case DWC3_DEVICE_EVENT_DISCONNECT:
f75cacc4 FB	155	sprintf(str, "Disconnect: [%s]",
	156	dwc3_gadget_link_string(state));
	157	break;
80977dc9	158	case DWC3_DEVICE_EVENT_RESET:
f75cacc4 FB	159	sprintf(str, "Reset [%s]", dwc3_gadget_link_string(state));
f75cacc4 FB	160	break;
80977dc9	161	case DWC3_DEVICE_EVENT_CONNECT_DONE:
f75cacc4 FB	162	sprintf(str, "Connection Done [%s]",
	163	dwc3_gadget_link_string(state));
	164	break;
80977dc9	165	case DWC3_DEVICE_EVENT_LINK_STATUS_CHANGE:
f75cacc4 FB	166	sprintf(str, "Link Change [%s]",
	167	dwc3_gadget_link_string(state));
	168	break;
80977dc9	169	case DWC3_DEVICE_EVENT_WAKEUP:
f75cacc4 FB	170	sprintf(str, "WakeUp [%s]", dwc3_gadget_link_string(state));
f75cacc4 FB	171	break;
80977dc9	172	case DWC3_DEVICE_EVENT_EOPF:
f75cacc4 FB	173	sprintf(str, "End-Of-Frame [%s]",
	174	dwc3_gadget_link_string(state));
	175	break;
80977dc9	176	case DWC3_DEVICE_EVENT_SOF:
f75cacc4 FB	177	sprintf(str, "Start-Of-Frame [%s]",
	178	dwc3_gadget_link_string(state));
	179	break;
80977dc9	180	case DWC3_DEVICE_EVENT_ERRATIC_ERROR:
f75cacc4 FB	181	sprintf(str, "Erratic Error [%s]",
	182	dwc3_gadget_link_string(state));
	183	break;
80977dc9	184	case DWC3_DEVICE_EVENT_CMD_CMPL:
f75cacc4 FB	185	sprintf(str, "Command Complete [%s]",
	186	dwc3_gadget_link_string(state));
	187	break;
80977dc9	188	case DWC3_DEVICE_EVENT_OVERFLOW:
f75cacc4 FB	189	sprintf(str, "Overflow [%s]", dwc3_gadget_link_string(state));
	190	break;
	191	default:
	192	sprintf(str, "UNKNOWN");
80977dc9 FB	193	}
80977dc9 FB	194
f75cacc4	195	return str;
80977dc9 FB	196	}
	197
	198	/**
	199	* dwc3_ep_event_string - returns event name
	200	* @event: then event code
	201	*/
f75cacc4	202	static inline const char *
43c96be1	203	dwc3_ep_event_string(const struct dwc3_event_depevt *event, u32 ep0state)
80977dc9	204	{
f75cacc4 FB	205	u8 epnum = event->endpoint_number;
f75cacc4 FB	206	static char str[256];
43c96be1	207	size_t len;
f75cacc4 FB	208	int status;
	209	int ret;
	210
	211	ret = sprintf(str, "ep%d%s: ", epnum >> 1,
696fe69d	212	(epnum & 1) ? "in" : "out");
f75cacc4 FB	213	if (ret < 0)
	214	return "UNKNOWN";
	215
	216	switch (event->endpoint_event) {
80977dc9	217	case DWC3_DEPEVT_XFERCOMPLETE:
f75cacc4	218	strcat(str, "Transfer Complete");
43c96be1 FB	219	len = strlen(str);
	220
	221	if (epnum <= 1)
	222	sprintf(str + len, " [%s]", dwc3_ep0_state_string(ep0state));
f75cacc4	223	break;
80977dc9	224	case DWC3_DEPEVT_XFERINPROGRESS:
f75cacc4 FB	225	strcat(str, "Transfer In-Progress");
f75cacc4 FB	226	break;
80977dc9	227	case DWC3_DEPEVT_XFERNOTREADY:
f75cacc4 FB	228	strcat(str, "Transfer Not Ready");
	229	status = event->status & DEPEVT_STATUS_TRANSFER_ACTIVE;
	230	strcat(str, status ? " (Active)" : " (Not Active)");
45a2af2f FB	231
	232	/* Control Endpoints */
	233	if (epnum <= 1) {
	234	int phase = DEPEVT_STATUS_CONTROL_PHASE(event->status);
	235
	236	switch (phase) {
	237	case DEPEVT_STATUS_CONTROL_DATA:
	238	strcat(str, " [Data Phase]");
	239	break;
	240	case DEPEVT_STATUS_CONTROL_STATUS:
	241	strcat(str, " [Status Phase]");
	242	}
	243	}
f75cacc4	244	break;
80977dc9	245	case DWC3_DEPEVT_RXTXFIFOEVT:
f75cacc4 FB	246	strcat(str, "FIFO");
f75cacc4 FB	247	break;
80977dc9	248	case DWC3_DEPEVT_STREAMEVT:
f75cacc4 FB	249	status = event->status;
	250
	251	switch (status) {
	252	case DEPEVT_STREAMEVT_FOUND:
	253	sprintf(str + ret, " Stream %d Found",
	254	event->parameters);
	255	break;
	256	case DEPEVT_STREAMEVT_NOTFOUND:
	257	default:
	258	strcat(str, " Stream Not Found");
	259	break;
	260	}
	261
	262	break;
80977dc9	263	case DWC3_DEPEVT_EPCMDCMPLT:
f75cacc4 FB	264	strcat(str, "Endpoint Command Complete");
	265	break;
	266	default:
	267	sprintf(str, "UNKNOWN");
80977dc9 FB	268	}
80977dc9 FB	269
f75cacc4	270	return str;
80977dc9 FB	271	}
80977dc9 FB	272
e996061b FB	273	/**
	274	* dwc3_gadget_event_type_string - return event name
	275	* @event: the event code
	276	*/
	277	static inline const char *dwc3_gadget_event_type_string(u8 event)
	278	{
	279	switch (event) {
	280	case DWC3_DEVICE_EVENT_DISCONNECT:
	281	return "Disconnect";
	282	case DWC3_DEVICE_EVENT_RESET:
	283	return "Reset";
	284	case DWC3_DEVICE_EVENT_CONNECT_DONE:
	285	return "Connect Done";
	286	case DWC3_DEVICE_EVENT_LINK_STATUS_CHANGE:
	287	return "Link Status Change";
	288	case DWC3_DEVICE_EVENT_WAKEUP:
	289	return "Wake-Up";
	290	case DWC3_DEVICE_EVENT_HIBER_REQ:
	291	return "Hibernation";
	292	case DWC3_DEVICE_EVENT_EOPF:
	293	return "End of Periodic Frame";
	294	case DWC3_DEVICE_EVENT_SOF:
	295	return "Start of Frame";
	296	case DWC3_DEVICE_EVENT_ERRATIC_ERROR:
	297	return "Erratic Error";
	298	case DWC3_DEVICE_EVENT_CMD_CMPL:
	299	return "Command Complete";
	300	case DWC3_DEVICE_EVENT_OVERFLOW:
	301	return "Overflow";
	302	default:
	303	return "UNKNOWN";
	304	}
	305	}
	306
43c96be1	307	static inline const char *dwc3_decode_event(u32 event, u32 ep0state)
f75cacc4 FB	308	{
	309	const union dwc3_event evt = (union dwc3_event) event;
	310
	311	if (evt.type.is_devspec)
	312	return dwc3_gadget_event_string(&evt.devt);
	313	else
43c96be1	314	return dwc3_ep_event_string(&evt.depevt, ep0state);
f75cacc4 FB	315	}
f75cacc4 FB	316
0933df15 FB	317	static inline const char *dwc3_ep_cmd_status_string(int status)
	318	{
	319	switch (status) {
	320	case -ETIMEDOUT:
	321	return "Timed Out";
	322	case 0:
	323	return "Successful";
	324	case DEPEVT_TRANSFER_NO_RESOURCE:
	325	return "No Resource";
	326	case DEPEVT_TRANSFER_BUS_EXPIRY:
	327	return "Bus Expiry";
	328	default:
	329	return "UNKNOWN";
	330	}
	331	}
	332
71f7e702 FB	333	static inline const char *dwc3_gadget_generic_cmd_status_string(int status)
	334	{
	335	switch (status) {
	336	case -ETIMEDOUT:
	337	return "Timed Out";
	338	case 0:
	339	return "Successful";
	340	case 1:
	341	return "Error";
	342	default:
	343	return "UNKNOWN";
	344	}
	345	}
	346
57b14da5	347
72246da4	348	#ifdef CONFIG_DEBUG_FS
4e9f3118	349	extern void dwc3_debugfs_init(struct dwc3 *);
72246da4 FB	350	extern void dwc3_debugfs_exit(struct dwc3 *);
72246da4 FB	351	#else
4e9f3118 CD	352	static inline void dwc3_debugfs_init(struct dwc3 *d)
4e9f3118 CD	353	{ }
72246da4 FB	354	static inline void dwc3_debugfs_exit(struct dwc3 *d)
	355	{ }
	356	#endif
80977dc9	357	#endif /* __DWC3_DEBUG_H */