Unverified Commit 118b2a32 authored by Pawel Laszczak's avatar Pawel Laszczak Committed by Peter Chen
Browse files

usb: cdnsp: Add tracepoints for CDNSP driver 



Patch adds the series of tracepoints that can be used for
debugging issues detected in driver.

Signed-off-by: default avatarPawel Laszczak <pawell@cadence.com>
Reviewed-by: default avatarPeter Chen <peter.chen@nxp.com>
Signed-off-by: default avatarPeter Chen <peter.chen@nxp.com>
parent 3d829045

drivers/usb/cdns3/Makefile

+5 −0
Original line number Diff line number Diff line 
# SPDX-License-Identifier: GPL-2.0

# define_trace.h needs to know how to find our header

CFLAGS_trace.o					:= -I$(src)

CFLAGS_cdnsp-trace.o				:= -I$(src)



cdns-usb-common-y				:= core.o drd.o

cdns3-y						:= cdns3-plat.o
@@ -23,3 +24,7 @@ cdnsp-udc-pci-y := cdnsp-pci.o 
obj-$(CONFIG_USB_CDNSP_PCI) 			+= cdnsp-udc-pci.o

cdnsp-udc-pci-$(CONFIG_USB_CDNSP_GADGET)	+= cdnsp-ring.o cdnsp-gadget.o \

						   cdnsp-mem.o cdnsp-ep0.o



ifneq ($(CONFIG_USB_CDNSP_GADGET),)

cdnsp-udc-pci-$(CONFIG_TRACING)			+= cdnsp-trace.o

endif

drivers/usb/cdns3/cdnsp-debug.h

0 → 100644
+583 −0
Original line number Diff line number Diff line 
/* SPDX-License-Identifier: GPL-2.0 */

/*

 * Cadence CDNSP DRD Driver.

 *

 * Copyright (C) 2020 Cadence.

 *

 * Author: Pawel Laszczak <pawell@cadence.com>

 *

 */

#ifndef __LINUX_CDNSP_DEBUG

#define __LINUX_CDNSP_DEBUG



static inline const char *cdnsp_trb_comp_code_string(u8 status)

{

	switch (status) {

	case COMP_INVALID:

		return "Invalid";

	case COMP_SUCCESS:

		return "Success";

	case COMP_DATA_BUFFER_ERROR:

		return "Data Buffer Error";

	case COMP_BABBLE_DETECTED_ERROR:

		return "Babble Detected";

	case COMP_TRB_ERROR:

		return "TRB Error";

	case COMP_RESOURCE_ERROR:

		return "Resource Error";

	case COMP_NO_SLOTS_AVAILABLE_ERROR:

		return "No Slots Available Error";

	case COMP_INVALID_STREAM_TYPE_ERROR:

		return "Invalid Stream Type Error";

	case COMP_SLOT_NOT_ENABLED_ERROR:

		return "Slot Not Enabled Error";

	case COMP_ENDPOINT_NOT_ENABLED_ERROR:

		return "Endpoint Not Enabled Error";

	case COMP_SHORT_PACKET:

		return "Short Packet";

	case COMP_RING_UNDERRUN:

		return "Ring Underrun";

	case COMP_RING_OVERRUN:

		return "Ring Overrun";

	case COMP_VF_EVENT_RING_FULL_ERROR:

		return "VF Event Ring Full Error";

	case COMP_PARAMETER_ERROR:

		return "Parameter Error";

	case COMP_CONTEXT_STATE_ERROR:

		return "Context State Error";

	case COMP_EVENT_RING_FULL_ERROR:

		return "Event Ring Full Error";

	case COMP_INCOMPATIBLE_DEVICE_ERROR:

		return "Incompatible Device Error";

	case COMP_MISSED_SERVICE_ERROR:

		return "Missed Service Error";

	case COMP_COMMAND_RING_STOPPED:

		return "Command Ring Stopped";

	case COMP_COMMAND_ABORTED:

		return "Command Aborted";

	case COMP_STOPPED:

		return "Stopped";

	case COMP_STOPPED_LENGTH_INVALID:

		return "Stopped - Length Invalid";

	case COMP_STOPPED_SHORT_PACKET:

		return "Stopped - Short Packet";

	case COMP_MAX_EXIT_LATENCY_TOO_LARGE_ERROR:

		return "Max Exit Latency Too Large Error";

	case COMP_ISOCH_BUFFER_OVERRUN:

		return "Isoch Buffer Overrun";

	case COMP_EVENT_LOST_ERROR:

		return "Event Lost Error";

	case COMP_UNDEFINED_ERROR:

		return "Undefined Error";

	case COMP_INVALID_STREAM_ID_ERROR:

		return "Invalid Stream ID Error";

	default:

		return "Unknown!!";

	}

}



