[deliverable/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 <balbi@ti.com>,
 *	    Sebastian Andrzej Siewior <bigeasy@linutronix.de>
 *
 * 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";
	}
}

/**
 * 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)
{
	u8 epnum = event->endpoint_number;
	static char str[256];
	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");
		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)");
		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)
{
	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);
}

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";
	}
}

void dwc3_trace(void (*trace)(struct va_format *), const char *fmt, ...);

#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 <balbi@ti.com>,
	7	* Sebastian Andrzej Siewior <bigeasy@linutronix.de>
	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
127	/**
128	* dwc3_gadget_event_string - returns event name
129	* @event: the event code
130	*/
f75cacc4 FB	131	static inline const char *
f75cacc4 FB	132	dwc3_gadget_event_string(const struct dwc3_event_devt *event)
80977dc9	133	{
f75cacc4 FB	134	static char str[256];
	135	enum dwc3_link_state state = event->event_info & DWC3_LINK_STATE_MASK;
	136
	137	switch (event->type) {
80977dc9	138	case DWC3_DEVICE_EVENT_DISCONNECT:
f75cacc4 FB	139	sprintf(str, "Disconnect: [%s]",
	140	dwc3_gadget_link_string(state));
	141	break;
80977dc9	142	case DWC3_DEVICE_EVENT_RESET:
f75cacc4 FB	143	sprintf(str, "Reset [%s]", dwc3_gadget_link_string(state));
f75cacc4 FB	144	break;
80977dc9	145	case DWC3_DEVICE_EVENT_CONNECT_DONE:
f75cacc4 FB	146	sprintf(str, "Connection Done [%s]",
	147	dwc3_gadget_link_string(state));
	148	break;
80977dc9	149	case DWC3_DEVICE_EVENT_LINK_STATUS_CHANGE:
f75cacc4 FB	150	sprintf(str, "Link Change [%s]",
	151	dwc3_gadget_link_string(state));
	152	break;
80977dc9	153	case DWC3_DEVICE_EVENT_WAKEUP:
f75cacc4 FB	154	sprintf(str, "WakeUp [%s]", dwc3_gadget_link_string(state));
f75cacc4 FB	155	break;
80977dc9	156	case DWC3_DEVICE_EVENT_EOPF:
f75cacc4 FB	157	sprintf(str, "End-Of-Frame [%s]",
	158	dwc3_gadget_link_string(state));
	159	break;
80977dc9	160	case DWC3_DEVICE_EVENT_SOF:
f75cacc4 FB	161	sprintf(str, "Start-Of-Frame [%s]",
	162	dwc3_gadget_link_string(state));
	163	break;
80977dc9	164	case DWC3_DEVICE_EVENT_ERRATIC_ERROR:
f75cacc4 FB	165	sprintf(str, "Erratic Error [%s]",
	166	dwc3_gadget_link_string(state));
	167	break;
80977dc9	168	case DWC3_DEVICE_EVENT_CMD_CMPL:
f75cacc4 FB	169	sprintf(str, "Command Complete [%s]",
	170	dwc3_gadget_link_string(state));
	171	break;
80977dc9	172	case DWC3_DEVICE_EVENT_OVERFLOW:
f75cacc4 FB	173	sprintf(str, "Overflow [%s]", dwc3_gadget_link_string(state));
	174	break;
	175	default:
	176	sprintf(str, "UNKNOWN");
80977dc9 FB	177	}
80977dc9 FB	178
f75cacc4	179	return str;
80977dc9 FB	180	}
	181
	182	/**
	183	* dwc3_ep_event_string - returns event name
	184	* @event: then event code
	185	*/
