diff --git a/drivers/usb/cdns3/debug.h b/drivers/usb/cdns3/debug.h
new file mode 100644
index 000000000000..afb81d224718
--- /dev/null
+++ b/drivers/usb/cdns3/debug.h

@@ -0,0 +1,346 @@
+/* SPDX-License-Identifier: GPL-2.0 */
+/*
+ * Cadence USBSS DRD Driver.
+ * Debug header file.
+ *
+ * Copyright (C) 2018 Cadence.
+ *
+ * Author: Pawel Laszczak <pawell@cadence.com>
+ */
+#ifndef __LINUX_CDNS3_DEBUG
+#define __LINUX_CDNS3_DEBUG
+#include "gadget.h"
+
+static inline void cdns3_decode_get_status(u8 bRequestType, u16 wIndex,
+					   u16 wLength, char *str)
+{
+	switch (bRequestType & USB_RECIP_MASK) {
+	case USB_RECIP_INTERFACE:
+		sprintf(str, "Get Interface Status Intf = %d, L: = %d",
+			wIndex, wLength);
+		break;
+	case USB_RECIP_ENDPOINT:
+		sprintf(str, "Get Endpoint Status ep%d%s",
+			wIndex & ~USB_DIR_IN,
+			wIndex & USB_DIR_IN ? "in" : "out");
+		break;
+	}
+}
+
+static inline const char *cdns3_decode_device_feature(u16 wValue)
+{
+	switch (wValue) {
+	case USB_DEVICE_SELF_POWERED:
+		return "Self Powered";
+	case USB_DEVICE_REMOTE_WAKEUP:
+		return "Remote Wakeup";
+	case USB_DEVICE_TEST_MODE:
+		return "Test Mode";
+	case USB_DEVICE_U1_ENABLE:
+		return "U1 Enable";
+	case USB_DEVICE_U2_ENABLE:
+		return "U2 Enable";
+	case USB_DEVICE_LTM_ENABLE:
+		return "LTM Enable";
+	default:
+		return "UNKNOWN";
+	}
+}
+
+static inline const char *cdns3_decode_test_mode(u16 wIndex)
+{
+	switch (wIndex) {
+	case TEST_J:
+		return ": TEST_J";
+	case TEST_K:
+		return ": TEST_K";
+	case TEST_SE0_NAK:
+		return ": TEST_SE0_NAK";
+	case TEST_PACKET:
+		return ": TEST_PACKET";
+	case TEST_FORCE_EN:
+		return ": TEST_FORCE_EN";
+	default:
+		return ": UNKNOWN";
+	}
+}
+
+static inline void cdns3_decode_set_clear_feature(u8 bRequestType, u8 bRequest,
+						  u16 wValue, u16 wIndex,
+						  char *str)
+{
+	switch (bRequestType & USB_RECIP_MASK) {
+	case USB_RECIP_DEVICE:
+		sprintf(str, "%s Device Feature(%s%s)",
+			bRequest == USB_REQ_CLEAR_FEATURE ? "Clear" : "Set",
+			cdns3_decode_device_feature(wValue),
+			wValue == USB_DEVICE_TEST_MODE ?
+			cdns3_decode_test_mode(wIndex) : "");
+		break;
+	case USB_RECIP_INTERFACE:
+		sprintf(str, "%s Interface Feature(%s)",
+			bRequest == USB_REQ_CLEAR_FEATURE ? "Clear" : "Set",
+			wIndex == USB_INTRF_FUNC_SUSPEND ?
+			"Function Suspend" : "UNKNOWN");
+		break;
+	case USB_RECIP_ENDPOINT:
+		sprintf(str, "%s Endpoint Feature(%s ep%d%s)",
+			bRequest == USB_REQ_CLEAR_FEATURE ? "Clear" : "Set",
+			    wIndex == USB_ENDPOINT_HALT ? "Halt" : "UNKNOWN",
+			wIndex & ~USB_DIR_IN,
+			wIndex & USB_DIR_IN ? "in" : "out");
+		break;
+	}
+}
+
+static inline const char *cdns3_decode_descriptor(u16 wValue)
+{
+	switch (wValue >> 8) {
+	case USB_DT_DEVICE:
+		return "Device";
+	case USB_DT_CONFIG:
+		return "Configuration";
+	case USB_DT_STRING:
+		return "String";
+	case USB_DT_INTERFACE:
+		return "Interface";
+	case USB_DT_ENDPOINT:
+		return "Endpoint";
+	case USB_DT_DEVICE_QUALIFIER:
+		return "Device Qualifier";
+	case USB_DT_OTHER_SPEED_CONFIG:
+		return "Other Speed Config";
+	case USB_DT_INTERFACE_POWER:
+		return "Interface Power";
+	case USB_DT_OTG:
+		return "OTG";
+	case USB_DT_DEBUG:
+		return "Debug";
+	case USB_DT_INTERFACE_ASSOCIATION:
+		return "Interface Association";
+	case USB_DT_BOS:
+		return "BOS";
+	case USB_DT_DEVICE_CAPABILITY:
+		return "Device Capability";
+	case USB_DT_SS_ENDPOINT_COMP:
+		return "SS Endpoint Companion";
+	case USB_DT_SSP_ISOC_ENDPOINT_COMP:
+		return "SSP Isochronous Endpoint Companion";
+	default:
+		return "UNKNOWN";
+	}
+}
+
+/**
+ * cdns3_decode_ctrl - returns a string represetion of ctrl request
+ */
+static inline const char *cdns3_decode_ctrl(char *str, u8 bRequestType,
+					    u8 bRequest, u16 wValue,
+					    u16 wIndex, u16 wLength)
+{
+	switch (bRequest) {
+	case USB_REQ_GET_STATUS:
+		cdns3_decode_get_status(bRequestType, wIndex,
+					wLength, str);
+		break;
+	case USB_REQ_CLEAR_FEATURE:
+	case USB_REQ_SET_FEATURE:
+		cdns3_decode_set_clear_feature(bRequestType, bRequest,
+					       wValue, wIndex, str);
+		break;
+	case USB_REQ_SET_ADDRESS:
+		sprintf(str, "Set Address Addr: %02x", wValue);
+		break;
+	case USB_REQ_GET_DESCRIPTOR:
+		sprintf(str, "GET %s Descriptor I: %d, L: %d",
+			cdns3_decode_descriptor(wValue),
+			wValue & 0xff, wLength);
+		break;
+	case USB_REQ_SET_DESCRIPTOR:
+		sprintf(str, "SET %s Descriptor I: %d, L: %d",
+			cdns3_decode_descriptor(wValue),
+			wValue & 0xff, wLength);
+		break;
+	case USB_REQ_GET_CONFIGURATION:
+		sprintf(str, "Get Configuration L: %d", wLength);
+		break;
+	case USB_REQ_SET_CONFIGURATION:
+		sprintf(str, "Set Configuration Config: %d ", wValue);
+		break;
+	case USB_REQ_GET_INTERFACE:
+		sprintf(str, "Get Interface Intf: %d, L: %d", wIndex, wLength);
+		break;
+	case USB_REQ_SET_INTERFACE:
+		sprintf(str, "Set Interface Intf: %d, Alt: %d", wIndex, wValue);
+		break;
+	case USB_REQ_SYNCH_FRAME:
+		sprintf(str, "Synch Frame Ep: %d, L: %d", wIndex, wLength);
+		break;
+	case USB_REQ_SET_SEL:
+		sprintf(str, "Set SEL L: %d", wLength);
+		break;
+	case USB_REQ_SET_ISOCH_DELAY:
+		sprintf(str, "Set Isochronous Delay Delay: %d ns", wValue);
+		break;
+	default:
+		sprintf(str,
+			"SETUP BRT: %02x BR: %02x V: %04x I: %04x L: %04x\n",
+			bRequestType, bRequest,
+			wValue, wIndex, wLength);
+	}
+
+	return str;
+}