static inline const char *cdnsp_trb_type_string(u8 type)

{

	switch (type) {

	case TRB_NORMAL:

		return "Normal";

	case TRB_SETUP:

		return "Setup Stage";

	case TRB_DATA:

		return "Data Stage";

	case TRB_STATUS:

		return "Status Stage";

	case TRB_ISOC:

		return "Isoch";

	case TRB_LINK:

		return "Link";

	case TRB_EVENT_DATA:

		return "Event Data";

	case TRB_TR_NOOP:

		return "No-Op";

	case TRB_ENABLE_SLOT:

		return "Enable Slot Command";

	case TRB_DISABLE_SLOT:

		return "Disable Slot Command";

	case TRB_ADDR_DEV:

		return "Address Device Command";

	case TRB_CONFIG_EP:

		return "Configure Endpoint Command";

	case TRB_EVAL_CONTEXT:

		return "Evaluate Context Command";

	case TRB_RESET_EP:

		return "Reset Endpoint Command";

	case TRB_STOP_RING:

		return "Stop Ring Command";

	case TRB_SET_DEQ:

		return "Set TR Dequeue Pointer Command";

	case TRB_RESET_DEV:

		return "Reset Device Command";

	case TRB_FORCE_HEADER:

		return "Force Header Command";

	case TRB_CMD_NOOP:

		return "No-Op Command";

	case TRB_TRANSFER:

		return "Transfer Event";

	case TRB_COMPLETION:

		return "Command Completion Event";

	case TRB_PORT_STATUS:

		return "Port Status Change Event";

	case TRB_HC_EVENT:

		return "Device Controller Event";

	case TRB_MFINDEX_WRAP:

		return "MFINDEX Wrap Event";

	case TRB_ENDPOINT_NRDY:

		return "Endpoint Not ready";

	case TRB_HALT_ENDPOINT:

		return "Halt Endpoint";

	case TRB_FLUSH_ENDPOINT:

		return "FLush Endpoint";

	default:

		return "UNKNOWN";

	}

}



static inline const char *cdnsp_ring_type_string(enum cdnsp_ring_type type)

{

	switch (type) {

	case TYPE_CTRL:

		return "CTRL";

	case TYPE_ISOC:

		return "ISOC";

	case TYPE_BULK:

		return "BULK";

	case TYPE_INTR:

		return "INTR";

	case TYPE_STREAM:

		return "STREAM";

	case TYPE_COMMAND:

		return "CMD";

	case TYPE_EVENT:

		return "EVENT";

	}



	return "UNKNOWN";

}



static inline char *cdnsp_slot_state_string(u32 state)

{

	switch (state) {

	case SLOT_STATE_ENABLED:

		return "enabled/disabled";

	case SLOT_STATE_DEFAULT:

		return "default";

	case SLOT_STATE_ADDRESSED:

		return "addressed";

	case SLOT_STATE_CONFIGURED:

		return "configured";

	default:

		return "reserved";

	}

}



static inline const char *cdnsp_decode_trb(char *str, size_t size, u32 field0,

					   u32 field1, u32 field2, u32 field3)