f75cacc4 FB	186	static inline const char *
f75cacc4 FB	187	dwc3_ep_event_string(const struct dwc3_event_depevt *event)
80977dc9	188	{
f75cacc4 FB	189	u8 epnum = event->endpoint_number;
	190	static char str[256];
	191	int status;
	192	int ret;
	193
	194	ret = sprintf(str, "ep%d%s: ", epnum >> 1,
696fe69d	195	(epnum & 1) ? "in" : "out");
f75cacc4 FB	196	if (ret < 0)
	197	return "UNKNOWN";
	198
	199	switch (event->endpoint_event) {
80977dc9	200	case DWC3_DEPEVT_XFERCOMPLETE:
f75cacc4 FB	201	strcat(str, "Transfer Complete");
f75cacc4 FB	202	break;
80977dc9	203	case DWC3_DEPEVT_XFERINPROGRESS:
f75cacc4 FB	204	strcat(str, "Transfer In-Progress");
f75cacc4 FB	205	break;
80977dc9	206	case DWC3_DEPEVT_XFERNOTREADY:
f75cacc4 FB	207	strcat(str, "Transfer Not Ready");
	208	status = event->status & DEPEVT_STATUS_TRANSFER_ACTIVE;
	209	strcat(str, status ? " (Active)" : " (Not Active)");
	210	break;
80977dc9	211	case DWC3_DEPEVT_RXTXFIFOEVT:
f75cacc4 FB	212	strcat(str, "FIFO");
f75cacc4 FB	213	break;
80977dc9	214	case DWC3_DEPEVT_STREAMEVT:
f75cacc4 FB	215	status = event->status;
	216
	217	switch (status) {
	218	case DEPEVT_STREAMEVT_FOUND:
	219	sprintf(str + ret, " Stream %d Found",
	220	event->parameters);
	221	break;
	222	case DEPEVT_STREAMEVT_NOTFOUND:
	223	default:
	224	strcat(str, " Stream Not Found");
	225	break;
	226	}
	227
	228	break;
80977dc9	229	case DWC3_DEPEVT_EPCMDCMPLT:
f75cacc4 FB	230	strcat(str, "Endpoint Command Complete");
	231	break;
	232	default:
	233	sprintf(str, "UNKNOWN");
80977dc9 FB	234	}
80977dc9 FB	235
f75cacc4	236	return str;
80977dc9 FB	237	}
80977dc9 FB	238
e996061b FB	239	/**
	240	* dwc3_gadget_event_type_string - return event name
	241	* @event: the event code
	242	*/
	243	static inline const char *dwc3_gadget_event_type_string(u8 event)
	244	{
	245	switch (event) {
	246	case DWC3_DEVICE_EVENT_DISCONNECT:
	247	return "Disconnect";
	248	case DWC3_DEVICE_EVENT_RESET:
	249	return "Reset";
	250	case DWC3_DEVICE_EVENT_CONNECT_DONE:
	251	return "Connect Done";
	252	case DWC3_DEVICE_EVENT_LINK_STATUS_CHANGE:
	253	return "Link Status Change";
	254	case DWC3_DEVICE_EVENT_WAKEUP:
	255	return "Wake-Up";
	256	case DWC3_DEVICE_EVENT_HIBER_REQ:
	257	return "Hibernation";
	258	case DWC3_DEVICE_EVENT_EOPF:
	259	return "End of Periodic Frame";
	260	case DWC3_DEVICE_EVENT_SOF:
	261	return "Start of Frame";
	262	case DWC3_DEVICE_EVENT_ERRATIC_ERROR:
	263	return "Erratic Error";
	264	case DWC3_DEVICE_EVENT_CMD_CMPL:
	265	return "Command Complete";
	266	case DWC3_DEVICE_EVENT_OVERFLOW:
	267	return "Overflow";
	268	default:
	269	return "UNKNOWN";
	270	}
	271	}
	272
f75cacc4 FB	273	static inline const char *dwc3_decode_event(u32 event)
	274	{
	275	const union dwc3_event evt = (union dwc3_event) event;
	276
	277	if (evt.type.is_devspec)
	278	return dwc3_gadget_event_string(&evt.devt);
	279	else
	280	return dwc3_ep_event_string(&evt.depevt);
	281	}
	282
0933df15 FB	283	static inline const char *dwc3_ep_cmd_status_string(int status)
	284	{
	285	switch (status) {
	286	case -ETIMEDOUT:
	287	return "Timed Out";
	288	case 0:
	289	return "Successful";
	290	case DEPEVT_TRANSFER_NO_RESOURCE:
	291	return "No Resource";
	292	case DEPEVT_TRANSFER_BUS_EXPIRY:
	293	return "Bus Expiry";
	294	default:
	295	return "UNKNOWN";
	296	}
	297	}
	298
71f7e702 FB	299	static inline const char *dwc3_gadget_generic_cmd_status_string(int status)
	300	{
	301	switch (status) {
	302	case -ETIMEDOUT:
	303	return "Timed Out";
	304	case 0:
	305	return "Successful";
	306	case 1:
	307	return "Error";
	308	default:
	309	return "UNKNOWN";
	310	}
	311	}
	312
2c4cbe6e FB	313	void dwc3_trace(void (trace)(struct va_format ), const char *fmt, ...);
2c4cbe6e FB	314
72246da4	315	#ifdef CONFIG_DEBUG_FS
4e9f3118	316	extern void dwc3_debugfs_init(struct dwc3 *);
72246da4 FB	317	extern void dwc3_debugfs_exit(struct dwc3 *);
72246da4 FB	318	#else
4e9f3118 DC	319	static inline void dwc3_debugfs_init(struct dwc3 *d)
4e9f3118 DC	320	{ }
72246da4 FB	321	static inline void dwc3_debugfs_exit(struct dwc3 *d)
	322	{ }
	323	#endif
80977dc9	324	#endif /* __DWC3_DEBUG_H */