diff --git a/drivers/usb/cdns3/ep0.c b/drivers/usb/cdns3/ep0.c
new file mode 100644
index 000000000000..1ef0e9f73e3e
--- /dev/null
+++ b/drivers/usb/cdns3/ep0.c

@@ -0,0 +1,864 @@
+// SPDX-License-Identifier: GPL-2.0
+/*
+ * Cadence USBSS DRD Driver - gadget side.
+ *
+ * Copyright (C) 2018 Cadence Design Systems.
+ * Copyright (C) 2017-2018 NXP
+ *
+ * Authors: Pawel Jez <pjez@cadence.com>,
+ *          Pawel Laszczak <pawell@cadence.com>
+ *	    Peter Chen <peter.chen@nxp.com>
+ */
+
+#include <linux/usb/composite.h>
+
+#include "gadget.h"
+#include "trace.h"
+
+static struct usb_endpoint_descriptor cdns3_gadget_ep0_desc = {
+	.bLength = USB_DT_ENDPOINT_SIZE,
+	.bDescriptorType = USB_DT_ENDPOINT,
+	.bmAttributes =	USB_ENDPOINT_XFER_CONTROL,
+};
+
+/**
+ * cdns3_ep0_run_transfer - Do transfer on default endpoint hardware
+ * @priv_dev: extended gadget object
+ * @dma_addr: physical address where data is/will be stored
+ * @length: data length
+ * @erdy: set it to 1 when ERDY packet should be sent -
+ *        exit from flow control state
+ */
+static void cdns3_ep0_run_transfer(struct cdns3_device *priv_dev,
+				   dma_addr_t dma_addr,
+				   unsigned int length, int erdy)
+{
+	struct cdns3_usb_regs __iomem *regs = priv_dev->regs;
+	struct cdns3_endpoint *priv_ep = ep_to_cdns3_ep(priv_dev->gadget.ep0);
+
+	priv_dev->ep0_trb->buffer = TRB_BUFFER(dma_addr);
+	priv_dev->ep0_trb->length = TRB_LEN(length);
+	priv_dev->ep0_trb->control = TRB_CYCLE | TRB_IOC | TRB_TYPE(TRB_NORMAL);
+
+	trace_cdns3_prepare_trb(priv_ep, priv_dev->ep0_trb);
+
+	cdns3_select_ep(priv_dev, priv_dev->ep0_data_dir);
+
+	writel(EP_STS_TRBERR, &regs->ep_sts);
+	writel(EP_TRADDR_TRADDR(priv_dev->ep0_trb_dma), &regs->ep_traddr);
+	trace_cdns3_doorbell_ep0(priv_dev->ep0_data_dir ? "ep0in" : "ep0out");
+
+	/* TRB should be prepared before starting transfer */
+	writel(EP_CMD_DRDY, &regs->ep_cmd);
+
+	if (erdy)
+		writel(EP_CMD_ERDY, &priv_dev->regs->ep_cmd);
+}
+
+/**
+ * cdns3_ep0_delegate_req - Returns status of handling setup packet
+ * Setup is handled by gadget driver
+ * @priv_dev: extended gadget object
+ * @ctrl_req: pointer to received setup packet
+ *
+ * Returns zero on success or negative value on failure
+ */
+static int cdns3_ep0_delegate_req(struct cdns3_device *priv_dev,
+				  struct usb_ctrlrequest *ctrl_req)
+{
+	int ret;
+
+	spin_unlock(&priv_dev->lock);
+	priv_dev->setup_pending = 1;
+	ret = priv_dev->gadget_driver->setup(&priv_dev->gadget, ctrl_req);
+	priv_dev->setup_pending = 0;
+	spin_lock(&priv_dev->lock);
+	return ret;
+}
+
+static void cdns3_prepare_setup_packet(struct cdns3_device *priv_dev)
+{
+	priv_dev->ep0_data_dir = 0;
+	cdns3_ep0_run_transfer(priv_dev, priv_dev->setup_dma,
+			       sizeof(struct usb_ctrlrequest), 0);
+}
+
+/**
+ * cdns3_req_ep0_set_configuration - Handling of SET_CONFIG standard USB request
+ * @priv_dev: extended gadget object
+ * @ctrl_req: pointer to received setup packet
+ *
+ * Returns 0 if success, USB_GADGET_DELAYED_STATUS on deferred status stage,
+ * error code on error
+ */
+static int cdns3_req_ep0_set_configuration(struct cdns3_device *priv_dev,
+					   struct usb_ctrlrequest *ctrl_req)
+{
+	enum usb_device_state device_state = priv_dev->gadget.state;
+	struct cdns3_endpoint *priv_ep;
+	u32 config = le16_to_cpu(ctrl_req->wValue);
+	int result = 0;
+	int i;
+
+	switch (device_state) {
+	case USB_STATE_ADDRESS:
+		/* Configure non-control EPs */
+		for (i = 0; i < CDNS3_ENDPOINTS_MAX_COUNT; i++) {
+			priv_ep = priv_dev->eps[i];
+			if (!priv_ep)
+				continue;
+
+			if (priv_ep->flags & EP_CLAIMED)
+				cdns3_ep_config(priv_ep);
+		}
+
+		result = cdns3_ep0_delegate_req(priv_dev, ctrl_req);
+
+		if (result)
+			return result;
+
+		if (config) {
+			cdns3_set_hw_configuration(priv_dev);
+		} else {
+			cdns3_gadget_unconfig(priv_dev);
+			usb_gadget_set_state(&priv_dev->gadget,
+					     USB_STATE_ADDRESS);

diff --git a/drivers/usb/cdns3/gadget.c b/drivers/usb/cdns3/gadget.c
new file mode 100644
index 000000000000..a021eaf07aee
--- /dev/null
+++ b/drivers/usb/cdns3/gadget.c