{

	int ep_id = TRB_TO_EP_INDEX(field3) - 1;

	int type = TRB_FIELD_TO_TYPE(field3);

	unsigned int ep_num;

	int ret = 0;

	u32 temp;



	ep_num = DIV_ROUND_UP(ep_id, 2);



	switch (type) {

	case TRB_LINK:

		ret += snprintf(str, size,

				"LINK %08x%08x intr %ld type '%s' flags %c:%c:%c:%c",

				field1, field0, GET_INTR_TARGET(field2),

				cdnsp_trb_type_string(type),

				field3 & TRB_IOC ? 'I' : 'i',

				field3 & TRB_CHAIN ? 'C' : 'c',

				field3 & TRB_TC ? 'T' : 't',

				field3 & TRB_CYCLE ? 'C' : 'c');

		break;

	case TRB_TRANSFER:

	case TRB_COMPLETION:

	case TRB_PORT_STATUS:

	case TRB_HC_EVENT:

		ret += snprintf(str, size,

				"ep%d%s(%d) type '%s' TRB %08x%08x status '%s'"

				" len %ld slot %ld flags %c:%c",

				ep_num, ep_id % 2 ? "out" : "in",

				TRB_TO_EP_INDEX(field3),

				cdnsp_trb_type_string(type), field1, field0,

				cdnsp_trb_comp_code_string(GET_COMP_CODE(field2)),

				EVENT_TRB_LEN(field2), TRB_TO_SLOT_ID(field3),

				field3 & EVENT_DATA ? 'E' : 'e',

				field3 & TRB_CYCLE ? 'C' : 'c');

		break;

	case TRB_MFINDEX_WRAP:

		ret += snprintf(str, size, "%s: flags %c",

				cdnsp_trb_type_string(type),

				field3 & TRB_CYCLE ? 'C' : 'c');

		break;

	case TRB_SETUP:

		ret += snprintf(str, size,

				"type '%s' bRequestType %02x bRequest %02x "

				"wValue %02x%02x wIndex %02x%02x wLength %d "

				"length %ld TD size %ld intr %ld Setup ID %ld "

				"flags %c:%c:%c",

				cdnsp_trb_type_string(type),

				field0 & 0xff,

				(field0 & 0xff00) >> 8,

				(field0 & 0xff000000) >> 24,

				(field0 & 0xff0000) >> 16,

				(field1 & 0xff00) >> 8,

				field1 & 0xff,

				(field1 & 0xff000000) >> 16 |

				(field1 & 0xff0000) >> 16,

				TRB_LEN(field2), GET_TD_SIZE(field2),

				GET_INTR_TARGET(field2),

				TRB_SETUPID_TO_TYPE(field3),

				field3 & TRB_IDT ? 'D' : 'd',

				field3 & TRB_IOC ? 'I' : 'i',

				field3 & TRB_CYCLE ? 'C' : 'c');

		break;

	case TRB_DATA:

		ret += snprintf(str, size,

				"type '%s' Buffer %08x%08x length %ld TD size %ld "

				"intr %ld flags %c:%c:%c:%c:%c:%c:%c",

				cdnsp_trb_type_string(type),

				field1, field0, TRB_LEN(field2),

				GET_TD_SIZE(field2),

				GET_INTR_TARGET(field2),

				field3 & TRB_IDT ? 'D' : 'i',

				field3 & TRB_IOC ? 'I' : 'i',

				field3 & TRB_CHAIN ? 'C' : 'c',

				field3 & TRB_NO_SNOOP ? 'S' : 's',

				field3 & TRB_ISP ? 'I' : 'i',

				field3 & TRB_ENT ? 'E' : 'e',

				field3 & TRB_CYCLE ? 'C' : 'c');

		break;

	case TRB_STATUS:

		ret += snprintf(str, size,

				"Buffer %08x%08x length %ld TD size %ld intr"

				"%ld type '%s' flags %c:%c:%c:%c",

				field1, field0, TRB_LEN(field2),

				GET_TD_SIZE(field2),

				GET_INTR_TARGET(field2),

				cdnsp_trb_type_string(type),

				field3 & TRB_IOC ? 'I' : 'i',

				field3 & TRB_CHAIN ? 'C' : 'c',

				field3 & TRB_ENT ? 'E' : 'e',

				field3 & TRB_CYCLE ? 'C' : 'c');

		break;

	case TRB_NORMAL:

	case TRB_ISOC:

	case TRB_EVENT_DATA:

	case TRB_TR_NOOP:

		ret += snprintf(str, size,

				"type '%s' Buffer %08x%08x length %ld "

				"TD size %ld intr %ld "

				"flags %c:%c:%c:%c:%c:%c:%c:%c:%c",

				cdnsp_trb_type_string(type),

				field1, field0, TRB_LEN(field2),

				GET_TD_SIZE(field2),

				GET_INTR_TARGET(field2),

				field3 & TRB_BEI ? 'B' : 'b',

				field3 & TRB_IDT ? 'T' : 't',

				field3 & TRB_IOC ? 'I' : 'i',

				field3 & TRB_CHAIN ? 'C' : 'c',

				field3 & TRB_NO_SNOOP ? 'S' : 's',

				field3 & TRB_ISP ? 'I' : 'i',

				field3 & TRB_ENT ? 'E' : 'e',

				field3 & TRB_CYCLE ? 'C' : 'c',

				!(field3 & TRB_EVENT_INVALIDATE) ? 'V' : 'v');

		break;

	case TRB_CMD_NOOP:

	case TRB_ENABLE_SLOT:

		ret += snprintf(str, size, "%s: flags %c",

				cdnsp_trb_type_string(type),

				field3 & TRB_CYCLE ? 'C' : 'c');

		break;

	case TRB_DISABLE_SLOT:

		ret += snprintf(str, size, "%s: slot %ld flags %c",

				cdnsp_trb_type_string(type),

				TRB_TO_SLOT_ID(field3),

				field3 & TRB_CYCLE ? 'C' : 'c');

		break;

	case TRB_ADDR_DEV:

		ret += snprintf(str, size,

				"%s: ctx %08x%08x slot %ld flags %c:%c",

				cdnsp_trb_type_string(type), field1, field0,

				TRB_TO_SLOT_ID(field3),

				field3 & TRB_BSR ? 'B' : 'b',

				field3 & TRB_CYCLE ? 'C' : 'c');

		break;

	case TRB_CONFIG_EP:

		ret += snprintf(str, size,

				"%s: ctx %08x%08x slot %ld flags %c:%c",

				cdnsp_trb_type_string(type), field1, field0,

				TRB_TO_SLOT_ID(field3),

				field3 & TRB_DC ? 'D' : 'd',

				field3 & TRB_CYCLE ? 'C' : 'c');

		break;

	case TRB_EVAL_CONTEXT:

		ret += snprintf(str, size,

				"%s: ctx %08x%08x slot %ld flags %c",

				cdnsp_trb_type_string(type), field1, field0,

				TRB_TO_SLOT_ID(field3),

				field3 & TRB_CYCLE ? 'C' : 'c');

		break;

	case TRB_RESET_EP:

	case TRB_HALT_ENDPOINT:

	case TRB_FLUSH_ENDPOINT:

		ret += snprintf(str, size,

				"%s: ep%d%s(%d) ctx %08x%08x slot %ld flags %c",

				cdnsp_trb_type_string(type),

				ep_num, ep_id % 2 ? "out" : "in",

				TRB_TO_EP_INDEX(field3), field1, field0,

				TRB_TO_SLOT_ID(field3),

				field3 & TRB_CYCLE ? 'C' : 'c');

		break;

	case TRB_STOP_RING:

		ret += snprintf(str, size,

				"%s: ep%d%s(%d) slot %ld sp %d flags %c",

				cdnsp_trb_type_string(type),

				ep_num, ep_id % 2 ? "out" : "in",

				TRB_TO_EP_INDEX(field3),

				TRB_TO_SLOT_ID(field3),

				TRB_TO_SUSPEND_PORT(field3),

				field3 & TRB_CYCLE ? 'C' : 'c');

		break;

	case TRB_SET_DEQ:

		ret += snprintf(str, size,

				"%s: ep%d%s(%d) deq %08x%08x stream %ld slot %ld  flags %c",

				cdnsp_trb_type_string(type),

				ep_num, ep_id % 2 ? "out" : "in",

				TRB_TO_EP_INDEX(field3), field1, field0,

				TRB_TO_STREAM_ID(field2),

				TRB_TO_SLOT_ID(field3),

				field3 & TRB_CYCLE ? 'C' : 'c');

		break;

	case TRB_RESET_DEV:

		ret += snprintf(str, size, "%s: slot %ld flags %c",

				cdnsp_trb_type_string(type),

				TRB_TO_SLOT_ID(field3),

				field3 & TRB_CYCLE ? 'C' : 'c');

		break;

	case TRB_ENDPOINT_NRDY:

		temp  = TRB_TO_HOST_STREAM(field2);



		ret += snprintf(str, size,

				"%s: ep%d%s(%d) H_SID %x%s%s D_SID %lx flags %c:%c",

				cdnsp_trb_type_string(type),

				ep_num, ep_id % 2 ? "out" : "in",

				TRB_TO_EP_INDEX(field3), temp,

				temp == STREAM_PRIME_ACK ? "(PRIME)" : "",

				temp == STREAM_REJECTED ? "(REJECTED)" : "",

				TRB_TO_DEV_STREAM(field0),

				field3 & TRB_STAT ? 'S' : 's',

				field3 & TRB_CYCLE ? 'C' : 'c');

		break;

	default:

		ret += snprintf(str, size,

				"type '%s' -> raw %08x %08x %08x %08x",

				cdnsp_trb_type_string(type),

				field0, field1, field2, field3);

	}



	return str;

}



