RE: [RFC PATCH v2 12/15] usb:cdns3: Adds enumeration related function.

[Pawel Laszczak]

>On 18/11/18 12:09, Pawel Laszczak wrote:
>> Patch implements a set of function related to enumeration process.
>> Some standard requests are handled on controller driver level and
>> other are delegated to gadget core driver.
>> All class requests are delegated to gadget core driver.
>>
>> Signed-off-by: Pawel Laszczak <pawell@xxxxxxxxxxx>
>> ---
>>  drivers/usb/cdns3/ep0.c    | 491 ++++++++++++++++++++++++++++++++++++-
>>  drivers/usb/cdns3/gadget.c | 119 +++++++++
>>  drivers/usb/cdns3/gadget.h |   4 +
>>  3 files changed, 610 insertions(+), 4 deletions(-)
>>
>> diff --git a/drivers/usb/cdns3/ep0.c b/drivers/usb/cdns3/ep0.c
>> index eb92fd234bd7..6f33d98f7684 100644
>> --- a/drivers/usb/cdns3/ep0.c
>> +++ b/drivers/usb/cdns3/ep0.c
>> @@ -10,6 +10,7 @@
>>   *	    Peter Chen <peter.chen@xxxxxxx>
>>   */
>>
>> +#include <linux/usb/composite.h>
>>  #include "gadget.h"
>>
>>  static struct usb_endpoint_descriptor cdns3_gadget_ep0_desc = {
>> @@ -52,9 +53,31 @@ static void cdns3_ep0_run_transfer(struct cdns3_device *priv_dev,
>>  		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;
>
>Why is setup_pending flag being set and cleared?

This flag is checking during handling DESCMISS interrupt. If this flag is set 
then driver not start DMA for SETUP packet waiting in on-chip buffer.
>
>> +	spin_lock(&priv_dev->lock);
>> +	return ret;
>> +}
>> +
>>  static void cdns3_prepare_setup_packet(struct cdns3_device *priv_dev)
>>  {
>> -	//TODO: Implements this function
>> +	priv_dev->ep0_data_dir = 0;
>> +	cdns3_ep0_run_transfer(priv_dev, priv_dev->setup_dma, 8, 0);
>
>why hardcode to 8?
>Don't vendor specific requests have different lengths?

SETUP packet always has 8 bytes. 
I will change this to sizeof(struct struct usb_ctrlrequest). It says more.
>
>>  }
>>
>>  static void cdns3_set_hw_configuration(struct cdns3_device *priv_dev)
>> @@ -90,9 +113,431 @@ static void cdns3_set_hw_configuration(struct cdns3_device *priv_dev)
>>  	}
>>  }
>>
>> +/**
>> + * 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, 0x7FFF on deferred status stage, error code on error
>
>what is this magic number 0x7fff?

We will have USB_GADGET_DELAYED_STATUS instead 0x7FFF;
>
>> + */
>> +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, *temp_ep;
>> +	u32 config = le16_to_cpu(ctrl_req->wValue);
>> +	int result = 0;
>> +
>> +	switch (device_state) {
>> +	case USB_STATE_ADDRESS:
>> +		/* Configure non-control EPs */
>> +		list_for_each_entry_safe(priv_ep, temp_ep,
>> +					 &priv_dev->ep_match_list,
>> +					 ep_match_pending_list)
>> +			cdns3_ep_config(priv_ep);
>
>Why configure here? They should be configured at ep_enable. no?
>And you don't need to maintain a ep_match/pending_list.

It's a little tricky. 
We need to configure all endpoint on SET_CONFIGURATION request. 
After reset we can set only once CFGSET bit in usb_conf register.
We don't need to enable endpoint, but we need set all other parameters.   
Not all endpoints are enabled before SET_CONFIGURATION, but
most of them, or even all are claimed during loading function by means 
of usb_ep_autoconfig. 

After setting CFGSET bit we can't change configuration of any endpoint. 
We can only enable or disable them. 
>> +
>> +		result = cdns3_ep0_delegate_req(priv_dev, ctrl_req);
>> +
>> +		if (result)
>> +			return result;
>> +
>> +		if (config) {
>
>What if result is USB_GADGET_DELAYED_STATUS?
It's handled be cdns3_ep0_setup_phase when this function return USB_GADGET_DELAYED_STATUS

>
>> +			cdns3_set_hw_configuration(priv_dev);
>
>usb_gadget_set_state(USB_STATE_CONFIGURED) ?
It is set in set_config in composite driver.
I think that it is sufficient. 
>
>> +		} else {
>> +			cdns3_gadget_unconfig(priv_dev);
>> +			usb_gadget_set_state(&priv_dev->gadget,
>> +					     USB_STATE_ADDRESS);
>> +		}
>> +		break;
>> +	case USB_STATE_CONFIGURED:
>> +		result = cdns3_ep0_delegate_req(priv_dev, ctrl_req);
>> +
>> +		if (!config && !result) {
>> +			cdns3_gadget_unconfig(priv_dev);
>> +			usb_gadget_set_state(&priv_dev->gadget,
>> +					     USB_STATE_ADDRESS);
>> +		}
>> +		break;
>> +	default:
>> +		result = -EINVAL;
>> +	}
>> +
>> +	return result;
>> +}
>> +
>> +/**
>> + * cdns3_req_ep0_set_address - Handling of SET_ADDRESS standard USB request
>> + * @priv_dev: extended gadget object
>> + * @ctrl_req: pointer to received setup packet
>> + *
>> + * Returns 0 if success, error code on error
>> + */
>> +static int cdns3_req_ep0_set_address(struct cdns3_device *priv_dev,
>> +				     struct usb_ctrlrequest *ctrl_req)
>> +{
>> +	enum usb_device_state device_state = priv_dev->gadget.state;
>> +	u32 reg;
>> +	u32 addr;
>> +
>> +	addr = le16_to_cpu(ctrl_req->wValue);
>> +
>> +	if (addr > DEVICE_ADDRESS_MAX) {
>
>If DEVICE_ADDRESS_MAX comes from USB spec it must be in ch9.h.
>Maybe add something like
>
>#define	USB_DEVICE_MAX_ADDRESS	127
>
Yes, it should, but I didn't see such macro definition in ch9.h.
I will add change this to USB_DEVICE_MAX_ADDRESS. 

>> +		dev_err(&priv_dev->dev,
>> +			"Device address (%d) cannot be greater than %d\n",
>> +			addr, DEVICE_ADDRESS_MAX);
>> +		return -EINVAL;
>> +	}
>> +
>> +	if (device_state == USB_STATE_CONFIGURED) {
>> +		dev_err(&priv_dev->dev, "USB device already configured\n");
>
>Message is misleading. How about "can't set_address from configured state"
>
Sounds better. 
>> +		return -EINVAL;
>> +	}
>> +
>> +	reg = readl(&priv_dev->regs->usb_cmd);
>> +
>> +	writel(reg | USB_CMD_FADDR(addr) | USB_CMD_SET_ADDR,
>> +	       &priv_dev->regs->usb_cmd);
>> +
>> +	usb_gadget_set_state(&priv_dev->gadget,
>> +			     (addr ? USB_STATE_ADDRESS : USB_STATE_DEFAULT));
>> +
>> +	cdns3_prepare_setup_packet(priv_dev);
>
>why call this here? This should be done after the current ep0 request is complete.

It only arm DMA for next SETUP packet. 
It's allow to eliminate one extra DESCMISS interrupt. This interrupt is 
generated when packet is in on-chip buffer and DMA is not started. 

Additionally, all OUT endpoints have common shared FIFO buffer. It's the reason why data from 
This on-chip buffers should be copied to system memory ASAP. Each delay before 
getting  packet  from this FIFO has impact on performance.

>> +
>> +	writel(EP_CMD_ERDY | EP_CMD_REQ_CMPL, &priv_dev->regs->ep_cmd);
>> +
>> +	return 0;
>> +}
>> +
>> +/**
>> + * cdns3_req_ep0_get_status - Handling of GET_STATUS standard USB request
>> + * @priv_dev: extended gadget object
>> + * @ctrl_req: pointer to received setup packet
>> + *
>> + * Returns 0 if success, error code on error
>> + */
>> +static int cdns3_req_ep0_get_status(struct cdns3_device *priv_dev,
>> +				    struct usb_ctrlrequest *ctrl)
>> +{
>> +	__le16 *response_pkt;
>> +	u16 usb_status = 0;
>> +	u32 recip;
>> +	u32 reg;
>> +
>> +	recip = ctrl->bRequestType & USB_RECIP_MASK;
>> +
>> +	switch (recip) {
>> +	case USB_RECIP_DEVICE:
>> +		/* self powered */
>> +		usb_status |= priv_dev->gadget.is_selfpowered;
>
>if (prv_devgadget.is_selfpowered)
>	usb_stats |= BIT(USB_DEVICE_SELF_POWERED);
>
Ok,
 I don't understand why, but I see such solution in MTU3 driver

In musb it is used in such way: 
result[0] = musb->g.is_selfpowered << USB_DEVICE_SELF_POWERED;

>> +
>> +		if (priv_dev->gadget.speed != USB_SPEED_SUPER)
>
>You should check controller speed directly instead.
>
>> +			break;
>> +
>> +		reg = readl(&priv_dev->regs->usb_sts);
>> +
>> +		if (priv_dev->u1_allowed)
>> +			usb_status |= BIT(USB_DEV_STAT_U1_ENABLED);
>> +
>> +		if (priv_dev->u2_allowed)
>> +			usb_status |= BIT(USB_DEV_STAT_U2_ENABLED);
>> +
>> +		if (priv_dev->wake_up_flag)
>> +			usb_status |= BIT(USB_DEVICE_REMOTE_WAKEUP);
>
>Remote wakeup is not SS specific. So needs to go before the SS check.
Yes, sure.
>
>> +		break;
>> +	case USB_RECIP_INTERFACE:
>> +		return cdns3_ep0_delegate_req(priv_dev, ctrl);
>> +	case USB_RECIP_ENDPOINT:
>> +		/* check if endpoint is stalled */
>> +		cdns3_select_ep(priv_dev, ctrl->wIndex);
>> +		if (EP_STS_STALL(readl(&priv_dev->regs->ep_sts)))
>> +			usb_status =  BIT(USB_ENDPOINT_HALT);
>> +		break;
>> +	default:
>> +		return -EINVAL;
>> +	}
>> +
>> +	response_pkt = (__le16 *)priv_dev->setup;
>> +	*response_pkt = cpu_to_le16(usb_status);
>> +
>> +	cdns3_ep0_run_transfer(priv_dev, priv_dev->setup_dma,
>> +			       sizeof(*response_pkt), 1);
>> +	return 0;
>> +}
>> +
>> +static int cdns3_ep0_feature_handle_device(struct cdns3_device *priv_dev,
>> +					   struct usb_ctrlrequest *ctrl,
>> +					   int set)
>> +{
>> +	enum usb_device_state state;
>> +	enum usb_device_speed speed;
>> +	int ret = 0;
>> +	u32 wValue;
>> +	u32 wIndex;
>> +	u16 tmode;
>> +
>> +	wValue = le16_to_cpu(ctrl->wValue);
>> +	wIndex = le16_to_cpu(ctrl->wIndex);
>> +	state = priv_dev->gadget.state;
>> +	speed = priv_dev->gadget.speed;
>> +
>> +	switch (ctrl->wValue) {
>> +	case USB_DEVICE_REMOTE_WAKEUP:
>> +		priv_dev->wake_up_flag = !!set;
>> +		break;
>> +	case USB_DEVICE_U1_ENABLE:
>> +		if (state != USB_STATE_CONFIGURED || speed != USB_SPEED_SUPER)
>> +			return -EINVAL;
>> +
>> +		priv_dev->u1_allowed = !!set;
>> +		break;
>> +	case USB_DEVICE_U2_ENABLE:
>> +		if (state != USB_STATE_CONFIGURED || speed != USB_SPEED_SUPER)
>> +			return -EINVAL;
>> +
>> +		priv_dev->u2_allowed = !!set;
>> +		break;
>> +	case USB_DEVICE_LTM_ENABLE:
>> +		ret = -EINVAL;
>> +		break;
>> +	case USB_DEVICE_TEST_MODE:
>> +		if (state != USB_STATE_CONFIGURED || speed > USB_SPEED_HIGH)
>> +			return -EINVAL;
>> +
>> +		tmode = le16_to_cpu(ctrl->wIndex);
>> +
>> +		if (!set || (tmode & 0xff) != 0)
>> +			return -EINVAL;
>> +
>> +		switch (tmode >> 8) {
>> +		case TEST_J:
>> +		case TEST_K:
>> +		case TEST_SE0_NAK:
>> +		case TEST_PACKET:
>> +			cdns3_set_register_bit(&priv_dev->regs->usb_cmd,
>> +					       USB_CMD_STMODE |
>> +					       USB_STS_TMODE_SEL(tmode - 1));
>> +			break;
>> +		default:
>> +			ret = -EINVAL;
>> +		}
>> +		break;
>> +	default:
>> +		ret = -EINVAL;
>> +	}
>> +
>> +	return ret;
>> +}
>> +
>> +static int cdns3_ep0_feature_handle_intf(struct cdns3_device *priv_dev,
>> +					 struct usb_ctrlrequest *ctrl,
>> +					 int set)
>> +{
>> +	u32 wValue;
>> +	int ret = 0;
>> +
>> +	wValue = le16_to_cpu(ctrl->wValue);
>> +
>> +	switch (wValue) {
>> +	case USB_INTRF_FUNC_SUSPEND:
>> +		break;
>> +	default:
>> +		ret = -EINVAL;
>> +	}
>> +
>> +	return ret;
>> +}
>> +
>> +static int cdns3_ep0_feature_handle_endpoint(struct cdns3_device *priv_dev,
>> +					     struct usb_ctrlrequest *ctrl,
>> +					     int set)
>> +{
>> +	struct cdns3_endpoint *priv_ep;
>> +	int ret = 0;
>> +	u8 index;
>> +
>> +	if (!(ctrl->wIndex &  ~USB_DIR_IN))
>> +		return 0;
>
>Why is this check?

Whether  endpoint in wIndex is different then 0. I use this 
value in next line and it must be greater than 0.  
>
>> +
>> +	index = cdns3_ep_addr_to_index(ctrl->wIndex);
>> +	priv_ep = priv_dev->eps[index];
>> +
>> +	cdns3_select_ep(priv_dev, ctrl->wIndex);
>> +
>> +	if (le16_to_cpu(ctrl->wValue) != USB_ENDPOINT_HALT)
>> +		return -EINVAL;
>
>This check should be done first before you try to decode wIndex.
I understand that you mean that it doesn't make sense doing anything when endpoint is halted. 
>
>> +
>> +	if (set) {
>> +		writel(EP_CMD_SSTALL, &priv_dev->regs->ep_cmd);
>> +		priv_ep->flags |= EP_STALL;
>> +	} else {
>> +		struct usb_request *request;
>> +
>> +		if (priv_dev->eps[index]->flags & EP_WEDGE) {
>> +			cdns3_select_ep(priv_dev, 0x00);
>> +			return 0;
>> +		}
>> +
>> +		writel(EP_CMD_CSTALL | EP_CMD_EPRST, &priv_dev->regs->ep_cmd);
>> +
>> +		/* wait for EPRST cleared */
>> +		ret = cdns3_handshake(&priv_dev->regs->ep_cmd,
>> +				      EP_CMD_EPRST, 0, 100);
>> +		if (ret)
>> +			return -EINVAL;
>> +
>> +		priv_ep->flags &= ~EP_STALL;
>> +
>> +		request = cdns3_next_request(&priv_ep->request_list);
>> +		if (request)
>> +			cdns3_ep_run_transfer(priv_ep, request);
>> +	}
>> +	return ret;
>> +}
>> +
>> +/**
>> + * cdns3_req_ep0_handle_feature -
>> + * Handling of GET/SET_FEATURE standard USB request
>> + *
>> + * @priv_dev: extended gadget object
>> + * @ctrl_req: pointer to received setup packet
>> + * @set: must be set to 1 for SET_FEATURE request
>> + *
>> + * Returns 0 if success, error code on error
>> + */
>> +static int cdns3_req_ep0_handle_feature(struct cdns3_device *priv_dev,
>> +					struct usb_ctrlrequest *ctrl,
>> +					int set)
>> +{
>> +	int ret = 0;
>> +	u32 recip;
>> +
>> +	recip = ctrl->bRequestType & USB_RECIP_MASK;
>> +
>> +	switch (recip) {
>> +	case USB_RECIP_DEVICE:
>> +		ret = cdns3_ep0_feature_handle_device(priv_dev, ctrl, set);
>> +		break;
>> +	case USB_RECIP_INTERFACE:
>> +		ret = cdns3_ep0_feature_handle_intf(priv_dev, ctrl, set);
>> +		break;
>> +	case USB_RECIP_ENDPOINT:
>> +		ret = cdns3_ep0_feature_handle_endpoint(priv_dev, ctrl, set);
>> +		break;
>> +	default:
>> +		return -EINVAL;
>> +	}
>> +
>> +	if (!ret)
>> +		writel(EP_CMD_ERDY | EP_CMD_REQ_CMPL, &priv_dev->regs->ep_cmd);
>> +
>> +	return ret;
>> +}
>> +
>> +/**
>> + * cdns3_req_ep0_set_sel - Handling of SET_SEL standard USB request
>> + * @priv_dev: extended gadget object
>> + * @ctrl_req: pointer to received setup packet
>> + *
>> + * Returns 0 if success, error code on error
>> + */
>> +static int cdns3_req_ep0_set_sel(struct cdns3_device *priv_dev,
>> +				 struct usb_ctrlrequest *ctrl_req)
>> +{
>> +	if (priv_dev->gadget.state < USB_STATE_ADDRESS)
>> +		return -EINVAL;
>> +
>> +	if (ctrl_req->wLength != 6) {
>> +		dev_err(&priv_dev->dev, "Set SEL should be 6 bytes, got %d\n",
>> +			ctrl_req->wLength);
>> +		return -EINVAL;
>> +	}
>> +
>> +	priv_dev->ep0_data_dir = 0;
>> +	cdns3_ep0_run_transfer(priv_dev, priv_dev->setup_dma, 6, 1);
>> +	return 0;
>> +}
>> +
>> +/**
>> + * cdns3_req_ep0_set_isoch_delay -
>> + * Handling of GET_ISOCH_DELAY standard USB request
>> + * @priv_dev: extended gadget object
>> + * @ctrl_req: pointer to received setup packet
>> + *
>> + * Returns 0 if success, error code on error
>> + */
>> +static int cdns3_req_ep0_set_isoch_delay(struct cdns3_device *priv_dev,
>> +					 struct usb_ctrlrequest *ctrl_req)
>> +{
>> +	if (ctrl_req->wIndex || ctrl_req->wLength)
>> +		return -EINVAL;
>> +
>> +	priv_dev->isoch_delay = ctrl_req->wValue;
>> +	writel(EP_CMD_ERDY | EP_CMD_REQ_CMPL, &priv_dev->regs->ep_cmd);
>> +	return 0;
>> +}
>> +
>> +/**
>> + * cdns3_ep0_standard_request - Handling standard USB requests
>> + * @priv_dev: extended gadget object
>> + * @ctrl_req: pointer to received setup packet
>> + *
>> + * Returns 0 if success, error code on error
>> + */
>> +static int cdns3_ep0_standard_request(struct cdns3_device *priv_dev,
>> +				      struct usb_ctrlrequest *ctrl_req)
>> +{
>> +	int ret;
>> +
>> +	switch (ctrl_req->bRequest) {
>> +	case USB_REQ_SET_ADDRESS:
>> +		ret = cdns3_req_ep0_set_address(priv_dev, ctrl_req);
>> +		break;
>> +	case USB_REQ_SET_CONFIGURATION:
>> +		ret = cdns3_req_ep0_set_configuration(priv_dev, ctrl_req);
>> +		break;
>> +	case USB_REQ_GET_STATUS:
>> +		ret = cdns3_req_ep0_get_status(priv_dev, ctrl_req);
>> +		break;
>> +	case USB_REQ_CLEAR_FEATURE:
>> +		ret = cdns3_req_ep0_handle_feature(priv_dev, ctrl_req, 0);
>> +		break;
>> +	case USB_REQ_SET_FEATURE:
>> +		ret = cdns3_req_ep0_handle_feature(priv_dev, ctrl_req, 1);
>> +		break;
>> +	case USB_REQ_SET_SEL:
>> +		ret = cdns3_req_ep0_set_sel(priv_dev, ctrl_req);
>> +		break;
>> +	case USB_REQ_SET_ISOCH_DELAY:
>> +		ret = cdns3_req_ep0_set_isoch_delay(priv_dev, ctrl_req);
>> +		break;
>> +	default:
>> +		ret = cdns3_ep0_delegate_req(priv_dev, ctrl_req);
>> +		break;
>> +	}
>> +
>> +	return ret;
>> +}
>> +
>>  static void __pending_setup_status_handler(struct cdns3_device *priv_dev)
>>  {
>> -	//TODO: Implements this function
>> +	struct usb_request *request = priv_dev->pending_status_request;
>> +
>> +	if (priv_dev->status_completion_no_call && request &&
>> +	    request->complete) {
>> +		request->complete(priv_dev->gadget.ep0, request);
>> +		priv_dev->status_completion_no_call = 0;
>> +	}
>> +}
>> +
>> +void cdns3_pending_setup_status_handler(struct work_struct *work)
>> +{
>> +	struct cdns3_device *priv_dev = container_of(work, struct cdns3_device,
>> +			pending_status_wq);
>> +	unsigned long flags;
>> +
>> +	spin_lock_irqsave(&priv_dev->lock, flags);
>> +	__pending_setup_status_handler(priv_dev);
>> +	spin_unlock_irqrestore(&priv_dev->lock, flags);
>>  }
>>
>>  /**
>> @@ -101,12 +546,50 @@ static void __pending_setup_status_handler(struct cdns3_device *priv_dev)
>>   */
>>  static void cdns3_ep0_setup_phase(struct cdns3_device *priv_dev)
>>  {
>> -	//TODO: Implements this function.
>> +	struct usb_ctrlrequest *ctrl = priv_dev->setup;
>> +	int result;
>> +
>> +	if ((ctrl->bRequestType & USB_TYPE_MASK) == USB_TYPE_STANDARD)
>> +		result = cdns3_ep0_standard_request(priv_dev, ctrl);
>> +	else
>> +		result = cdns3_ep0_delegate_req(priv_dev, ctrl);
>> +
>> +	if (result != 0 && result != USB_GADGET_DELAYED_STATUS) {
>> +		dev_dbg(&priv_dev->dev, "STALL for ep0\n");
>> +		/* set_stall on ep0 */
>> +		cdns3_select_ep(priv_dev, 0x00);
>> +		writel(EP_CMD_SSTALL, &priv_dev->regs->ep_cmd);
>> +		writel(EP_CMD_ERDY | EP_CMD_REQ_CMPL, &priv_dev->regs->ep_cmd);
>> +	}
>>  }
>>
>>  static void cdns3_transfer_completed(struct cdns3_device *priv_dev)
>>  {
>> -	//TODO: Implements this function
>> +	if (priv_dev->ep0_request) {
>> +		usb_gadget_unmap_request_by_dev(priv_dev->sysdev,
>> +						priv_dev->ep0_request,
>> +						priv_dev->ep0_data_dir);
>> +
>> +		priv_dev->ep0_request->actual =
>> +			TRB_LEN(le32_to_cpu(priv_dev->trb_ep0->length));
>> +
>> +		dev_dbg(&priv_dev->dev, "Ep0 completion length %d\n",
>> +			priv_dev->ep0_request->actual);
>> +		list_del_init(&priv_dev->ep0_request->list);
>> +	}
>> +
>> +	if (priv_dev->ep0_request &&
>> +	    priv_dev->ep0_request->complete) {
>> +		spin_unlock(&priv_dev->lock);
>> +		priv_dev->ep0_request->complete(priv_dev->gadget.ep0,
>> +						priv_dev->ep0_request);
>> +
>> +		priv_dev->ep0_request = NULL;
>> +		spin_lock(&priv_dev->lock);
>> +	}
>> +
>> +	cdns3_prepare_setup_packet(priv_dev);
>> +	writel(EP_CMD_REQ_CMPL, &priv_dev->regs->ep_cmd);
>>  }
>>
>>  /**
>> diff --git a/drivers/usb/cdns3/gadget.c b/drivers/usb/cdns3/gadget.c
>> index 309202474e57..0202ff5f6c90 100644
>> --- a/drivers/usb/cdns3/gadget.c
>> +++ b/drivers/usb/cdns3/gadget.c
>> @@ -70,6 +70,30 @@ static u8 cdns3_ep_reg_pos_to_index(int i)
>>  	return ((i / 16) + (((i % 16) - 2) * 2));
>>  }
>>
>> +/**
>> + * cdns3_ep_addr_to_index - Macro converts endpoint address to
>> + * index of endpoint object in cdns3_device.eps[] container
>> + * @ep_addr: endpoint address for which endpoint object is required
>> + *
>> + * Remember that endpoint container doesn't contain default endpoint
>> + */
>> +u8 cdns3_ep_addr_to_index(u8 ep_addr)
>> +{
>> +	return (((ep_addr & 0x7F) - 1) + ((ep_addr & USB_DIR_IN) ? 1 : 0));
>> +}
>> +
>> +/**
>> + * cdns3_ep_addr_to_bit_pos - Macro converts endpoint address to
>> + * bit position in ep_ists register
>> + * @ep_addr: endpoint address for which bit position is required
>> + *
>> + * Remember that endpoint container doesn't contain default endpoint
>> + */
>> +static u32 cdns3_ep_addr_to_bit_pos(u8 ep_addr)
>> +{
>> +	return (1 << (ep_addr & 0x7F)) << ((ep_addr & 0x80) ? 16 : 0);
>> +}
>> +
>>  /**
>>   * cdns3_next_request - returns next request from list
>>   * @list: list containing requests
>> @@ -464,6 +488,99 @@ static irqreturn_t cdns3_irq_handler_thread(struct cdns3 *cdns)
>>  	return ret;
>>  }
>>
>> +/**
>> + * cdns3_ep_onchip_buffer_alloc - Try to allocate onchip buf for EP
>> + *
>> + * The real allocation will occur during write to EP_CFG register,
>> + * this function is used to check if the 'size' allocation is allowed.
>> + *
>> + * @priv_dev: extended gadget object
>> + * @size: the size (KB) for EP would like to allocate
>> + * @is_in: the direction for EP
>> + *
>> + * Return 0 if the later allocation is allowed or negative value on failure
>> + */
>> +static int cdns3_ep_onchip_buffer_alloc(struct cdns3_device *priv_dev,
>> +					int size, int is_in)
>> +{
>> +	if (is_in) {
>> +		priv_dev->onchip_mem_allocated_size += size;
>> +	} else if (!priv_dev->out_mem_is_allocated) {
>> +		 /* ALL OUT EPs are shared the same chunk onchip memory */
>> +		priv_dev->onchip_mem_allocated_size += size;
>> +		priv_dev->out_mem_is_allocated = 1;
>> +	}
>> +
>> +	if (priv_dev->onchip_mem_allocated_size > CDNS3_ONCHIP_BUF_SIZE) {
>> +		priv_dev->onchip_mem_allocated_size -= size;
>> +		return -EPERM;
>> +	} else {
>> +		return 0;
>> +	}
>> +}
>> +
>> +/**
>> + * cdns3_ep_config Configure hardware endpoint
>> + * @priv_ep: extended endpoint object
>> + */
>> +void cdns3_ep_config(struct cdns3_endpoint *priv_ep)
>> +{
>> +	bool is_iso_ep = (priv_ep->type == USB_ENDPOINT_XFER_ISOC);
>> +	struct cdns3_device *priv_dev = priv_ep->cdns3_dev;
>> +	u32 bEndpointAddress = priv_ep->num | priv_ep->dir;
>> +	u32 interrupt_mask = EP_STS_EN_TRBERREN;
>> +	u32 max_packet_size = 0;
>> +	u32 ep_cfg = 0;
>> +	int ret;
>> +
>> +	if (priv_ep->type == USB_ENDPOINT_XFER_INT) {
>> +		ep_cfg = EP_CFG_EPTYPE(USB_ENDPOINT_XFER_INT);
>> +	} else if (priv_ep->type == USB_ENDPOINT_XFER_BULK) {
>> +		ep_cfg = EP_CFG_EPTYPE(USB_ENDPOINT_XFER_BULK);
>> +	} else {
>> +		ep_cfg = EP_CFG_EPTYPE(USB_ENDPOINT_XFER_ISOC);
>> +		interrupt_mask = 0xFFFFFFFF;
>> +	}
>> +
>> +	switch (priv_dev->gadget.speed) {
>> +	case USB_SPEED_FULL:
>> +		max_packet_size = is_iso_ep ? 1023 : 64;
>> +		break;
>> +	case USB_SPEED_HIGH:
>> +		max_packet_size = is_iso_ep ? 1024 : 512;
>> +		break;
>> +	case USB_SPEED_SUPER:
>> +		max_packet_size = 1024;
>> +		break;
>> +	default:
>> +		//all other speed are not supported
>> +		return;
>> +	}
>> +
>> +	ret = cdns3_ep_onchip_buffer_alloc(priv_dev, CDNS3_EP_BUF_SIZE,
>> +					   priv_ep->dir);
>
>where do you free the buffer_alloc?
I don't free this buffer. 
This function was added by Peter Chan, and it refer to on-chip buffer. 
Peter in his platform has limited number of on-chip memory. If I remember 
correctly It has only 16KB. It's kind of software protection against exceeding this buffer.
It's hard coded now in driver. I think that this value can be read from  register, 
I have to consult this with hardware team.

I think the cdns3_ep_onchip_buffer_reserve is a better name.
It is not associated with allocation of memory. 
>
>> +	if (ret) {
>> +		dev_err(&priv_dev->dev, "onchip mem is full, ep is invalid\n");
>> +		return;
>> +	}
>> +
>> +	ep_cfg |= EP_CFG_MAXPKTSIZE(max_packet_size) |
>> +		  EP_CFG_BUFFERING(CDNS3_EP_BUF_SIZE - 1) |
>> +		  EP_CFG_MAXBURST(priv_ep->endpoint.maxburst);
>> +
>> +	cdns3_select_ep(priv_dev, bEndpointAddress);
>> +
>> +	writel(ep_cfg, &priv_dev->regs->ep_cfg);
>> +	writel(interrupt_mask, &priv_dev->regs->ep_sts_en);
>> +
>> +	dev_dbg(&priv_dev->dev, "Configure %s: with val %08x\n",
>> +		priv_ep->name, ep_cfg);
>> +
>> +	/* enable interrupt for selected endpoint */
>> +	cdns3_set_register_bit(&priv_dev->regs->ep_ien,
>> +			       cdns3_ep_addr_to_bit_pos(bEndpointAddress));
>> +}
>> +
>>  /* Find correct direction for HW endpoint according to description */
>>  static int cdns3_ep_dir_is_correct(struct usb_endpoint_descriptor *desc,
>>  				   struct cdns3_endpoint *priv_ep)
>> @@ -1104,6 +1221,8 @@ static int __cdns3_gadget_init(struct cdns3 *cdns)
>>  	priv_dev->is_connected = 0;
>>
>>  	spin_lock_init(&priv_dev->lock);
>> +	INIT_WORK(&priv_dev->pending_status_wq,
>> +		  cdns3_pending_setup_status_handler);
>>
>>  	priv_dev->in_standby_mode = 1;
>>
>> diff --git a/drivers/usb/cdns3/gadget.h b/drivers/usb/cdns3/gadget.h
>> index 8c2f363f9340..db8c6cb9f2a5 100644
>> --- a/drivers/usb/cdns3/gadget.h
>> +++ b/drivers/usb/cdns3/gadget.h
>> @@ -1070,14 +1070,18 @@ struct cdns3_device {
>>
>>  int cdns3_handshake(void __iomem *ptr, u32 mask, u32 done, int usec);
>>  void cdns3_set_register_bit(void __iomem *ptr, u32 mask);
>> +void cdns3_pending_setup_status_handler(struct work_struct *work);
>>  int cdns3_init_ep0(struct cdns3_device *priv_dev);
>>  void cdns3_ep0_config(struct cdns3_device *priv_dev);
>> +void cdns3_ep_config(struct cdns3_endpoint *priv_ep);
>>  void cdns3_check_ep0_interrupt_proceed(struct cdns3_device *priv_dev, int dir);
>>  void cdns3_select_ep(struct cdns3_device *priv_dev, u32 ep);
>>  void cdns3_enable_l1(struct cdns3_device *priv_dev, int enable);
>>  struct usb_request *cdns3_next_request(struct list_head *list);
>> +void cdns3_gadget_unconfig(struct cdns3_device *priv_dev);
>>  int cdns3_ep_run_transfer(struct cdns3_endpoint *priv_ep,
>>  			  struct usb_request *request);
>> +u8 cdns3_ep_addr_to_index(u8 ep_addr);
>>  int cdns3_gadget_ep_set_wedge(struct usb_ep *ep);
>>  int cdns3_gadget_ep_set_halt(struct usb_ep *ep, int value);
>>  struct usb_request *cdns3_gadget_ep_alloc_request(struct usb_ep *ep,
>>
Cheers	
Pawel