[mirror_ubuntu-bionic-kernel.git] / drivers / usb / dwc3 / debug.h

// SPDX-License-Identifier: GPL-2.0
/**
 * 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>
 */

#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_hs_link_string - returns highspeed and below link name
 * @link_state: link state code
 */
static inline const char *
dwc3_gadget_hs_link_string(enum dwc3_link_state link_state)
{
	switch (link_state) {
	case DWC3_LINK_STATE_U0:
		return "On";
	case DWC3_LINK_STATE_U2:
		return "Sleep";
	case DWC3_LINK_STATE_U3:
		return "Suspend";
	case DWC3_LINK_STATE_SS_DIS:
		return "Disconnected";
	case DWC3_LINK_STATE_RX_DET:
		return "Early Suspend";
	case DWC3_LINK_STATE_RECOV:
		return "Recovery";
	case DWC3_LINK_STATE_RESET:
		return "Reset";
	case DWC3_LINK_STATE_RESUME:
		return "Resume";
	default:
		return "UNKNOWN link state\n";
	}
}

/**
 * dwc3_trb_type_string - returns TRB type as a string
 * @type: the type of the TRB
 */
static inline const char *dwc3_trb_type_string(unsigned int type)
{
	switch (type) {
	case DWC3_TRBCTL_NORMAL:
		return "normal";
	case DWC3_TRBCTL_CONTROL_SETUP:
		return "setup";
	case DWC3_TRBCTL_CONTROL_STATUS2:
		return "status2";
	case DWC3_TRBCTL_CONTROL_STATUS3:
		return "status3";
	case DWC3_TRBCTL_CONTROL_DATA:
		return "data";
	case DWC3_TRBCTL_ISOCHRONOUS_FIRST:
		return "isoc-first";
	case DWC3_TRBCTL_ISOCHRONOUS:
		return "isoc";
	case DWC3_TRBCTL_LINK_TRB:
		return "link";
	default:
		return "UNKNOWN";
	}
}

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(char *str, const struct dwc3_event_devt *event)
{
	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;
}

static inline void dwc3_decode_get_status(__u8 t, __u16 i, __u16 l, char *str)
{
	switch (t & USB_RECIP_MASK) {
	case USB_RECIP_INTERFACE:
		sprintf(str, "Get Interface Status(Intf = %d, Length = %d)",
			i, l);
		break;
	case USB_RECIP_ENDPOINT:
		sprintf(str, "Get Endpoint Status(ep%d%s)",
			i & ~USB_DIR_IN,
			i & USB_DIR_IN ? "in" : "out");
		break;
	}
}

static inline void dwc3_decode_set_clear_feature(__u8 t, __u8 b, __u16 v,
						 __u16 i, char *str)
{
	switch (t & USB_RECIP_MASK) {
	case USB_RECIP_DEVICE:
		sprintf(str, "%s Device Feature(%s%s)",
			b == USB_REQ_CLEAR_FEATURE ? "Clear" : "Set",
			({char *s;
				switch (v) {
				case USB_DEVICE_SELF_POWERED:
					s = "Self Powered";
					break;
				case USB_DEVICE_REMOTE_WAKEUP:
					s = "Remote Wakeup";
					break;
				case USB_DEVICE_TEST_MODE:
					s = "Test Mode";
					break;
				default:
					s = "UNKNOWN";
				} s; }),
			v == USB_DEVICE_TEST_MODE ?
			({ char *s;
				switch (i) {
				case TEST_J:
					s = ": TEST_J";
					break;
				case TEST_K:
					s = ": TEST_K";
					break;
				case TEST_SE0_NAK:
					s = ": TEST_SE0_NAK";
					break;
				case TEST_PACKET:
					s = ": TEST_PACKET";
					break;
				case TEST_FORCE_EN:
					s = ": TEST_FORCE_EN";
					break;
				default:
					s = ": UNKNOWN";
				} s; }) : "");
		break;
	case USB_RECIP_INTERFACE:
		sprintf(str, "%s Interface Feature(%s)",
			b == USB_REQ_CLEAR_FEATURE ? "Clear" : "Set",
			v == USB_INTRF_FUNC_SUSPEND ?
			"Function Suspend" : "UNKNOWN");
		break;
	case USB_RECIP_ENDPOINT:
		sprintf(str, "%s Endpoint Feature(%s ep%d%s)",
			b == USB_REQ_CLEAR_FEATURE ? "Clear" : "Set",
			v == USB_ENDPOINT_HALT ? "Halt" : "UNKNOWN",
			i & ~USB_DIR_IN,
			i & USB_DIR_IN ? "in" : "out");
		break;
	}
}