static inline const char *cdnsp_decode_slot_context(u32 info, u32 info2,

						    u32 int_target, u32 state)

{

	static char str[1024];

	int ret = 0;

	u32 speed;

	char *s;



	speed = info & DEV_SPEED;



	switch (speed) {

	case SLOT_SPEED_FS:

		s = "full-speed";

		break;

	case SLOT_SPEED_HS:

		s = "high-speed";

		break;

	case SLOT_SPEED_SS:

		s = "super-speed";

		break;

	case SLOT_SPEED_SSP:

		s = "super-speed plus";

		break;

	default:

		s = "UNKNOWN speed";

	}



	ret = sprintf(str, "%s Ctx Entries %ld",

		      s, (info & LAST_CTX_MASK) >> 27);



	ret += sprintf(str + ret, " [Intr %ld] Addr %ld State %s",

		       GET_INTR_TARGET(int_target), state & DEV_ADDR_MASK,

		       cdnsp_slot_state_string(GET_SLOT_STATE(state)));



	return str;

}



static inline const char *cdnsp_portsc_link_state_string(u32 portsc)

{

	switch (portsc & PORT_PLS_MASK) {

	case XDEV_U0:

		return "U0";

	case XDEV_U1:

		return "U1";

	case XDEV_U2:

		return "U2";

	case XDEV_U3:

		return "U3";

	case XDEV_DISABLED:

		return "Disabled";

	case XDEV_RXDETECT:

		return "RxDetect";

	case XDEV_INACTIVE:

		return "Inactive";

	case XDEV_POLLING:

		return "Polling";

	case XDEV_RECOVERY:

		return "Recovery";

	case XDEV_HOT_RESET:

		return "Hot Reset";

	case XDEV_COMP_MODE:

		return "Compliance mode";

	case XDEV_TEST_MODE:

		return "Test mode";

	case XDEV_RESUME:

		return "Resume";

	default:

		break;

	}



	return "Unknown";

}



static inline const char *cdnsp_decode_portsc(char *str, size_t size,

					      u32 portsc)

{

	int ret;



	ret = snprintf(str, size, "%s %s %s Link:%s PortSpeed:%d ",

		       portsc & PORT_POWER ? "Powered" : "Powered-off",

		       portsc & PORT_CONNECT ? "Connected" : "Not-connected",

		       portsc & PORT_PED ? "Enabled" : "Disabled",

		       cdnsp_portsc_link_state_string(portsc),

		       DEV_PORT_SPEED(portsc));



	if (portsc & PORT_RESET)

		ret += snprintf(str + ret, size - ret, "In-Reset ");



	ret += snprintf(str + ret, size - ret, "Change: ");

	if (portsc & PORT_CSC)

		ret += snprintf(str + ret, size - ret, "CSC ");

	if (portsc & PORT_WRC)

		ret += snprintf(str + ret, size - ret, "WRC ");

	if (portsc & PORT_RC)

		ret += snprintf(str + ret, size - ret, "PRC ");

	if (portsc & PORT_PLC)

		ret += snprintf(str + ret, size - ret, "PLC ");

	if (portsc & PORT_CEC)

		ret += snprintf(str + ret, size - ret, "CEC ");

	ret += snprintf(str + ret, size - ret, "Wake: ");

	if (portsc & PORT_WKCONN_E)

		ret += snprintf(str + ret, size - ret, "WCE ");

	if (portsc & PORT_WKDISC_E)

		ret += snprintf(str + ret, size - ret, "WDE ");



	return str;

}