static inline void dwc3_decode_set_address(__u16 v, char *str)
{
	sprintf(str, "Set Address(Addr = %02x)", v);
}

static inline void dwc3_decode_get_set_descriptor(__u8 t, __u8 b, __u16 v,
						  __u16 i, __u16 l, char *str)
{
	sprintf(str, "%s %s Descriptor(Index = %d, Length = %d)",
		b == USB_REQ_GET_DESCRIPTOR ? "Get" : "Set",
		({ char *s;
			switch (v >> 8) {
			case USB_DT_DEVICE:
				s = "Device";
				break;
			case USB_DT_CONFIG:
				s = "Configuration";
				break;
			case USB_DT_STRING:
				s = "String";
				break;
			case USB_DT_INTERFACE:
				s = "Interface";
				break;
			case USB_DT_ENDPOINT:
				s = "Endpoint";
				break;
			case USB_DT_DEVICE_QUALIFIER:
				s = "Device Qualifier";
				break;
			case USB_DT_OTHER_SPEED_CONFIG:
				s = "Other Speed Config";
				break;
			case USB_DT_INTERFACE_POWER:
				s = "Interface Power";
				break;
			case USB_DT_OTG:
				s = "OTG";
				break;
			case USB_DT_DEBUG:
				s = "Debug";
				break;
			case USB_DT_INTERFACE_ASSOCIATION:
				s = "Interface Association";
				break;
			case USB_DT_BOS:
				s = "BOS";
				break;
			case USB_DT_DEVICE_CAPABILITY:
				s = "Device Capability";
				break;
			case USB_DT_PIPE_USAGE:
				s = "Pipe Usage";
				break;
			case USB_DT_SS_ENDPOINT_COMP:
				s = "SS Endpoint Companion";
				break;
			case USB_DT_SSP_ISOC_ENDPOINT_COMP:
				s = "SSP Isochronous Endpoint Companion";
				break;
			default:
				s = "UNKNOWN";
				break;
			} s; }), v & 0xff, l);
}


static inline void dwc3_decode_get_configuration(__u16 l, char *str)
{
	sprintf(str, "Get Configuration(Length = %d)", l);
}

static inline void dwc3_decode_set_configuration(__u8 v, char *str)
{
	sprintf(str, "Set Configuration(Config = %d)", v);
}

static inline void dwc3_decode_get_intf(__u16 i, __u16 l, char *str)
{
	sprintf(str, "Get Interface(Intf = %d, Length = %d)", i, l);
}

static inline void dwc3_decode_set_intf(__u8 v, __u16 i, char *str)
{
	sprintf(str, "Set Interface(Intf = %d, Alt.Setting = %d)", i, v);
}

static inline void dwc3_decode_synch_frame(__u16 i, __u16 l, char *str)
{
	sprintf(str, "Synch Frame(Endpoint = %d, Length = %d)", i, l);
}

static inline void dwc3_decode_set_sel(__u16 l, char *str)
{
	sprintf(str, "Set SEL(Length = %d)", l);
}

static inline void dwc3_decode_set_isoch_delay(__u8 v, char *str)
{
	sprintf(str, "Set Isochronous Delay(Delay = %d ns)", v);
}

/**
 * dwc3_decode_ctrl - returns a string represetion of ctrl request
 */
static inline const char *dwc3_decode_ctrl(char *str, __u8 bRequestType,
		__u8 bRequest, __u16 wValue, __u16 wIndex, __u16 wLength)
{
	switch (bRequest) {
	case USB_REQ_GET_STATUS:
		dwc3_decode_get_status(bRequestType, wIndex, wLength, str);
		break;
	case USB_REQ_CLEAR_FEATURE:
	case USB_REQ_SET_FEATURE:
		dwc3_decode_set_clear_feature(bRequestType, bRequest, wValue,
					      wIndex, str);
		break;
	case USB_REQ_SET_ADDRESS:
		dwc3_decode_set_address(wValue, str);
		break;
	case USB_REQ_GET_DESCRIPTOR:
	case USB_REQ_SET_DESCRIPTOR:
		dwc3_decode_get_set_descriptor(bRequestType, bRequest, wValue,
					       wIndex, wLength, str);
		break;
	case USB_REQ_GET_CONFIGURATION:
		dwc3_decode_get_configuration(wLength, str);
		break;
	case USB_REQ_SET_CONFIGURATION:
		dwc3_decode_set_configuration(wValue, str);
		break;
	case USB_REQ_GET_INTERFACE:
		dwc3_decode_get_intf(wIndex, wLength, str);
		break;
	case USB_REQ_SET_INTERFACE:
		dwc3_decode_set_intf(wValue, wIndex, str);
		break;
	case USB_REQ_SYNCH_FRAME:
		dwc3_decode_synch_frame(wIndex, wLength, str);
		break;
	case USB_REQ_SET_SEL:
		dwc3_decode_set_sel(wLength, str);
		break;
	case USB_REQ_SET_ISOCH_DELAY:
		dwc3_decode_set_isoch_delay(wValue, str);
		break;
	default:
		sprintf(str, "%02x %02x %02x %02x %02x %02x %02x %02x",
			bRequestType, bRequest,
			cpu_to_le16(wValue) & 0xff,
			cpu_to_le16(wValue) >> 8,
			cpu_to_le16(wIndex) & 0xff,
			cpu_to_le16(wIndex) >> 8,
			cpu_to_le16(wLength) & 0xff,
			cpu_to_le16(wLength) >> 8);
	}

	return str;
}