static inline const char *cdnsp_ep_state_string(u8 state)

{

	switch (state) {

	case EP_STATE_DISABLED:

		return "disabled";

	case EP_STATE_RUNNING:

		return "running";

	case EP_STATE_HALTED:

		return "halted";

	case EP_STATE_STOPPED:

		return "stopped";

	case EP_STATE_ERROR:

		return "error";

	default:

		return "INVALID";

	}

}



static inline const char *cdnsp_ep_type_string(u8 type)

{

	switch (type) {

	case ISOC_OUT_EP:

		return "Isoc OUT";

	case BULK_OUT_EP:

		return "Bulk OUT";

	case INT_OUT_EP:

		return "Int OUT";

	case CTRL_EP:

		return "Ctrl";

	case ISOC_IN_EP:

		return "Isoc IN";

	case BULK_IN_EP:

		return "Bulk IN";

	case INT_IN_EP:

		return "Int IN";

	default:

		return "INVALID";

	}

}



static inline const char *cdnsp_decode_ep_context(char *str, size_t size,

						  u32 info, u32 info2,

						  u64 deq, u32 tx_info)

{

	u8 max_pstr, ep_state, interval, ep_type, burst, cerr, mult;

	bool lsa, hid;

	u16 maxp, avg;

	u32 esit;

	int ret;



	esit = CTX_TO_MAX_ESIT_PAYLOAD_HI(info) << 16 |

	       CTX_TO_MAX_ESIT_PAYLOAD_LO(tx_info);



	ep_state = info & EP_STATE_MASK;

	max_pstr = CTX_TO_EP_MAXPSTREAMS(info);

	interval = CTX_TO_EP_INTERVAL(info);

	mult = CTX_TO_EP_MULT(info) + 1;

	lsa = !!(info & EP_HAS_LSA);



	cerr = (info2 & (3 << 1)) >> 1;

	ep_type = CTX_TO_EP_TYPE(info2);

	hid = !!(info2 & (1 << 7));

	burst = CTX_TO_MAX_BURST(info2);

	maxp = MAX_PACKET_DECODED(info2);



	avg = EP_AVG_TRB_LENGTH(tx_info);



	ret = snprintf(str, size, "State %s mult %d max P. Streams %d %s",

		       cdnsp_ep_state_string(ep_state), mult,

		       max_pstr, lsa ? "LSA " : "");



	ret += snprintf(str + ret, size - ret,

			"interval %d us max ESIT payload %d CErr %d ",

			(1 << interval) * 125, esit, cerr);



	ret += snprintf(str + ret, size - ret,

			"Type %s %sburst %d maxp %d deq %016llx ",

			cdnsp_ep_type_string(ep_type), hid ? "HID" : "",

			burst, maxp, deq);



	ret += snprintf(str + ret, size - ret, "avg trb len %d", avg);



	return str;

}



#endif /*__LINUX_CDNSP_DEBUG*/

drivers/usb/cdns3/cdnsp-ep0.c

+20 −2
Original line number Diff line number Diff line
@@ -13,6 +13,7 @@ 
#include <linux/list.h>



#include "cdnsp-gadget.h"

#include "cdnsp-trace.h"



static void cdnsp_ep0_stall(struct cdnsp_device *pdev)

{
@@ -23,11 +24,13 @@ static void cdnsp_ep0_stall(struct cdnsp_device *pdev) 
	preq = next_request(&pep->pending_list);



	if (pdev->three_stage_setup) {

		trace_cdnsp_ep0_data_stage("send stall");

		cdnsp_halt_endpoint(pdev, pep, true);



		if (preq)

			cdnsp_gadget_giveback(pep, preq, -ECONNRESET);

	} else {

		trace_cdnsp_ep0_status_stage("send stall");

		pep->ep_state |= EP0_HALTED_STATUS;



		if (preq)
@@ -42,6 +45,8 @@ static int cdnsp_ep0_delegate_req(struct cdnsp_device *pdev, 
{

	int ret;



	trace_cdnsp_ep0_request("delagete");



	spin_unlock(&pdev->lock);

	ret = pdev->gadget_driver->setup(&pdev->gadget, ctrl);

	spin_lock(&pdev->lock);
@@ -60,8 +65,10 @@ static int cdnsp_ep0_set_config(struct cdnsp_device *pdev, 


	switch (state) {

	case USB_STATE_ADDRESS:

		trace_cdnsp_ep0_set_config("from Address state");

		break;

	case USB_STATE_CONFIGURED:

		trace_cdnsp_ep0_set_config("from Configured state");

		break;

	default:

		dev_err(pdev->dev, "Set Configuration - bad device state\n");
@@ -123,6 +130,7 @@ static int cdnsp_ep0_set_address(struct cdnsp_device *pdev, 


int cdnsp_status_stage(struct cdnsp_device *pdev)

{

	trace_cdnsp_ep0_status_stage("preparing");

	pdev->ep0_stage = CDNSP_STATUS_STAGE;

	pdev->ep0_preq.request.length = 0;
@@ -211,18 +219,21 @@ static int cdnsp_ep0_handle_feature_device(struct cdnsp_device *pdev, 
	switch (le16_to_cpu(ctrl->wValue)) {

	case USB_DEVICE_REMOTE_WAKEUP:

		pdev->may_wakeup = !!set;

		trace_cdnsp_may_wakeup(set);

		break;

	case USB_DEVICE_U1_ENABLE:

		if (state != USB_STATE_CONFIGURED || speed < USB_SPEED_SUPER)

			return -EINVAL;



		pdev->u1_allowed = !!set;

		trace_cdnsp_u1(set);

		break;

	case USB_DEVICE_U2_ENABLE:

		if (state != USB_STATE_CONFIGURED || speed < USB_SPEED_SUPER)

			return -EINVAL;



		pdev->u2_allowed = !!set;

		trace_cdnsp_u2(set);

		break;

	case USB_DEVICE_LTM_ENABLE:

		return -EINVAL;
@@ -426,6 +437,8 @@ void cdnsp_setup_analyze(struct cdnsp_device *pdev) 
	int ret = 0;

	__le16 len;



	trace_cdnsp_ctrl_req(ctrl);



	if (!pdev->gadget_driver)

		goto out;
@@ -436,8 +449,10 @@ void cdnsp_setup_analyze(struct cdnsp_device *pdev) 
	}



	/* Restore the ep0 to Stopped/Running state. */

	if (pdev->eps[0].ep_state & EP_HALTED)

	if (pdev->eps[0].ep_state & EP_HALTED) {

		trace_cdnsp_ep0_halted("Restore to normal state");

		cdnsp_halt_endpoint(pdev, &pdev->eps[0], 0);

	}



	/*

	 * Finishing previous SETUP transfer by removing request from
@@ -446,6 +461,7 @@ void cdnsp_setup_analyze(struct cdnsp_device *pdev) 
	if (!list_empty(&pdev->eps[0].pending_list)) {

		struct cdnsp_request	*req;



		trace_cdnsp_ep0_request("Remove previous");

		req = next_request(&pdev->eps[0].pending_list);

		cdnsp_ep_dequeue(&pdev->eps[0], req);

	}
@@ -467,8 +483,10 @@ void cdnsp_setup_analyze(struct cdnsp_device *pdev) 
	if (!len)

		pdev->ep0_stage = CDNSP_STATUS_STAGE;



	if (ret == USB_GADGET_DELAYED_STATUS)

	if (ret == USB_GADGET_DELAYED_STATUS) {

		trace_cdnsp_ep0_status_stage("delayed");

		return;

	}

out:

	if (ret < 0)

		cdnsp_ep0_stall(pdev);

drivers/usb/cdns3/cdnsp-gadget.c

+69 −6

File changed.

Preview size limit exceeded, changes collapsed.

drivers/usb/cdns3/cdnsp-mem.c

+16 −2
Original line number Diff line number Diff line
@@ -16,6 +16,7 @@ 
#include <linux/usb.h>



#include "cdnsp-gadget.h"

#include "cdnsp-trace.h"



static void cdnsp_free_stream_info(struct cdnsp_device *pdev,

				   struct cdnsp_ep *pep);
@@ -281,6 +282,8 @@ static void cdnsp_ring_free(struct cdnsp_device *pdev, struct cdnsp_ring *ring) 
	if (!ring)

		return;



	trace_cdnsp_ring_free(ring);



	if (ring->first_seg) {

		if (ring->type == TYPE_STREAM)

			cdnsp_remove_stream_mapping(ring);
@@ -397,7 +400,7 @@ static struct cdnsp_ring *cdnsp_ring_alloc(struct cdnsp_device *pdev, 
			cpu_to_le32(LINK_TOGGLE);



	cdnsp_initialize_ring_info(ring);



	trace_cdnsp_ring_alloc(ring);

	return ring;

fail:

	kfree(ring);
@@ -450,6 +453,7 @@ int cdnsp_ring_expansion(struct cdnsp_device *pdev, 
	}



	cdnsp_link_rings(pdev, ring, first, last, num_segs);

	trace_cdnsp_ring_expansion(ring);



	return 0;

}
@@ -610,6 +614,8 @@ int cdnsp_alloc_stream_info(struct cdnsp_device *pdev, 
		stream_info->stream_ctx_array[cur_stream].stream_ring =

			cpu_to_le64(addr);



		trace_cdnsp_set_stream_ring(cur_ring);



		ret = cdnsp_update_stream_mapping(cur_ring);

		if (ret)

			goto cleanup_rings;
@@ -695,6 +701,7 @@ static int cdnsp_alloc_priv_device(struct cdnsp_device *pdev, gfp_t flags) 
	pdev->dcbaa->dev_context_ptrs[1] = cpu_to_le64(pdev->out_ctx.dma);

	pdev->cmd.in_ctx = &pdev->in_ctx;



	trace_cdnsp_alloc_priv_device(pdev);

	return 0;

fail:

	dma_pool_free(pdev->device_pool, pdev->out_ctx.bytes,
@@ -761,6 +768,8 @@ int cdnsp_setup_addressable_priv_dev(struct cdnsp_device *pdev) 
	ep0_ctx->deq = cpu_to_le64(pdev->eps[0].ring->first_seg->dma |

				   pdev->eps[0].ring->cycle_state);



	trace_cdnsp_setup_addressable_priv_device(pdev);



	return 0;

}
@@ -1112,7 +1121,7 @@ static void cdnsp_add_in_port(struct cdnsp_device *pdev, 
			      struct cdnsp_port *port,

			      __le32 __iomem *addr)

{

	u32 temp, port_offset;

	u32 temp, port_offset, port_count;



	temp = readl(addr);

	port->maj_rev = CDNSP_EXT_PORT_MAJOR(temp);
@@ -1121,6 +1130,9 @@ static void cdnsp_add_in_port(struct cdnsp_device *pdev, 
	/* Port offset and count in the third dword.*/

	temp = readl(addr + 2);

	port_offset = CDNSP_EXT_PORT_OFF(temp);

	port_count = CDNSP_EXT_PORT_COUNT(temp);



	trace_cdnsp_port_info(addr, port_offset, port_count, port->maj_rev);



	port->port_num = port_offset;

	port->exist = 1;
@@ -1171,6 +1183,8 @@ static int cdnsp_setup_port_arrays(struct cdnsp_device *pdev, gfp_t flags) 
		return -ENODEV;

	}



	trace_cdnsp_init("Found USB 2.0 ports and  USB 3.0 ports.");



	pdev->usb2_port.regs = (struct cdnsp_port_regs *)

			       (&pdev->op_regs->port_reg_base + NUM_PORT_REGS *

				(pdev->usb2_port.port_num - 1));