/**
 * dwc3_ep_event_string - returns event name
 * @event: then event code
 */
static inline const char *
dwc3_ep_event_string(char *str, const struct dwc3_event_depevt *event,
		     u32 ep0state)
{
	u8 epnum = event->endpoint_number;
	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(char *str, u32 event, u32 ep0state)
{
	const union dwc3_event evt = (union dwc3_event) event;

	if (evt.type.is_devspec)
		return dwc3_gadget_event_string(str, &evt.devt);
	else
		return dwc3_ep_event_string(str, &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
5fd54ace	1	// SPDX-License-Identifier: GPL-2.0
72246da4 FB	2	/**
	3	* debug.h - DesignWare USB3 DRD Controller Debug Header
	4	*
	5	* Copyright (C) 2010-2011 Texas Instruments Incorporated - http://www.ti.com
72246da4 FB	6	*
	7	* Authors: Felipe Balbi <balbi@ti.com>,
	8	* Sebastian Andrzej Siewior <bigeasy@linutronix.de>
72246da4 FB	9	*/
72246da4 FB	10
80977dc9 FB	11	#ifndef __DWC3_DEBUG_H
	12	#define __DWC3_DEBUG_H
	13
72246da4 FB	14	#include "core.h"
72246da4 FB	15
80977dc9 FB	16	/**
	17	* dwc3_gadget_ep_cmd_string - returns endpoint command string
	18	* @cmd: command code
	19	*/
	20	static inline const char *
	21	dwc3_gadget_ep_cmd_string(u8 cmd)
	22	{
	23	switch (cmd) {
	24	case DWC3_DEPCMD_DEPSTARTCFG:
	25	return "Start New Configuration";
	26	case DWC3_DEPCMD_ENDTRANSFER:
	27	return "End Transfer";
	28	case DWC3_DEPCMD_UPDATETRANSFER:
	29	return "Update Transfer";
	30	case DWC3_DEPCMD_STARTTRANSFER:
	31	return "Start Transfer";
	32	case DWC3_DEPCMD_CLEARSTALL:
	33	return "Clear Stall";
	34	case DWC3_DEPCMD_SETSTALL:
	35	return "Set Stall";
	36	case DWC3_DEPCMD_GETEPSTATE:
	37	return "Get Endpoint State";
	38	case DWC3_DEPCMD_SETTRANSFRESOURCE:
	39	return "Set Endpoint Transfer Resource";
	40	case DWC3_DEPCMD_SETEPCONFIG:
	41	return "Set Endpoint Configuration";
	42	default:
	43	return "UNKNOWN command";
	44	}
	45	}
	46
	47	/**
	48	* dwc3_gadget_generic_cmd_string - returns generic command string
	49	* @cmd: command code
	50	*/
	51	static inline const char *
	52	dwc3_gadget_generic_cmd_string(u8 cmd)
	53	{
	54	switch (cmd) {
	55	case DWC3_DGCMD_SET_LMP:
	56	return "Set LMP";
	57	case DWC3_DGCMD_SET_PERIODIC_PAR:
	58	return "Set Periodic Parameters";
	59	case DWC3_DGCMD_XMIT_FUNCTION:
	60	return "Transmit Function Wake Device Notification";
	61	case DWC3_DGCMD_SET_SCRATCHPAD_ADDR_LO:
	62	return "Set Scratchpad Buffer Array Address Lo";
	63	case DWC3_DGCMD_SET_SCRATCHPAD_ADDR_HI:
	64	return "Set Scratchpad Buffer Array Address Hi";
	65	case DWC3_DGCMD_SELECTED_FIFO_FLUSH:
	66	return "Selected FIFO Flush";
	67	case DWC3_DGCMD_ALL_FIFO_FLUSH:
	68	return "All FIFO Flush";
	69	case DWC3_DGCMD_SET_ENDPOINT_NRDY:
	70	return "Set Endpoint NRDY";
	71	case DWC3_DGCMD_RUN_SOC_BUS_LOOPBACK:
	72	return "Run SoC Bus Loopback Test";
	73	default:
	74	return "UNKNOWN";
	75	}
	76	}
	77
	78	/**
	79	* dwc3_gadget_link_string - returns link name
80	* @link_state: link state code
81	*/
82	static inline const char *
83	dwc3_gadget_link_string(enum dwc3_link_state link_state)
84	{
85	switch (link_state) {
86	case DWC3_LINK_STATE_U0:
87	return "U0";
88	case DWC3_LINK_STATE_U1:
89	return "U1";
90	case DWC3_LINK_STATE_U2:
91	return "U2";
92	case DWC3_LINK_STATE_U3:
93	return "U3";
94	case DWC3_LINK_STATE_SS_DIS:
95	return "SS.Disabled";
96	case DWC3_LINK_STATE_RX_DET:
97	return "RX.Detect";
98	case DWC3_LINK_STATE_SS_INACT:
99	return "SS.Inactive";
100	case DWC3_LINK_STATE_POLL:
101	return "Polling";
102	case DWC3_LINK_STATE_RECOV:
103	return "Recovery";
104	case DWC3_LINK_STATE_HRESET:
105	return "Hot Reset";
106	case DWC3_LINK_STATE_CMPLY:
107	return "Compliance";
108	case DWC3_LINK_STATE_LPBK:
109	return "Loopback";
110	case DWC3_LINK_STATE_RESET:
111	return "Reset";
112	case DWC3_LINK_STATE_RESUME:
113	return "Resume";
114	default:
115	return "UNKNOWN link state\n";
116	}
117	}
118
8d20e852 TN	119	/**
	120	* dwc3_gadget_hs_link_string - returns highspeed and below link name
	121	* @link_state: link state code
	122	*/
	123	static inline const char *
	124	dwc3_gadget_hs_link_string(enum dwc3_link_state link_state)
	125	{
	126	switch (link_state) {
	127	case DWC3_LINK_STATE_U0:
	128	return "On";
	129	case DWC3_LINK_STATE_U2:
	130	return "Sleep";
	131	case DWC3_LINK_STATE_U3:
	132	return "Suspend";
	133	case DWC3_LINK_STATE_SS_DIS:
	134	return "Disconnected";
	135	case DWC3_LINK_STATE_RX_DET:
	136	return "Early Suspend";
	137	case DWC3_LINK_STATE_RECOV:
	138	return "Recovery";
	139	case DWC3_LINK_STATE_RESET:
	140	return "Reset";
	141	case DWC3_LINK_STATE_RESUME:
	142	return "Resume";
	143	default:
	144	return "UNKNOWN link state\n";
	145	}
	146	}
	147
b5c7ed5c FB	148	/**
	149	* dwc3_trb_type_string - returns TRB type as a string
	150	* @type: the type of the TRB
	151	*/
	152	static inline const char *dwc3_trb_type_string(unsigned int type)
	153	{
	154	switch (type) {
	155	case DWC3_TRBCTL_NORMAL:
	156	return "normal";
	157	case DWC3_TRBCTL_CONTROL_SETUP:
	158	return "setup";
	159	case DWC3_TRBCTL_CONTROL_STATUS2:
	160	return "status2";
	161	case DWC3_TRBCTL_CONTROL_STATUS3:
	162	return "status3";
	163	case DWC3_TRBCTL_CONTROL_DATA:
	164	return "data";
	165	case DWC3_TRBCTL_ISOCHRONOUS_FIRST:
	166	return "isoc-first";
	167	case DWC3_TRBCTL_ISOCHRONOUS:
	168	return "isoc";
	169	case DWC3_TRBCTL_LINK_TRB:
	170	return "link";
	171	default:
	172	return "UNKNOWN";
	173	}
	174	}
	175
cdd72ac2 FB	176	static inline const char *dwc3_ep0_state_string(enum dwc3_ep0_state state)
	177	{
	178	switch (state) {
	179	case EP0_UNCONNECTED:
	180	return "Unconnected";
	181	case EP0_SETUP_PHASE:
	182	return "Setup Phase";
	183	case EP0_DATA_PHASE:
	184	return "Data Phase";
	185	case EP0_STATUS_PHASE:
	186	return "Status Phase";
	187	default:
	188	return "UNKNOWN";
	189	}
	190	}
	191
80977dc9 FB	192	/**
	193	* dwc3_gadget_event_string - returns event name
	194	* @event: the event code
	195	*/
f75cacc4	196	static inline const char *
3587f36a	197	dwc3_gadget_event_string(char str, const struct dwc3_event_devt event)
80977dc9	198	{
f75cacc4 FB	199	enum dwc3_link_state state = event->event_info & DWC3_LINK_STATE_MASK;
	200
	201	switch (event->type) {
80977dc9	202	case DWC3_DEVICE_EVENT_DISCONNECT:
f75cacc4 FB	203	sprintf(str, "Disconnect: [%s]",
	204	dwc3_gadget_link_string(state));
	205	break;
80977dc9	206	case DWC3_DEVICE_EVENT_RESET:
f75cacc4 FB	207	sprintf(str, "Reset [%s]", dwc3_gadget_link_string(state));
f75cacc4 FB	208	break;
80977dc9	209	case DWC3_DEVICE_EVENT_CONNECT_DONE:
f75cacc4 FB	210	sprintf(str, "Connection Done [%s]",
	211	dwc3_gadget_link_string(state));
	212	break;
80977dc9	213	case DWC3_DEVICE_EVENT_LINK_STATUS_CHANGE:
f75cacc4 FB	214	sprintf(str, "Link Change [%s]",
	215	dwc3_gadget_link_string(state));
	216	break;
80977dc9	217	case DWC3_DEVICE_EVENT_WAKEUP:
f75cacc4 FB	218	sprintf(str, "WakeUp [%s]", dwc3_gadget_link_string(state));
f75cacc4 FB	219	break;
80977dc9	220	case DWC3_DEVICE_EVENT_EOPF:
f75cacc4 FB	221	sprintf(str, "End-Of-Frame [%s]",
	222	dwc3_gadget_link_string(state));
	223	break;
80977dc9	224	case DWC3_DEVICE_EVENT_SOF:
f75cacc4 FB	225	sprintf(str, "Start-Of-Frame [%s]",
	226	dwc3_gadget_link_string(state));
	227	break;
80977dc9	228	case DWC3_DEVICE_EVENT_ERRATIC_ERROR:
f75cacc4 FB	229	sprintf(str, "Erratic Error [%s]",
	230	dwc3_gadget_link_string(state));
	231	break;
80977dc9	232	case DWC3_DEVICE_EVENT_CMD_CMPL:
f75cacc4 FB	233	sprintf(str, "Command Complete [%s]",
	234	dwc3_gadget_link_string(state));
	235	break;
80977dc9	236	case DWC3_DEVICE_EVENT_OVERFLOW:
f75cacc4 FB	237	sprintf(str, "Overflow [%s]", dwc3_gadget_link_string(state));
	238	break;
	239	default:
	240	sprintf(str, "UNKNOWN");
80977dc9 FB	241	}
80977dc9 FB	242
f75cacc4	243	return str;
80977dc9 FB	244	}
80977dc9 FB	245
af32423a FB	246	static inline void dwc3_decode_get_status(__u8 t, __u16 i, __u16 l, char *str)
	247	{
	248	switch (t & USB_RECIP_MASK) {
	249	case USB_RECIP_INTERFACE:
	250	sprintf(str, "Get Interface Status(Intf = %d, Length = %d)",
	251	i, l);
	252	break;
	253	case USB_RECIP_ENDPOINT:
	254	sprintf(str, "Get Endpoint Status(ep%d%s)",
	255	i & ~USB_DIR_IN,
	256	i & USB_DIR_IN ? "in" : "out");
	257	break;
	258	}
	259	}
	260
	261	static inline void dwc3_decode_set_clear_feature(__u8 t, __u8 b, __u16 v,
	262	__u16 i, char *str)
	263	{
	264	switch (t & USB_RECIP_MASK) {
	265	case USB_RECIP_DEVICE:
	266	sprintf(str, "%s Device Feature(%s%s)",
	267	b == USB_REQ_CLEAR_FEATURE ? "Clear" : "Set",
	268	({char *s;
	269	switch (v) {
	270	case USB_DEVICE_SELF_POWERED:
	271	s = "Self Powered";
	272	break;
	273	case USB_DEVICE_REMOTE_WAKEUP:
	274	s = "Remote Wakeup";
	275	break;
	276	case USB_DEVICE_TEST_MODE:
	277	s = "Test Mode";
	278	break;
	279	default:
	280	s = "UNKNOWN";
	281	} s; }),
	282	v == USB_DEVICE_TEST_MODE ?
	283	({ char *s;
	284	switch (i) {
	285	case TEST_J:
	286	s = ": TEST_J";
	287	break;
	288	case TEST_K:
	289	s = ": TEST_K";
	290	break;
	291	case TEST_SE0_NAK:
	292	s = ": TEST_SE0_NAK";
	293	break;
	294	case TEST_PACKET:
	295	s = ": TEST_PACKET";
	296	break;
	297	case TEST_FORCE_EN:
	298	s = ": TEST_FORCE_EN";
	299	break;
	300	default:
	301	s = ": UNKNOWN";
	302	} s; }) : "");
	303	break;
	304	case USB_RECIP_INTERFACE:
	305	sprintf(str, "%s Interface Feature(%s)",
	306	b == USB_REQ_CLEAR_FEATURE ? "Clear" : "Set",
	307	v == USB_INTRF_FUNC_SUSPEND ?
	308	"Function Suspend" : "UNKNOWN");
	309	break;
310	case USB_RECIP_ENDPOINT:
311	sprintf(str, "%s Endpoint Feature(%s ep%d%s)",
312	b == USB_REQ_CLEAR_FEATURE ? "Clear" : "Set",
313	v == USB_ENDPOINT_HALT ? "Halt" : "UNKNOWN",
314	i & ~USB_DIR_IN,
315	i & USB_DIR_IN ? "in" : "out");
316	break;
317	}
318	}
319
320	static inline void dwc3_decode_set_address(__u16 v, char *str)
321	{
322	sprintf(str, "Set Address(Addr = %02x)", v);
323	}
324
325	static inline void dwc3_decode_get_set_descriptor(__u8 t, __u8 b, __u16 v,
326	__u16 i, __u16 l, char *str)
327	{
328	sprintf(str, "%s %s Descriptor(Index = %d, Length = %d)",
329	b == USB_REQ_GET_DESCRIPTOR ? "Get" : "Set",
330	({ char *s;
331	switch (v >> 8) {
332	case USB_DT_DEVICE:
333	s = "Device";
334	break;
335	case USB_DT_CONFIG:
336	s = "Configuration";
337	break;
338	case USB_DT_STRING:
339	s = "String";
340	break;
341	case USB_DT_INTERFACE:
342	s = "Interface";
343	break;
344	case USB_DT_ENDPOINT:
345	s = "Endpoint";
346	break;
347	case USB_DT_DEVICE_QUALIFIER:
348	s = "Device Qualifier";
349	break;
350	case USB_DT_OTHER_SPEED_CONFIG:
351	s = "Other Speed Config";
352	break;
353	case USB_DT_INTERFACE_POWER:
354	s = "Interface Power";
355	break;
356	case USB_DT_OTG:
357	s = "OTG";
358	break;
359	case USB_DT_DEBUG:
360	s = "Debug";
361	break;
362	case USB_DT_INTERFACE_ASSOCIATION:
363	s = "Interface Association";
364	break;
365	case USB_DT_BOS:
366	s = "BOS";
367	break;
368	case USB_DT_DEVICE_CAPABILITY:
369	s = "Device Capability";
370	break;
371	case USB_DT_PIPE_USAGE:
372	s = "Pipe Usage";
373	break;
374	case USB_DT_SS_ENDPOINT_COMP:
375	s = "SS Endpoint Companion";
376	break;
377	case USB_DT_SSP_ISOC_ENDPOINT_COMP:
378	s = "SSP Isochronous Endpoint Companion";
379	break;
380	default:
381	s = "UNKNOWN";
382	break;
383	} s; }), v & 0xff, l);
384	}
385
386
387	static inline void dwc3_decode_get_configuration(__u16 l, char *str)
388	{
389	sprintf(str, "Get Configuration(Length = %d)", l);
390	}
391
392	static inline void dwc3_decode_set_configuration(__u8 v, char *str)
393	{
394	sprintf(str, "Set Configuration(Config = %d)", v);
395	}
396
397	static inline void dwc3_decode_get_intf(__u16 i, __u16 l, char *str)
398	{
399	sprintf(str, "Get Interface(Intf = %d, Length = %d)", i, l);
400	}
401
402	static inline void dwc3_decode_set_intf(__u8 v, __u16 i, char *str)
403	{
404	sprintf(str, "Set Interface(Intf = %d, Alt.Setting = %d)", i, v);
405	}
406
407	static inline void dwc3_decode_synch_frame(__u16 i, __u16 l, char *str)
408	{
409	sprintf(str, "Synch Frame(Endpoint = %d, Length = %d)", i, l);
410	}
411
412	static inline void dwc3_decode_set_sel(__u16 l, char *str)
413	{
414	sprintf(str, "Set SEL(Length = %d)", l);
415	}
416
417	static inline void dwc3_decode_set_isoch_delay(__u8 v, char *str)
418	{
419	sprintf(str, "Set Isochronous Delay(Delay = %d ns)", v);
420	}
421
422	/**
423	* dwc3_decode_ctrl - returns a string represetion of ctrl request
424	*/
425	static inline const char dwc3_decode_ctrl(char str, __u8 bRequestType,
426	__u8 bRequest, __u16 wValue, __u16 wIndex, __u16 wLength)
427	{
428	switch (bRequest) {
429	case USB_REQ_GET_STATUS:
430	dwc3_decode_get_status(bRequestType, wIndex, wLength, str);
431	break;
432	case USB_REQ_CLEAR_FEATURE:
433	case USB_REQ_SET_FEATURE:
434	dwc3_decode_set_clear_feature(bRequestType, bRequest, wValue,
435	wIndex, str);
436	break;
437	case USB_REQ_SET_ADDRESS:
438	dwc3_decode_set_address(wValue, str);
439	break;
440	case USB_REQ_GET_DESCRIPTOR:
441	case USB_REQ_SET_DESCRIPTOR:
442	dwc3_decode_get_set_descriptor(bRequestType, bRequest, wValue,
443	wIndex, wLength, str);
444	break;
445	case USB_REQ_GET_CONFIGURATION:
446	dwc3_decode_get_configuration(wLength, str);
447	break;
448	case USB_REQ_SET_CONFIGURATION:
449	dwc3_decode_set_configuration(wValue, str);
450	break;
451	case USB_REQ_GET_INTERFACE:
452	dwc3_decode_get_intf(wIndex, wLength, str);
453	break;
454	case USB_REQ_SET_INTERFACE:
455	dwc3_decode_set_intf(wValue, wIndex, str);
456	break;
457	case USB_REQ_SYNCH_FRAME:
458	dwc3_decode_synch_frame(wIndex, wLength, str);
459	break;
460	case USB_REQ_SET_SEL:
461	dwc3_decode_set_sel(wLength, str);
462	break;
463	case USB_REQ_SET_ISOCH_DELAY:
464	dwc3_decode_set_isoch_delay(wValue, str);
465	break;
466	default:
467	sprintf(str, "%02x %02x %02x %02x %02x %02x %02x %02x",
468	bRequestType, bRequest,
469	cpu_to_le16(wValue) & 0xff,
470	cpu_to_le16(wValue) >> 8,
471	cpu_to_le16(wIndex) & 0xff,
472	cpu_to_le16(wIndex) >> 8,
473	cpu_to_le16(wLength) & 0xff,
474	cpu_to_le16(wLength) >> 8);
475	}
476
477	return str;
478	}
479
80977dc9 FB	480	/**
	481	* dwc3_ep_event_string - returns event name
	482	* @event: then event code
	483	*/
f75cacc4	484	static inline const char *
3587f36a FB	485	dwc3_ep_event_string(char str, const struct dwc3_event_depevt event,
3587f36a FB	486	u32 ep0state)
80977dc9	487	{
f75cacc4	488	u8 epnum = event->endpoint_number;
43c96be1	489	size_t len;
f75cacc4 FB	490	int status;
	491	int ret;
	492
	493	ret = sprintf(str, "ep%d%s: ", epnum >> 1,
696fe69d	494	(epnum & 1) ? "in" : "out");
f75cacc4 FB	495	if (ret < 0)
	496	return "UNKNOWN";
	497
	498	switch (event->endpoint_event) {
80977dc9	499	case DWC3_DEPEVT_XFERCOMPLETE:
f75cacc4	500	strcat(str, "Transfer Complete");
43c96be1 FB	501	len = strlen(str);
	502
	503	if (epnum <= 1)
	504	sprintf(str + len, " [%s]", dwc3_ep0_state_string(ep0state));
f75cacc4	505	break;
80977dc9	506	case DWC3_DEPEVT_XFERINPROGRESS:
f75cacc4 FB	507	strcat(str, "Transfer In-Progress");
f75cacc4 FB	508	break;
80977dc9	509	case DWC3_DEPEVT_XFERNOTREADY:
f75cacc4 FB	510	strcat(str, "Transfer Not Ready");
	511	status = event->status & DEPEVT_STATUS_TRANSFER_ACTIVE;
	512	strcat(str, status ? " (Active)" : " (Not Active)");
45a2af2f FB	513
	514	/* Control Endpoints */
	515	if (epnum <= 1) {
	516	int phase = DEPEVT_STATUS_CONTROL_PHASE(event->status);
	517
	518	switch (phase) {
	519	case DEPEVT_STATUS_CONTROL_DATA:
	520	strcat(str, " [Data Phase]");
	521	break;
	522	case DEPEVT_STATUS_CONTROL_STATUS:
	523	strcat(str, " [Status Phase]");
	524	}
	525	}
f75cacc4	526	break;
80977dc9	527	case DWC3_DEPEVT_RXTXFIFOEVT:
f75cacc4 FB	528	strcat(str, "FIFO");
f75cacc4 FB	529	break;
80977dc9	530	case DWC3_DEPEVT_STREAMEVT:
f75cacc4 FB	531	status = event->status;
	532
	533	switch (status) {
	534	case DEPEVT_STREAMEVT_FOUND:
	535	sprintf(str + ret, " Stream %d Found",
	536	event->parameters);
	537	break;
	538	case DEPEVT_STREAMEVT_NOTFOUND:
	539	default:
	540	strcat(str, " Stream Not Found");
	541	break;
	542	}
	543
	544	break;
80977dc9	545	case DWC3_DEPEVT_EPCMDCMPLT:
f75cacc4 FB	546	strcat(str, "Endpoint Command Complete");
	547	break;
	548	default:
	549	sprintf(str, "UNKNOWN");
80977dc9 FB	550	}
80977dc9 FB	551
f75cacc4	552	return str;
80977dc9 FB	553	}
80977dc9 FB	554
e996061b FB	555	/**
	556	* dwc3_gadget_event_type_string - return event name
	557	* @event: the event code
	558	*/
	559	static inline const char *dwc3_gadget_event_type_string(u8 event)
	560	{
	561	switch (event) {
	562	case DWC3_DEVICE_EVENT_DISCONNECT:
	563	return "Disconnect";
	564	case DWC3_DEVICE_EVENT_RESET:
	565	return "Reset";
	566	case DWC3_DEVICE_EVENT_CONNECT_DONE:
	567	return "Connect Done";
	568	case DWC3_DEVICE_EVENT_LINK_STATUS_CHANGE:
	569	return "Link Status Change";
	570	case DWC3_DEVICE_EVENT_WAKEUP:
	571	return "Wake-Up";
	572	case DWC3_DEVICE_EVENT_HIBER_REQ:
	573	return "Hibernation";
	574	case DWC3_DEVICE_EVENT_EOPF:
	575	return "End of Periodic Frame";
	576	case DWC3_DEVICE_EVENT_SOF:
	577	return "Start of Frame";
	578	case DWC3_DEVICE_EVENT_ERRATIC_ERROR:
	579	return "Erratic Error";
	580	case DWC3_DEVICE_EVENT_CMD_CMPL:
	581	return "Command Complete";
	582	case DWC3_DEVICE_EVENT_OVERFLOW:
	583	return "Overflow";
	584	default:
	585	return "UNKNOWN";
	586	}
	587	}
	588
3587f36a	589	static inline const char dwc3_decode_event(char str, u32 event, u32 ep0state)
f75cacc4 FB	590	{
	591	const union dwc3_event evt = (union dwc3_event) event;
	592
	593	if (evt.type.is_devspec)
3587f36a	594	return dwc3_gadget_event_string(str, &evt.devt);
f75cacc4	595	else
3587f36a	596	return dwc3_ep_event_string(str, &evt.depevt, ep0state);
f75cacc4 FB	597	}
f75cacc4 FB	598
0933df15 FB	599	static inline const char *dwc3_ep_cmd_status_string(int status)
	600	{
	601	switch (status) {
	602	case -ETIMEDOUT:
	603	return "Timed Out";
	604	case 0:
	605	return "Successful";
	606	case DEPEVT_TRANSFER_NO_RESOURCE:
	607	return "No Resource";
	608	case DEPEVT_TRANSFER_BUS_EXPIRY:
	609	return "Bus Expiry";
	610	default:
	611	return "UNKNOWN";
	612	}
	613	}
	614
71f7e702 FB	615	static inline const char *dwc3_gadget_generic_cmd_status_string(int status)
	616	{
	617	switch (status) {
	618	case -ETIMEDOUT:
	619	return "Timed Out";
	620	case 0:
	621	return "Successful";
	622	case 1:
	623	return "Error";
	624	default:
	625	return "UNKNOWN";
	626	}
	627	}
	628
57b14da5	629
72246da4	630	#ifdef CONFIG_DEBUG_FS
4e9f3118	631	extern void dwc3_debugfs_init(struct dwc3 *);
72246da4 FB	632	extern void dwc3_debugfs_exit(struct dwc3 *);
72246da4 FB	633	#else
4e9f3118 DC	634	static inline void dwc3_debugfs_init(struct dwc3 *d)
4e9f3118 DC	635	{ }
72246da4 FB	636	static inline void dwc3_debugfs_exit(struct dwc3 *d)
	637	{ }
	638	#endif
80977dc9	639	#endif /* __DWC3_DEBUG_H */