[PATCH 0/9] Add a generic request map/unmap routine

[PATCH 0/9] Add a generic request map/unmap routine

[Felipe Balbi]

Hi all,

here's a more complete map/unmap rework patchset.

Please give it a try and reply with your Tested-by ASAP.

These patches were written on top of the Scatter/Gather
support patchset, so if you want to try it out, you might
need those first, as an alternative, you can drop patch 2
of this series if you're not testing against dwc3 and it
should apply fine on top of greg/usb-next

Felipe Balbi (9):
  usb: gadget: add generic map/unmap request utilities
  usb: dwc3: gadget: use generic map/unmap routines
  usb: gadget: langwell: use generic map/unmap functions
  usb: renesas: gadget: use generic map/unmap routines
  usb: gadget: amd5536: use generic map/unmap routines
  usb: gadget: r8a66597: use generic map/unmap routines
  usb: gadget: net2272: use generic map/umap routines
  usb: gadget: net2280: use generic map/unmap routines
  usb: gadget: goku: use generic map/unmap routines

 drivers/usb/dwc3/gadget.c              |   80 +++++---------------------------
 drivers/usb/gadget/amd5536udc.c        |   32 ++-----------
 drivers/usb/gadget/goku_udc.c          |   17 +++----
 drivers/usb/gadget/langwell_udc.c      |   45 +++---------------
 drivers/usb/gadget/net2272.c           |   18 +++----
 drivers/usb/gadget/net2280.c           |   19 ++++----
 drivers/usb/gadget/r8a66597-udc.c      |   10 +---
 drivers/usb/gadget/udc-core.c          |   53 +++++++++++++++++++++
 drivers/usb/renesas_usbhs/mod_gadget.c |   60 +++---------------------
 include/linux/usb/gadget.h             |   10 ++++
 10 files changed, 120 insertions(+), 224 deletions(-)

-- 
1.7.8.rc3

[PATCH 0/9] Add a generic request map/unmap routine

[Felipe Balbi]

Hi all,

here's a more complete map/unmap rework patchset.

Please give it a try and reply with your Tested-by ASAP.

These patches were written on top of the Scatter/Gather
support patchset, so if you want to try it out, you might
need those first, as an alternative, you can drop patch 2
of this series if you're not testing against dwc3 and it
should apply fine on top of greg/usb-next

Felipe Balbi (9):
  usb: gadget: add generic map/unmap request utilities
  usb: dwc3: gadget: use generic map/unmap routines
  usb: gadget: langwell: use generic map/unmap functions
  usb: renesas: gadget: use generic map/unmap routines
  usb: gadget: amd5536: use generic map/unmap routines
  usb: gadget: r8a66597: use generic map/unmap routines
  usb: gadget: net2272: use generic map/umap routines
  usb: gadget: net2280: use generic map/unmap routines
  usb: gadget: goku: use generic map/unmap routines

 drivers/usb/dwc3/gadget.c              |   80 +++++---------------------------
 drivers/usb/gadget/amd5536udc.c        |   32 ++-----------
 drivers/usb/gadget/goku_udc.c          |   17 +++----
 drivers/usb/gadget/langwell_udc.c      |   45 +++---------------
 drivers/usb/gadget/net2272.c           |   18 +++----
 drivers/usb/gadget/net2280.c           |   19 ++++----
 drivers/usb/gadget/r8a66597-udc.c      |   10 +---
 drivers/usb/gadget/udc-core.c          |   53 +++++++++++++++++++++
 drivers/usb/renesas_usbhs/mod_gadget.c |   60 +++---------------------
 include/linux/usb/gadget.h             |   10 ++++
 10 files changed, 120 insertions(+), 224 deletions(-)

-- 
1.7.8.rc3

[PATCH 1/9] usb: gadget: add generic map/unmap request utilities

[Felipe Balbi]

such utilities are currently duplicated on all UDC
drivers basically with the same structure. Let's group
all implementations into one generic implementation
and get rid of that duplication.

Signed-off-by: Felipe Balbi <balbi@ti.com>
---
 drivers/usb/gadget/udc-core.c |   53 +++++++++++++++++++++++++++++++++++++++++
 include/linux/usb/gadget.h    |   10 +++++++
 2 files changed, 63 insertions(+), 0 deletions(-)

diff --git a/drivers/usb/gadget/udc-core.c b/drivers/usb/gadget/udc-core.c
index 0b0d12c..2031c11 100644
--- a/drivers/usb/gadget/udc-core.c
+++ b/drivers/usb/gadget/udc-core.c
@@ -22,6 +22,7 @@
 #include <linux/device.h>
 #include <linux/list.h>
 #include <linux/err.h>
+#include <linux/dma-mapping.h>
 
 #include <linux/usb/ch9.h>
 #include <linux/usb/gadget.h>
@@ -49,6 +50,58 @@ static DEFINE_MUTEX(udc_lock);
 
 /* ------------------------------------------------------------------------- */
 
+int usb_gadget_map_request(struct usb_gadget *gadget,
+		struct usb_request *req, int direction)
+{
+	if (req->length == 0)
+		return 0;
+
+	if (req->num_sgs) {
+		int     mapped;
+
+		mapped = dma_map_sg(&gadget->dev, req->sg, req->num_sgs,
+				direction ? DMA_TO_DEVICE
+				: DMA_FROM_DEVICE);
+		if (mapped == 0) {
+			dev_err(&gadget->dev, "failed to map SGs\n");
+			return -EFAULT;
+		}
+
+		req->num_mapped_sgs = mapped;
+	} else {
+		req->dma = dma_map_single(&gadget->dev, req->buf, req->length,
+				direction ? DMA_TO_DEVICE : DMA_FROM_DEVICE);
+
+		if (dma_mapping_error(&gadget->dev, req->dma)) {
+			dev_err(&gadget->dev, "failed to map buffer\n");
+			return -EFAULT;
+		}
+	}
+
+	return 0;
+}
+EXPORT_SYMBOL_GPL(usb_gadget_map_request);
+
+void usb_gadget_unmap_request(struct usb_gadget *gadget,
+		struct usb_request *req, int direction)
+{
+	if (req->length == 0)
+		return;
+
+	if (req->num_mapped_sgs) {
+		dma_unmap_sg(&gadget->dev, req->sg, req->num_sgs,
+				direction ? DMA_TO_DEVICE : DMA_FROM_DEVICE);
+
+		req->num_mapped_sgs = 0;
+	} else {
+		dma_unmap_single(&gadget->dev, req->dma, req->length,
+				direction ? DMA_TO_DEVICE : DMA_FROM_DEVICE);
+	}
+}
+EXPORT_SYMBOL_GPL(usb_gadget_unmap_request);
+
+/* ------------------------------------------------------------------------- */
+
 /**
  * usb_gadget_start - tells usb device controller to start up
  * @gadget: The gadget we want to get started
diff --git a/include/linux/usb/gadget.h b/include/linux/usb/gadget.h
index 911d4c7..9f84fdf 100644
--- a/include/linux/usb/gadget.h
+++ b/include/linux/usb/gadget.h
@@ -950,6 +950,16 @@ static inline void usb_free_descriptors(struct usb_descriptor_header **v)
 
 /*-------------------------------------------------------------------------*/
 
+/* utility to simplify map/unmap of usb_requests to/from DMA */
+
+extern int usb_gadget_map_request(struct usb_gadget *gadget,
+		struct usb_request *req, int direction);
+
+extern void usb_gadget_unmap_request(struct usb_gadget *gadget,
+		struct usb_request *req, int direction);
+
+/*-------------------------------------------------------------------------*/
+
 /* utility wrapping a simple endpoint selection policy */
 
 extern struct usb_ep *usb_ep_autoconfig(struct usb_gadget *,
-- 
1.7.8.rc3

[PATCH 1/9] usb: gadget: add generic map/unmap request utilities

[Felipe Balbi]

such utilities are currently duplicated on all UDC
drivers basically with the same structure. Let's group
all implementations into one generic implementation
and get rid of that duplication.

Signed-off-by: Felipe Balbi <balbi@ti.com>
---
 drivers/usb/gadget/udc-core.c |   53 +++++++++++++++++++++++++++++++++++++++++
 include/linux/usb/gadget.h    |   10 +++++++
 2 files changed, 63 insertions(+), 0 deletions(-)

diff --git a/drivers/usb/gadget/udc-core.c b/drivers/usb/gadget/udc-core.c
index 0b0d12c..2031c11 100644
--- a/drivers/usb/gadget/udc-core.c
+++ b/drivers/usb/gadget/udc-core.c
@@ -22,6 +22,7 @@
 #include <linux/device.h>
 #include <linux/list.h>
 #include <linux/err.h>
+#include <linux/dma-mapping.h>
 
 #include <linux/usb/ch9.h>
 #include <linux/usb/gadget.h>
@@ -49,6 +50,58 @@ static DEFINE_MUTEX(udc_lock);
 
 /* ------------------------------------------------------------------------- */
 
+int usb_gadget_map_request(struct usb_gadget *gadget,
+		struct usb_request *req, int direction)
+{
+	if (req->length == 0)
+		return 0;
+
+	if (req->num_sgs) {
+		int     mapped;
+
+		mapped = dma_map_sg(&gadget->dev, req->sg, req->num_sgs,
+				direction ? DMA_TO_DEVICE
+				: DMA_FROM_DEVICE);
+		if (mapped == 0) {
+			dev_err(&gadget->dev, "failed to map SGs\n");
+			return -EFAULT;
+		}
+
+		req->num_mapped_sgs = mapped;
+	} else {
+		req->dma = dma_map_single(&gadget->dev, req->buf, req->length,
+				direction ? DMA_TO_DEVICE : DMA_FROM_DEVICE);
+
+		if (dma_mapping_error(&gadget->dev, req->dma)) {
+			dev_err(&gadget->dev, "failed to map buffer\n");
+			return -EFAULT;
+		}
+	}
+
+	return 0;
+}
+EXPORT_SYMBOL_GPL(usb_gadget_map_request);
+
+void usb_gadget_unmap_request(struct usb_gadget *gadget,
+		struct usb_request *req, int direction)
+{
+	if (req->length == 0)
+		return;
+
+	if (req->num_mapped_sgs) {
+		dma_unmap_sg(&gadget->dev, req->sg, req->num_sgs,
+				direction ? DMA_TO_DEVICE : DMA_FROM_DEVICE);
+
+		req->num_mapped_sgs = 0;
+	} else {
+		dma_unmap_single(&gadget->dev, req->dma, req->length,
+				direction ? DMA_TO_DEVICE : DMA_FROM_DEVICE);
+	}
+}
+EXPORT_SYMBOL_GPL(usb_gadget_unmap_request);
+
+/* ------------------------------------------------------------------------- */
+
 /**
  * usb_gadget_start - tells usb device controller to start up
  * @gadget: The gadget we want to get started
diff --git a/include/linux/usb/gadget.h b/include/linux/usb/gadget.h
index 911d4c7..9f84fdf 100644
--- a/include/linux/usb/gadget.h
+++ b/include/linux/usb/gadget.h
@@ -950,6 +950,16 @@ static inline void usb_free_descriptors(struct usb_descriptor_header **v)
 
 /*-------------------------------------------------------------------------*/
 
+/* utility to simplify map/unmap of usb_requests to/from DMA */
+
+extern int usb_gadget_map_request(struct usb_gadget *gadget,
+		struct usb_request *req, int direction);
+
+extern void usb_gadget_unmap_request(struct usb_gadget *gadget,
+		struct usb_request *req, int direction);
+
+/*-------------------------------------------------------------------------*/
+
 /* utility wrapping a simple endpoint selection policy */
 
 extern struct usb_ep *usb_ep_autoconfig(struct usb_gadget *,
-- 
1.7.8.rc3

Re: [PATCH 1/9] usb: gadget: add generic map/unmap request utilities

[Alan Stern]

On Mon, 19 Dec 2011, Felipe Balbi wrote:

> such utilities are currently duplicated on all UDC
> drivers basically with the same structure. Let's group
> all implementations into one generic implementation
> and get rid of that duplication.
> 
> Signed-off-by: Felipe Balbi <balbi@ti.com>
> ---
>  drivers/usb/gadget/udc-core.c |   53 +++++++++++++++++++++++++++++++++++++++++
>  include/linux/usb/gadget.h    |   10 +++++++
>  2 files changed, 63 insertions(+), 0 deletions(-)
> 
> diff --git a/drivers/usb/gadget/udc-core.c b/drivers/usb/gadget/udc-core.c
> index 0b0d12c..2031c11 100644
> --- a/drivers/usb/gadget/udc-core.c
> +++ b/drivers/usb/gadget/udc-core.c
> @@ -22,6 +22,7 @@
>  #include <linux/device.h>
>  #include <linux/list.h>
>  #include <linux/err.h>
> +#include <linux/dma-mapping.h>
>  
>  #include <linux/usb/ch9.h>
>  #include <linux/usb/gadget.h>
> @@ -49,6 +50,58 @@ static DEFINE_MUTEX(udc_lock);
>  
>  /* ------------------------------------------------------------------------- */
>  
> +int usb_gadget_map_request(struct usb_gadget *gadget,
> +		struct usb_request *req, int direction)
> +{
> +	if (req->length == 0)
> +		return 0;
> +
> +	if (req->num_sgs) {
> +		int     mapped;
> +
> +		mapped = dma_map_sg(&gadget->dev, req->sg, req->num_sgs,
> +				direction ? DMA_TO_DEVICE
> +				: DMA_FROM_DEVICE);
> +		if (mapped == 0) {
> +			dev_err(&gadget->dev, "failed to map SGs\n");
> +			return -EFAULT;
> +		}
> +
> +		req->num_mapped_sgs = mapped;
> +	} else {
> +		req->dma = dma_map_single(&gadget->dev, req->buf, req->length,
> +				direction ? DMA_TO_DEVICE : DMA_FROM_DEVICE);
> +
> +		if (dma_mapping_error(&gadget->dev, req->dma)) {
> +			dev_err(&gadget->dev, "failed to map buffer\n");
> +			return -EFAULT;
> +		}
> +	}
> +
> +	return 0;

You forgot to set req->mapped.

> +}
> +EXPORT_SYMBOL_GPL(usb_gadget_map_request);
> +
> +void usb_gadget_unmap_request(struct usb_gadget *gadget,
> +		struct usb_request *req, int direction)
> +{
> +	if (req->length == 0)
> +		return;
> +
> +	if (req->num_mapped_sgs) {
> +		dma_unmap_sg(&gadget->dev, req->sg, req->num_sgs,
> +				direction ? DMA_TO_DEVICE : DMA_FROM_DEVICE);
> +
> +		req->num_mapped_sgs = 0;
> +	} else {
> +		dma_unmap_single(&gadget->dev, req->dma, req->length,
> +				direction ? DMA_TO_DEVICE : DMA_FROM_DEVICE);
> +	}

You forgot to clear req->mapped.

Alan Stern

Re: [PATCH 1/9] usb: gadget: add generic map/unmap request utilities

[Felipe Balbi]

[-- Attachment #1: Type: text/plain, Size: 2400 bytes --]

Hi,

On Mon, Dec 19, 2011 at 10:19:46AM -0500, Alan Stern wrote:
> On Mon, 19 Dec 2011, Felipe Balbi wrote:
> 
> > such utilities are currently duplicated on all UDC
> > drivers basically with the same structure. Let's group
> > all implementations into one generic implementation
> > and get rid of that duplication.
> > 
> > Signed-off-by: Felipe Balbi <balbi@ti.com>
> > ---
> >  drivers/usb/gadget/udc-core.c |   53 +++++++++++++++++++++++++++++++++++++++++
> >  include/linux/usb/gadget.h    |   10 +++++++
> >  2 files changed, 63 insertions(+), 0 deletions(-)
> > 
> > diff --git a/drivers/usb/gadget/udc-core.c b/drivers/usb/gadget/udc-core.c
> > index 0b0d12c..2031c11 100644
> > --- a/drivers/usb/gadget/udc-core.c
> > +++ b/drivers/usb/gadget/udc-core.c
> > @@ -22,6 +22,7 @@
> >  #include <linux/device.h>
> >  #include <linux/list.h>
> >  #include <linux/err.h>
> > +#include <linux/dma-mapping.h>
> >  
> >  #include <linux/usb/ch9.h>
> >  #include <linux/usb/gadget.h>
> > @@ -49,6 +50,58 @@ static DEFINE_MUTEX(udc_lock);
> >  
> >  /* ------------------------------------------------------------------------- */
> >  
> > +int usb_gadget_map_request(struct usb_gadget *gadget,
> > +		struct usb_request *req, int direction)
> > +{
> > +	if (req->length == 0)
> > +		return 0;
> > +
> > +	if (req->num_sgs) {
> > +		int     mapped;
> > +
> > +		mapped = dma_map_sg(&gadget->dev, req->sg, req->num_sgs,
> > +				direction ? DMA_TO_DEVICE
> > +				: DMA_FROM_DEVICE);
> > +		if (mapped == 0) {
> > +			dev_err(&gadget->dev, "failed to map SGs\n");
> > +			return -EFAULT;
> > +		}
> > +
> > +		req->num_mapped_sgs = mapped;
> > +	} else {
> > +		req->dma = dma_map_single(&gadget->dev, req->buf, req->length,
> > +				direction ? DMA_TO_DEVICE : DMA_FROM_DEVICE);
> > +
> > +		if (dma_mapping_error(&gadget->dev, req->dma)) {
> > +			dev_err(&gadget->dev, "failed to map buffer\n");
> > +			return -EFAULT;
> > +		}
> > +	}
> > +
> > +	return 0;
> 
> You forgot to set req->mapped.

actually there's no 'mapped' field on struct usb_request. That's a
nonsense added to all struct my_controller_request just because of that
DMA_ADDR_INVALID hackery. I'm dropping that completely. There were no
gadget drivers allocating memory from coherent or mapping requests
themselves, so req->mapped becomes useless.

-- 
balbi

[-- Attachment #2: Digital signature --]
[-- Type: application/pgp-signature, Size: 836 bytes --]

Re: [PATCH 1/9] usb: gadget: add generic map/unmap request utilities

[Felipe Balbi]

[-- Attachment #1: Type: text/plain, Size: 2422 bytes --]

Hi,

On Mon, Dec 19, 2011 at 10:19:46AM -0500, Alan Stern wrote:
> On Mon, 19 Dec 2011, Felipe Balbi wrote:
> 
> > such utilities are currently duplicated on all UDC
> > drivers basically with the same structure. Let's group
> > all implementations into one generic implementation
> > and get rid of that duplication.
> > 
> > Signed-off-by: Felipe Balbi <balbi-l0cyMroinI0@public.gmane.org>
> > ---
> >  drivers/usb/gadget/udc-core.c |   53 +++++++++++++++++++++++++++++++++++++++++
> >  include/linux/usb/gadget.h    |   10 +++++++
> >  2 files changed, 63 insertions(+), 0 deletions(-)
> > 
> > diff --git a/drivers/usb/gadget/udc-core.c b/drivers/usb/gadget/udc-core.c
> > index 0b0d12c..2031c11 100644
> > --- a/drivers/usb/gadget/udc-core.c
> > +++ b/drivers/usb/gadget/udc-core.c
> > @@ -22,6 +22,7 @@
> >  #include <linux/device.h>
> >  #include <linux/list.h>
> >  #include <linux/err.h>
> > +#include <linux/dma-mapping.h>
> >  
> >  #include <linux/usb/ch9.h>
> >  #include <linux/usb/gadget.h>
> > @@ -49,6 +50,58 @@ static DEFINE_MUTEX(udc_lock);
> >  
> >  /* ------------------------------------------------------------------------- */
> >  
> > +int usb_gadget_map_request(struct usb_gadget *gadget,
> > +		struct usb_request *req, int direction)
> > +{
> > +	if (req->length == 0)
> > +		return 0;
> > +
> > +	if (req->num_sgs) {
> > +		int     mapped;
> > +
> > +		mapped = dma_map_sg(&gadget->dev, req->sg, req->num_sgs,
> > +				direction ? DMA_TO_DEVICE
> > +				: DMA_FROM_DEVICE);
> > +		if (mapped == 0) {
> > +			dev_err(&gadget->dev, "failed to map SGs\n");
> > +			return -EFAULT;
> > +		}
> > +
> > +		req->num_mapped_sgs = mapped;
> > +	} else {
> > +		req->dma = dma_map_single(&gadget->dev, req->buf, req->length,
> > +				direction ? DMA_TO_DEVICE : DMA_FROM_DEVICE);
> > +
> > +		if (dma_mapping_error(&gadget->dev, req->dma)) {
> > +			dev_err(&gadget->dev, "failed to map buffer\n");
> > +			return -EFAULT;
> > +		}
> > +	}
> > +
> > +	return 0;
> 
> You forgot to set req->mapped.

actually there's no 'mapped' field on struct usb_request. That's a
nonsense added to all struct my_controller_request just because of that
DMA_ADDR_INVALID hackery. I'm dropping that completely. There were no
gadget drivers allocating memory from coherent or mapping requests
themselves, so req->mapped becomes useless.

-- 
balbi

[-- Attachment #2: Digital signature --]
[-- Type: application/pgp-signature, Size: 836 bytes --]

Re: [PATCH 1/9] usb: gadget: add generic map/unmap request utilities

[Alan Stern]

On Mon, 19 Dec 2011, Felipe Balbi wrote:

> > > +		if (dma_mapping_error(&gadget->dev, req->dma)) {
> > > +			dev_err(&gadget->dev, "failed to map buffer\n");
> > > +			return -EFAULT;
> > > +		}
> > > +	}
> > > +
> > > +	return 0;
> > 
> > You forgot to set req->mapped.
> 
> actually there's no 'mapped' field on struct usb_request. That's a

Whoops, you're right.  It's part of the UDC-private structure.

> nonsense added to all struct my_controller_request just because of that
> DMA_ADDR_INVALID hackery. I'm dropping that completely. There were no
> gadget drivers allocating memory from coherent or mapping requests
> themselves, so req->mapped becomes useless.

There's more to it than that.  A controller might support DMA on some
endpoints but not others, or for certain request lengths but not
others.  Hence when a request finishes, the driver needs to know
whether the request was mapped for DMA.

For example, your net2280 patch needs to be fixed.  Here's how it looks
now:

> --- a/drivers/usb/gadget/net2280.c
> +++ b/drivers/usb/gadget/net2280.c
> @@ -806,12 +806,8 @@ done (struct net2280_ep *ep, struct net2280_request *req, int status)
>  		status = req->req.status;
>  
>  	dev = ep->dev;
> -	if (req->mapped) {
> -		pci_unmap_single (dev->pdev, req->req.dma, req->req.length,
> -			ep->is_in ? PCI_DMA_TODEVICE : PCI_DMA_FROMDEVICE);
> -		req->req.dma = DMA_ADDR_INVALID;
> -		req->mapped = 0;
> -	}
> +	if (req->mapped)
> +		usb_gadget_unmap_request(&dev->gadget, &req->req, ep->is_in);

This code will never be executed because you never set req->mapped.  
And after that's fixed, when the unmapping occurs, req->mapped has to
be set back to 0.

> @@ -857,10 +853,13 @@ net2280_queue (struct usb_ep *_ep, struct usb_request *_req, gfp_t gfp_flags)
>  		return -EOPNOTSUPP;
>  
>  	/* set up dma mapping in case the caller didn't */
> -	if (ep->dma && _req->dma == DMA_ADDR_INVALID) {
> -		_req->dma = pci_map_single (dev->pdev, _req->buf, _req->length,
> -			ep->is_in ? PCI_DMA_TODEVICE : PCI_DMA_FROMDEVICE);
> -		req->mapped = 1;
> +	if (ep->dma) {
> +		int ret;
> +
> +		ret = usb_gadget_map_request(&dev->gadget, &req->req,
> +				ep->is_in);
> +		if (ret)
> +			return ret;

You probably need to set req->mapped right here.  Or rather, avoid 
removing the line that sets it.

>  	}

Alan Stern

[PATCH 2/9] usb: dwc3: gadget: use generic map/unmap routines

[Felipe Balbi]

those routines have everything we need to map/unmap
USB requests and it's better to use them.

Signed-off-by: Felipe Balbi <balbi@ti.com>
---
 drivers/usb/dwc3/gadget.c |   80 +++++++--------------------------------------
 1 files changed, 12 insertions(+), 68 deletions(-)

diff --git a/drivers/usb/dwc3/gadget.c b/drivers/usb/dwc3/gadget.c
index d228188..50e955f 100644
--- a/drivers/usb/dwc3/gadget.c
+++ b/drivers/usb/dwc3/gadget.c
@@ -54,70 +54,6 @@
 #include "gadget.h"
 #include "io.h"
 
-#define	DMA_ADDR_INVALID	(~(dma_addr_t)0)
-
-void dwc3_map_buffer_to_dma(struct dwc3_request *req)
-{
-	struct dwc3			*dwc = req->dep->dwc;
-
-	if (req->request.length == 0) {
-		/* req->request.dma = dwc->setup_buf_addr; */
-		return;
-	}
-
-	if (req->request.num_sgs) {
-		int	mapped;
-
-		mapped = dma_map_sg(dwc->dev, req->request.sg,
-				req->request.num_sgs,
-				req->direction ? DMA_TO_DEVICE
-				: DMA_FROM_DEVICE);
-		if (mapped < 0) {
-			dev_err(dwc->dev, "failed to map SGs\n");
-			return;
-		}
-
-		req->request.num_mapped_sgs = mapped;
-		return;
-	}
-
-	if (req->request.dma == DMA_ADDR_INVALID) {
-		req->request.dma = dma_map_single(dwc->dev, req->request.buf,
-				req->request.length, req->direction
-				? DMA_TO_DEVICE : DMA_FROM_DEVICE);
-		req->mapped = true;
-	}
-}
-
-void dwc3_unmap_buffer_from_dma(struct dwc3_request *req)
-{
-	struct dwc3			*dwc = req->dep->dwc;
-
-	if (req->request.length == 0) {
-		req->request.dma = DMA_ADDR_INVALID;
-		return;
-	}
-
-	if (req->request.num_mapped_sgs) {
-		req->request.dma = DMA_ADDR_INVALID;
-		dma_unmap_sg(dwc->dev, req->request.sg,
-				req->request.num_sgs,
-				req->direction ? DMA_TO_DEVICE
-				: DMA_FROM_DEVICE);
-
-		req->request.num_mapped_sgs = 0;
-		return;
-	}
-
-	if (req->mapped) {
-		dma_unmap_single(dwc->dev, req->request.dma,
-				req->request.length, req->direction
-				? DMA_TO_DEVICE : DMA_FROM_DEVICE);
-		req->mapped = 0;
-		req->request.dma = DMA_ADDR_INVALID;
-	}
-}
-
 void dwc3_gadget_giveback(struct dwc3_ep *dep, struct dwc3_request *req,
 		int status)
 {
@@ -144,7 +80,8 @@ void dwc3_gadget_giveback(struct dwc3_ep *dep, struct dwc3_request *req,
 	if (req->request.status == -EINPROGRESS)
 		req->request.status = status;
 
-	dwc3_unmap_buffer_from_dma(req);
+	usb_gadget_unmap_request(&dwc->gadget, &req->request,
+			req->direction);
 
 	dev_dbg(dwc->dev, "request %p from %s completed %d/%d ===> %d\n",
 			req, dep->name, req->request.actual,
@@ -558,7 +495,6 @@ static struct usb_request *dwc3_gadget_ep_alloc_request(struct usb_ep *ep,
 
 	req->epnum	= dep->number;
 	req->dep	= dep;
-	req->request.dma = DMA_ADDR_INVALID;
 
 	return &req->request;
 }
@@ -817,7 +753,8 @@ static int __dwc3_gadget_kick_transfer(struct dwc3_ep *dep, u16 cmd_param,
 		 * here and stop, unmap, free and del each of the linked
 		 * requests instead of we do now.
 		 */
-		dwc3_unmap_buffer_from_dma(req);
+		usb_gadget_unmap_request(&dwc->gadget, &req->request,
+				req->direction);
 		list_del(&req->list);
 		return ret;
 	}
@@ -832,6 +769,9 @@ static int __dwc3_gadget_kick_transfer(struct dwc3_ep *dep, u16 cmd_param,
 
 static int __dwc3_gadget_ep_queue(struct dwc3_ep *dep, struct dwc3_request *req)
 {
+	struct dwc3		*dwc = dep->dwc;
+	int			ret;
+
 	req->request.actual	= 0;
 	req->request.status	= -EINPROGRESS;
 	req->direction		= dep->direction;
@@ -849,7 +789,11 @@ static int __dwc3_gadget_ep_queue(struct dwc3_ep *dep, struct dwc3_request *req)
 	 * This will also avoid Host cancelling URBs due to too
 	 * many NACKs.
 	 */
-	dwc3_map_buffer_to_dma(req);
+	ret = usb_gadget_map_request(&dwc->gadget, &req->request,
+			dep->direction);
+	if (ret)
+		return ret;
+
 	list_add_tail(&req->list, &dep->request_list);
 
 	/*
-- 
1.7.8.rc3

[PATCH 2/9] usb: dwc3: gadget: use generic map/unmap routines

[Felipe Balbi]

those routines have everything we need to map/unmap
USB requests and it's better to use them.

Signed-off-by: Felipe Balbi <balbi-l0cyMroinI0@public.gmane.org>
---
 drivers/usb/dwc3/gadget.c |   80 +++++++--------------------------------------
 1 files changed, 12 insertions(+), 68 deletions(-)

diff --git a/drivers/usb/dwc3/gadget.c b/drivers/usb/dwc3/gadget.c
index d228188..50e955f 100644
--- a/drivers/usb/dwc3/gadget.c
+++ b/drivers/usb/dwc3/gadget.c
@@ -54,70 +54,6 @@
 #include "gadget.h"
 #include "io.h"
 
-#define	DMA_ADDR_INVALID	(~(dma_addr_t)0)
-
-void dwc3_map_buffer_to_dma(struct dwc3_request *req)
-{
-	struct dwc3			*dwc = req->dep->dwc;
-
-	if (req->request.length == 0) {
-		/* req->request.dma = dwc->setup_buf_addr; */
-		return;
-	}
-
-	if (req->request.num_sgs) {
-		int	mapped;
-
-		mapped = dma_map_sg(dwc->dev, req->request.sg,
-				req->request.num_sgs,
-				req->direction ? DMA_TO_DEVICE
-				: DMA_FROM_DEVICE);
-		if (mapped < 0) {
-			dev_err(dwc->dev, "failed to map SGs\n");
-			return;
-		}
-
-		req->request.num_mapped_sgs = mapped;
-		return;
-	}
-
-	if (req->request.dma == DMA_ADDR_INVALID) {
-		req->request.dma = dma_map_single(dwc->dev, req->request.buf,
-				req->request.length, req->direction
-				? DMA_TO_DEVICE : DMA_FROM_DEVICE);
-		req->mapped = true;
-	}
-}
-
-void dwc3_unmap_buffer_from_dma(struct dwc3_request *req)
-{
-	struct dwc3			*dwc = req->dep->dwc;
-
-	if (req->request.length == 0) {
-		req->request.dma = DMA_ADDR_INVALID;
-		return;
-	}
-
-	if (req->request.num_mapped_sgs) {
-		req->request.dma = DMA_ADDR_INVALID;
-		dma_unmap_sg(dwc->dev, req->request.sg,
-				req->request.num_sgs,
-				req->direction ? DMA_TO_DEVICE
-				: DMA_FROM_DEVICE);
-
-		req->request.num_mapped_sgs = 0;
-		return;
-	}
-
-	if (req->mapped) {
-		dma_unmap_single(dwc->dev, req->request.dma,
-				req->request.length, req->direction
-				? DMA_TO_DEVICE : DMA_FROM_DEVICE);
-		req->mapped = 0;
-		req->request.dma = DMA_ADDR_INVALID;
-	}
-}
-
 void dwc3_gadget_giveback(struct dwc3_ep *dep, struct dwc3_request *req,
 		int status)
 {
@@ -144,7 +80,8 @@ void dwc3_gadget_giveback(struct dwc3_ep *dep, struct dwc3_request *req,
 	if (req->request.status == -EINPROGRESS)
 		req->request.status = status;
 
-	dwc3_unmap_buffer_from_dma(req);
+	usb_gadget_unmap_request(&dwc->gadget, &req->request,
+			req->direction);
 
 	dev_dbg(dwc->dev, "request %p from %s completed %d/%d ===> %d\n",
 			req, dep->name, req->request.actual,
@@ -558,7 +495,6 @@ static struct usb_request *dwc3_gadget_ep_alloc_request(struct usb_ep *ep,
 
 	req->epnum	= dep->number;
 	req->dep	= dep;
-	req->request.dma = DMA_ADDR_INVALID;
 
 	return &req->request;
 }
@@ -817,7 +753,8 @@ static int __dwc3_gadget_kick_transfer(struct dwc3_ep *dep, u16 cmd_param,
 		 * here and stop, unmap, free and del each of the linked
 		 * requests instead of we do now.
 		 */
-		dwc3_unmap_buffer_from_dma(req);
+		usb_gadget_unmap_request(&dwc->gadget, &req->request,
+				req->direction);
 		list_del(&req->list);
 		return ret;
 	}
@@ -832,6 +769,9 @@ static int __dwc3_gadget_kick_transfer(struct dwc3_ep *dep, u16 cmd_param,
 
 static int __dwc3_gadget_ep_queue(struct dwc3_ep *dep, struct dwc3_request *req)
 {
+	struct dwc3		*dwc = dep->dwc;
+	int			ret;
+
 	req->request.actual	= 0;
 	req->request.status	= -EINPROGRESS;
 	req->direction		= dep->direction;
@@ -849,7 +789,11 @@ static int __dwc3_gadget_ep_queue(struct dwc3_ep *dep, struct dwc3_request *req)
 	 * This will also avoid Host cancelling URBs due to too
 	 * many NACKs.
 	 */
-	dwc3_map_buffer_to_dma(req);
+	ret = usb_gadget_map_request(&dwc->gadget, &req->request,
+			dep->direction);
+	if (ret)
+		return ret;
+
 	list_add_tail(&req->list, &dep->request_list);
 
 	/*
-- 
1.7.8.rc3

--
To unsubscribe from this list: send the line "unsubscribe linux-usb" in
the body of a message to majordomo-u79uwXL29TY76Z2rM5mHXA@public.gmane.org
More majordomo info at  http://vger.kernel.org/majordomo-info.html

[PATCH 3/9] usb: gadget: langwell: use generic map/unmap functions

[Felipe Balbi]

those routines have everything we need to map/unmap
USB requests and it's better to use them.

Signed-off-by: Felipe Balbi <balbi@ti.com>
---
 drivers/usb/gadget/langwell_udc.c |   45 +++++-------------------------------
 1 files changed, 7 insertions(+), 38 deletions(-)

diff --git a/drivers/usb/gadget/langwell_udc.c b/drivers/usb/gadget/langwell_udc.c
index fa0fcc1..fe7fbe3 100644
--- a/drivers/usb/gadget/langwell_udc.c
+++ b/drivers/usb/gadget/langwell_udc.c
@@ -406,16 +406,7 @@ static void done(struct langwell_ep *ep, struct langwell_request *req,
 		dma_pool_free(dev->dtd_pool, curr_dtd, curr_dtd->dtd_dma);
 	}
 
-	if (req->mapped) {
-		dma_unmap_single(&dev->pdev->dev,
-			req->req.dma, req->req.length,
-			is_in(ep) ? PCI_DMA_TODEVICE : PCI_DMA_FROMDEVICE);
-		req->req.dma = DMA_ADDR_INVALID;
-		req->mapped = 0;
-	} else
-		dma_sync_single_for_cpu(&dev->pdev->dev, req->req.dma,
-				req->req.length,
-				is_in(ep) ? DMA_TO_DEVICE : DMA_FROM_DEVICE);
+	usb_gadget_unmap_request(&dev->gadget, &req->req, is_in(ep));
 
 	if (status != -ESHUTDOWN)
 		dev_dbg(&dev->pdev->dev,
@@ -754,7 +745,8 @@ static int langwell_ep_queue(struct usb_ep *_ep, struct usb_request *_req,
 	struct langwell_ep	*ep;
 	struct langwell_udc	*dev;
 	unsigned long		flags;
-	int			is_iso = 0, zlflag = 0;
+	int			is_iso = 0;
+	int			ret;
 
 	/* always require a cpu-view buffer */
 	req = container_of(_req, struct langwell_request, req);
@@ -781,33 +773,10 @@ static int langwell_ep_queue(struct usb_ep *_ep, struct usb_request *_req,
 	if (unlikely(!dev->driver || dev->gadget.speed == USB_SPEED_UNKNOWN))
 		return -ESHUTDOWN;
 
-	/* set up dma mapping in case the caller didn't */
-	if (_req->dma == DMA_ADDR_INVALID) {
-		/* WORKAROUND: WARN_ON(size == 0) */
-		if (_req->length == 0) {
-			dev_vdbg(&dev->pdev->dev, "req->length: 0->1\n");
-			zlflag = 1;
-			_req->length++;
-		}
-
-		_req->dma = dma_map_single(&dev->pdev->dev,
-				_req->buf, _req->length,
-				is_in(ep) ? DMA_TO_DEVICE : DMA_FROM_DEVICE);
-		if (zlflag && (_req->length == 1)) {
-			dev_vdbg(&dev->pdev->dev, "req->length: 1->0\n");
-			zlflag = 0;
-			_req->length = 0;
-		}
-
-		req->mapped = 1;
-		dev_vdbg(&dev->pdev->dev, "req->mapped = 1\n");
-	} else {
-		dma_sync_single_for_device(&dev->pdev->dev,
-				_req->dma, _req->length,
-				is_in(ep) ?  DMA_TO_DEVICE : DMA_FROM_DEVICE);
-		req->mapped = 0;
-		dev_vdbg(&dev->pdev->dev, "req->mapped = 0\n");
-	}
+	/* set up dma mapping */
+	ret = usb_gadget_map_request(&dev->gadget, &req->req, is_in(ep));
+	if (ret)
+		return ret;
 
 	dev_dbg(&dev->pdev->dev,
 			"%s queue req %p, len %u, buf %p, dma 0x%08x\n",
-- 
1.7.8.rc3

[PATCH 3/9] usb: gadget: langwell: use generic map/unmap functions

[Felipe Balbi]

those routines have everything we need to map/unmap
USB requests and it's better to use them.

Signed-off-by: Felipe Balbi <balbi@ti.com>
---
 drivers/usb/gadget/langwell_udc.c |   45 +++++-------------------------------
 1 files changed, 7 insertions(+), 38 deletions(-)

diff --git a/drivers/usb/gadget/langwell_udc.c b/drivers/usb/gadget/langwell_udc.c
index fa0fcc1..fe7fbe3 100644
--- a/drivers/usb/gadget/langwell_udc.c
+++ b/drivers/usb/gadget/langwell_udc.c
@@ -406,16 +406,7 @@ static void done(struct langwell_ep *ep, struct langwell_request *req,
 		dma_pool_free(dev->dtd_pool, curr_dtd, curr_dtd->dtd_dma);
 	}
 
-	if (req->mapped) {
-		dma_unmap_single(&dev->pdev->dev,
-			req->req.dma, req->req.length,
-			is_in(ep) ? PCI_DMA_TODEVICE : PCI_DMA_FROMDEVICE);
-		req->req.dma = DMA_ADDR_INVALID;
-		req->mapped = 0;
-	} else
-		dma_sync_single_for_cpu(&dev->pdev->dev, req->req.dma,
-				req->req.length,
-				is_in(ep) ? DMA_TO_DEVICE : DMA_FROM_DEVICE);
+	usb_gadget_unmap_request(&dev->gadget, &req->req, is_in(ep));
 
 	if (status != -ESHUTDOWN)
 		dev_dbg(&dev->pdev->dev,
@@ -754,7 +745,8 @@ static int langwell_ep_queue(struct usb_ep *_ep, struct usb_request *_req,
 	struct langwell_ep	*ep;
 	struct langwell_udc	*dev;
 	unsigned long		flags;
-	int			is_iso = 0, zlflag = 0;
+	int			is_iso = 0;
+	int			ret;
 
 	/* always require a cpu-view buffer */
 	req = container_of(_req, struct langwell_request, req);
@@ -781,33 +773,10 @@ static int langwell_ep_queue(struct usb_ep *_ep, struct usb_request *_req,
 	if (unlikely(!dev->driver || dev->gadget.speed == USB_SPEED_UNKNOWN))
 		return -ESHUTDOWN;
 
-	/* set up dma mapping in case the caller didn't */
-	if (_req->dma == DMA_ADDR_INVALID) {
-		/* WORKAROUND: WARN_ON(size == 0) */
-		if (_req->length == 0) {
-			dev_vdbg(&dev->pdev->dev, "req->length: 0->1\n");
-			zlflag = 1;
-			_req->length++;
-		}
-
-		_req->dma = dma_map_single(&dev->pdev->dev,
-				_req->buf, _req->length,
-				is_in(ep) ? DMA_TO_DEVICE : DMA_FROM_DEVICE);
-		if (zlflag && (_req->length == 1)) {
-			dev_vdbg(&dev->pdev->dev, "req->length: 1->0\n");
-			zlflag = 0;
-			_req->length = 0;
-		}
-
-		req->mapped = 1;
-		dev_vdbg(&dev->pdev->dev, "req->mapped = 1\n");
-	} else {
-		dma_sync_single_for_device(&dev->pdev->dev,
-				_req->dma, _req->length,
-				is_in(ep) ?  DMA_TO_DEVICE : DMA_FROM_DEVICE);
-		req->mapped = 0;
-		dev_vdbg(&dev->pdev->dev, "req->mapped = 0\n");
-	}
+	/* set up dma mapping */
+	ret = usb_gadget_map_request(&dev->gadget, &req->req, is_in(ep));
+	if (ret)
+		return ret;
 
 	dev_dbg(&dev->pdev->dev,
 			"%s queue req %p, len %u, buf %p, dma 0x%08x\n",
-- 
1.7.8.rc3

[PATCH 4/9] usb: renesas: gadget: use generic map/unmap routines

[Felipe Balbi]

those routines have everything we need to map/unmap
USB requests and it's better to use them.

Signed-off-by: Felipe Balbi <balbi@ti.com>
---
 drivers/usb/renesas_usbhs/mod_gadget.c |   60 ++++----------------------------
 1 files changed, 7 insertions(+), 53 deletions(-)

diff --git a/drivers/usb/renesas_usbhs/mod_gadget.c b/drivers/usb/renesas_usbhs/mod_gadget.c
index 528691d5f..cb92a1d 100644
--- a/drivers/usb/renesas_usbhs/mod_gadget.c
+++ b/drivers/usb/renesas_usbhs/mod_gadget.c
@@ -165,69 +165,23 @@ static void usbhsg_queue_push(struct usbhsg_uep *uep,
 /*
  *		dma map/unmap
  */
-static int usbhsg_dma_map(struct device *dev,
-			  struct usbhs_pkt *pkt,
-			  enum dma_data_direction dir)
-{
-	struct usbhsg_request *ureq = usbhsg_pkt_to_ureq(pkt);
-	struct usb_request *req = &ureq->req;
-
-	if (pkt->dma != DMA_ADDR_INVALID) {
-		dev_err(dev, "dma is already mapped\n");
-		return -EIO;
-	}
-
-	if (req->dma == DMA_ADDR_INVALID) {
-		pkt->dma = dma_map_single(dev, pkt->buf, pkt->length, dir);
-	} else {
-		dma_sync_single_for_device(dev, req->dma, req->length, dir);
-		pkt->dma = req->dma;
-	}
-
-	if (dma_mapping_error(dev, pkt->dma)) {
-		dev_err(dev, "dma mapping error %llx\n", (u64)pkt->dma);
-		return -EIO;
-	}
-
-	return 0;
-}
-
-static int usbhsg_dma_unmap(struct device *dev,
-			    struct usbhs_pkt *pkt,
-			    enum dma_data_direction dir)
+static int usbhsg_dma_map_ctrl(struct usbhs_pkt *pkt, int map)
 {
 	struct usbhsg_request *ureq = usbhsg_pkt_to_ureq(pkt);
 	struct usb_request *req = &ureq->req;
-
-	if (pkt->dma == DMA_ADDR_INVALID) {
-		dev_err(dev, "dma is not mapped\n");
-		return -EIO;
-	}
-
-	if (req->dma == DMA_ADDR_INVALID)
-		dma_unmap_single(dev, pkt->dma, pkt->length, dir);
-	else
-		dma_sync_single_for_cpu(dev, req->dma, req->length, dir);
-
-	pkt->dma = DMA_ADDR_INVALID;
-
-	return 0;
-}
-
-static int usbhsg_dma_map_ctrl(struct usbhs_pkt *pkt, int map)
-{
 	struct usbhs_pipe *pipe = pkt->pipe;
 	struct usbhsg_uep *uep = usbhsg_pipe_to_uep(pipe);
 	struct usbhsg_gpriv *gpriv = usbhsg_uep_to_gpriv(uep);
-	struct device *dev = usbhsg_gpriv_to_dev(gpriv);
 	enum dma_data_direction dir;
 
 	dir = usbhs_pipe_is_dir_in(pipe) ? DMA_FROM_DEVICE : DMA_TO_DEVICE;
 
-	if (map)
-		return usbhsg_dma_map(dev, pkt, dir);
-	else
-		return usbhsg_dma_unmap(dev, pkt, dir);
+	if (map) {
+		return usb_gadget_map_request(&gpriv->gadget, req, dir);
+	} else {
+		usb_gadget_unmap_request(&gpriv->gadget, req, dir);
+		return 0;
+	}
 }
 
 /*
-- 
1.7.8.rc3

[PATCH 4/9] usb: renesas: gadget: use generic map/unmap routines

[Felipe Balbi]

those routines have everything we need to map/unmap
USB requests and it's better to use them.

Signed-off-by: Felipe Balbi <balbi@ti.com>
---
 drivers/usb/renesas_usbhs/mod_gadget.c |   60 ++++----------------------------
 1 files changed, 7 insertions(+), 53 deletions(-)

diff --git a/drivers/usb/renesas_usbhs/mod_gadget.c b/drivers/usb/renesas_usbhs/mod_gadget.c
index 528691d5f..cb92a1d 100644
--- a/drivers/usb/renesas_usbhs/mod_gadget.c
+++ b/drivers/usb/renesas_usbhs/mod_gadget.c
@@ -165,69 +165,23 @@ static void usbhsg_queue_push(struct usbhsg_uep *uep,
 /*
  *		dma map/unmap
  */
-static int usbhsg_dma_map(struct device *dev,
-			  struct usbhs_pkt *pkt,
-			  enum dma_data_direction dir)
-{
-	struct usbhsg_request *ureq = usbhsg_pkt_to_ureq(pkt);
-	struct usb_request *req = &ureq->req;
-
-	if (pkt->dma != DMA_ADDR_INVALID) {
-		dev_err(dev, "dma is already mapped\n");
-		return -EIO;
-	}
-
-	if (req->dma == DMA_ADDR_INVALID) {
-		pkt->dma = dma_map_single(dev, pkt->buf, pkt->length, dir);
-	} else {
-		dma_sync_single_for_device(dev, req->dma, req->length, dir);
-		pkt->dma = req->dma;
-	}
-
-	if (dma_mapping_error(dev, pkt->dma)) {
-		dev_err(dev, "dma mapping error %llx\n", (u64)pkt->dma);
-		return -EIO;
-	}
-
-	return 0;
-}
-
-static int usbhsg_dma_unmap(struct device *dev,
-			    struct usbhs_pkt *pkt,
-			    enum dma_data_direction dir)
+static int usbhsg_dma_map_ctrl(struct usbhs_pkt *pkt, int map)
 {
 	struct usbhsg_request *ureq = usbhsg_pkt_to_ureq(pkt);
 	struct usb_request *req = &ureq->req;
-
-	if (pkt->dma == DMA_ADDR_INVALID) {
-		dev_err(dev, "dma is not mapped\n");
-		return -EIO;
-	}
-
-	if (req->dma == DMA_ADDR_INVALID)
-		dma_unmap_single(dev, pkt->dma, pkt->length, dir);
-	else
-		dma_sync_single_for_cpu(dev, req->dma, req->length, dir);
-
-	pkt->dma = DMA_ADDR_INVALID;
-
-	return 0;
-}
-
-static int usbhsg_dma_map_ctrl(struct usbhs_pkt *pkt, int map)
-{
 	struct usbhs_pipe *pipe = pkt->pipe;
 	struct usbhsg_uep *uep = usbhsg_pipe_to_uep(pipe);
 	struct usbhsg_gpriv *gpriv = usbhsg_uep_to_gpriv(uep);
-	struct device *dev = usbhsg_gpriv_to_dev(gpriv);
 	enum dma_data_direction dir;
 
 	dir = usbhs_pipe_is_dir_in(pipe) ? DMA_FROM_DEVICE : DMA_TO_DEVICE;
 
-	if (map)
-		return usbhsg_dma_map(dev, pkt, dir);
-	else
-		return usbhsg_dma_unmap(dev, pkt, dir);
+	if (map) {
+		return usb_gadget_map_request(&gpriv->gadget, req, dir);
+	} else {
+		usb_gadget_unmap_request(&gpriv->gadget, req, dir);
+		return 0;
+	}
 }
 
 /*
-- 
1.7.8.rc3

Re: [PATCH 4/9] usb: renesas: gadget: use generic map/unmap routines

[Kuninori Morimoto]

Hi Felipe

Thank you for your hard work

> those routines have everything we need to map/unmap
> USB requests and it's better to use them.
> 
> Signed-off-by: Felipe Balbi <balbi@ti.com>
> ---
>  drivers/usb/renesas_usbhs/mod_gadget.c |   60 ++++----------------------------
>  1 files changed, 7 insertions(+), 53 deletions(-)
> 
> diff --git a/drivers/usb/renesas_usbhs/mod_gadget.c b/drivers/usb/renesas_usbhs/mod_gadget.c
> index 528691d5f..cb92a1d 100644
> --- a/drivers/usb/renesas_usbhs/mod_gadget.c
> +++ b/drivers/usb/renesas_usbhs/mod_gadget.c
> @@ -165,69 +165,23 @@ static void usbhsg_queue_push(struct usbhsg_uep *uep,
>  /*
>   *		dma map/unmap
>   */
> -static int usbhsg_dma_map(struct device *dev,
> -			  struct usbhs_pkt *pkt,
> -			  enum dma_data_direction dir)
> -{
> -	struct usbhsg_request *ureq = usbhsg_pkt_to_ureq(pkt);
> -	struct usb_request *req = &ureq->req;
> -
> -	if (pkt->dma != DMA_ADDR_INVALID) {
> -		dev_err(dev, "dma is already mapped\n");
> -		return -EIO;
> -	}
> -
> -	if (req->dma == DMA_ADDR_INVALID) {
> -		pkt->dma = dma_map_single(dev, pkt->buf, pkt->length, dir);
> -	} else {
> -		dma_sync_single_for_device(dev, req->dma, req->length, dir);
> -		pkt->dma = req->dma;
> -	}
> -
> -	if (dma_mapping_error(dev, pkt->dma)) {
> -		dev_err(dev, "dma mapping error %llx\n", (u64)pkt->dma);
> -		return -EIO;
> -	}
> -
> -	return 0;
> -}
> -
> -static int usbhsg_dma_unmap(struct device *dev,
> -			    struct usbhs_pkt *pkt,
> -			    enum dma_data_direction dir)
> +static int usbhsg_dma_map_ctrl(struct usbhs_pkt *pkt, int map)
>  {
>  	struct usbhsg_request *ureq = usbhsg_pkt_to_ureq(pkt);
>  	struct usb_request *req = &ureq->req;
> -
> -	if (pkt->dma == DMA_ADDR_INVALID) {
> -		dev_err(dev, "dma is not mapped\n");
> -		return -EIO;
> -	}
> -
> -	if (req->dma == DMA_ADDR_INVALID)
> -		dma_unmap_single(dev, pkt->dma, pkt->length, dir);
> -	else
> -		dma_sync_single_for_cpu(dev, req->dma, req->length, dir);
> -
> -	pkt->dma = DMA_ADDR_INVALID;
> -
> -	return 0;
> -}
> -
> -static int usbhsg_dma_map_ctrl(struct usbhs_pkt *pkt, int map)
> -{
>  	struct usbhs_pipe *pipe = pkt->pipe;
>  	struct usbhsg_uep *uep = usbhsg_pipe_to_uep(pipe);
>  	struct usbhsg_gpriv *gpriv = usbhsg_uep_to_gpriv(uep);
> -	struct device *dev = usbhsg_gpriv_to_dev(gpriv);
>  	enum dma_data_direction dir;
>  
>  	dir = usbhs_pipe_is_dir_in(pipe) ? DMA_FROM_DEVICE : DMA_TO_DEVICE;
>  
> -	if (map)
> -		return usbhsg_dma_map(dev, pkt, dir);
> -	else
> -		return usbhsg_dma_unmap(dev, pkt, dir);
> +	if (map) {
> +		return usb_gadget_map_request(&gpriv->gadget, req, dir);
> +	} else {
> +		usb_gadget_unmap_request(&gpriv->gadget, req, dir);
> +		return 0;
> +	}
>  }

I tried this patch, but renesas_usbhs didn't work.
It seems have some bugs.

1. renesas_usbhs dma needs pkt->dma, but this patch didn't care it.
2. dma direction seems wrong
   ("dir" needs 0/1, not DMA_xxx_DEVICE for usb_gadget_xx_request())

And, renesas_usbhs can not use scatter/gather type dma

#
# this is not super important, but
#
# int usb_gadget_map_request(struct usb_gadget *gadget,
#		struct usb_request *req, int direction)
#
# this "direction = 0/1" is a little bit un-understandable for me.
# it is difficult to understand "which direction ?" from code.
# if "direction = DMA_TO_DEVICE/DMA_FROM_DEVICE, it is understandable ;P
#

Can you please add below fix patch ?
------------------------------------------------
diff --git a/drivers/usb/renesas_usbhs/mod_gadget.c b/drivers/usb/renesas_usbhs/mod_gadget.c
index cb92a1d..c467067 100644
--- a/drivers/usb/renesas_usbhs/mod_gadget.c
+++ b/drivers/usb/renesas_usbhs/mod_gadget.c
@@ -173,15 +173,32 @@ static int usbhsg_dma_map_ctrl(struct usbhs_pkt *pkt, int map)
 	struct usbhsg_uep *uep = usbhsg_pipe_to_uep(pipe);
 	struct usbhsg_gpriv *gpriv = usbhsg_uep_to_gpriv(uep);
 	enum dma_data_direction dir;
+	int ret;
 
-	dir = usbhs_pipe_is_dir_in(pipe) ? DMA_FROM_DEVICE : DMA_TO_DEVICE;
+	dir = !usbhs_pipe_is_dir_in(pipe);
 
 	if (map) {
-		return usb_gadget_map_request(&gpriv->gadget, req, dir);
+		if (req->num_sgs) /* it can not use scatter/gather */
+			return -EIO;
+
+		if (pkt->dma != DMA_ADDR_INVALID)
+			return -EIO;
+
+		ret = usb_gadget_map_request(&gpriv->gadget, req, dir);
+		if (ret < 0)
+			return ret;
+
+		pkt->dma = req->dma;
 	} else {
+		if (pkt->dma == DMA_ADDR_INVALID)
+			return -EIO;
+
 		usb_gadget_unmap_request(&gpriv->gadget, req, dir);
-		return 0;
+		ret = 0;
+		pkt->dma = DMA_ADDR_INVALID;
 	}
+
+	return ret;
 }
 
 /*
------------------------------------------------

Best regards
---
Kuninori Morimoto

Re: [PATCH 4/9] usb: renesas: gadget: use generic map/unmap routines

[Kuninori Morimoto]

Hi Felipe

Thank you for your hard work

> those routines have everything we need to map/unmap
> USB requests and it's better to use them.
> 
> Signed-off-by: Felipe Balbi <balbi-l0cyMroinI0@public.gmane.org>
> ---
>  drivers/usb/renesas_usbhs/mod_gadget.c |   60 ++++----------------------------
>  1 files changed, 7 insertions(+), 53 deletions(-)
> 
> diff --git a/drivers/usb/renesas_usbhs/mod_gadget.c b/drivers/usb/renesas_usbhs/mod_gadget.c
> index 528691d5f..cb92a1d 100644
> --- a/drivers/usb/renesas_usbhs/mod_gadget.c
> +++ b/drivers/usb/renesas_usbhs/mod_gadget.c
> @@ -165,69 +165,23 @@ static void usbhsg_queue_push(struct usbhsg_uep *uep,
>  /*
>   *		dma map/unmap
>   */
> -static int usbhsg_dma_map(struct device *dev,
> -			  struct usbhs_pkt *pkt,
> -			  enum dma_data_direction dir)
> -{
> -	struct usbhsg_request *ureq = usbhsg_pkt_to_ureq(pkt);
> -	struct usb_request *req = &ureq->req;
> -
> -	if (pkt->dma != DMA_ADDR_INVALID) {
> -		dev_err(dev, "dma is already mapped\n");
> -		return -EIO;
> -	}
> -
> -	if (req->dma == DMA_ADDR_INVALID) {
> -		pkt->dma = dma_map_single(dev, pkt->buf, pkt->length, dir);
> -	} else {
> -		dma_sync_single_for_device(dev, req->dma, req->length, dir);
> -		pkt->dma = req->dma;
> -	}
> -
> -	if (dma_mapping_error(dev, pkt->dma)) {
> -		dev_err(dev, "dma mapping error %llx\n", (u64)pkt->dma);
> -		return -EIO;
> -	}
> -
> -	return 0;
> -}
> -
> -static int usbhsg_dma_unmap(struct device *dev,
> -			    struct usbhs_pkt *pkt,
> -			    enum dma_data_direction dir)
> +static int usbhsg_dma_map_ctrl(struct usbhs_pkt *pkt, int map)
>  {
>  	struct usbhsg_request *ureq = usbhsg_pkt_to_ureq(pkt);
>  	struct usb_request *req = &ureq->req;
> -
> -	if (pkt->dma == DMA_ADDR_INVALID) {
> -		dev_err(dev, "dma is not mapped\n");
> -		return -EIO;
> -	}
> -
> -	if (req->dma == DMA_ADDR_INVALID)
> -		dma_unmap_single(dev, pkt->dma, pkt->length, dir);
> -	else
> -		dma_sync_single_for_cpu(dev, req->dma, req->length, dir);
> -
> -	pkt->dma = DMA_ADDR_INVALID;
> -
> -	return 0;
> -}
> -
> -static int usbhsg_dma_map_ctrl(struct usbhs_pkt *pkt, int map)
> -{
>  	struct usbhs_pipe *pipe = pkt->pipe;
>  	struct usbhsg_uep *uep = usbhsg_pipe_to_uep(pipe);
>  	struct usbhsg_gpriv *gpriv = usbhsg_uep_to_gpriv(uep);
> -	struct device *dev = usbhsg_gpriv_to_dev(gpriv);
>  	enum dma_data_direction dir;
>  
>  	dir = usbhs_pipe_is_dir_in(pipe) ? DMA_FROM_DEVICE : DMA_TO_DEVICE;
>  
> -	if (map)
> -		return usbhsg_dma_map(dev, pkt, dir);
> -	else
> -		return usbhsg_dma_unmap(dev, pkt, dir);
> +	if (map) {
> +		return usb_gadget_map_request(&gpriv->gadget, req, dir);
> +	} else {
> +		usb_gadget_unmap_request(&gpriv->gadget, req, dir);
> +		return 0;
> +	}
>  }

I tried this patch, but renesas_usbhs didn't work.
It seems have some bugs.

1. renesas_usbhs dma needs pkt->dma, but this patch didn't care it.
2. dma direction seems wrong
   ("dir" needs 0/1, not DMA_xxx_DEVICE for usb_gadget_xx_request())

And, renesas_usbhs can not use scatter/gather type dma

#
# this is not super important, but
#
# int usb_gadget_map_request(struct usb_gadget *gadget,
#		struct usb_request *req, int direction)
#
# this "direction = 0/1" is a little bit un-understandable for me.
# it is difficult to understand "which direction ?" from code.
# if "direction = DMA_TO_DEVICE/DMA_FROM_DEVICE, it is understandable ;P
#

Can you please add below fix patch ?
------------------------------------------------
diff --git a/drivers/usb/renesas_usbhs/mod_gadget.c b/drivers/usb/renesas_usbhs/mod_gadget.c
index cb92a1d..c467067 100644
--- a/drivers/usb/renesas_usbhs/mod_gadget.c
+++ b/drivers/usb/renesas_usbhs/mod_gadget.c
@@ -173,15 +173,32 @@ static int usbhsg_dma_map_ctrl(struct usbhs_pkt *pkt, int map)
 	struct usbhsg_uep *uep = usbhsg_pipe_to_uep(pipe);
 	struct usbhsg_gpriv *gpriv = usbhsg_uep_to_gpriv(uep);
 	enum dma_data_direction dir;
+	int ret;
 
-	dir = usbhs_pipe_is_dir_in(pipe) ? DMA_FROM_DEVICE : DMA_TO_DEVICE;
+	dir = !usbhs_pipe_is_dir_in(pipe);
 
 	if (map) {
-		return usb_gadget_map_request(&gpriv->gadget, req, dir);
+		if (req->num_sgs) /* it can not use scatter/gather */
+			return -EIO;
+
+		if (pkt->dma != DMA_ADDR_INVALID)
+			return -EIO;
+
+		ret = usb_gadget_map_request(&gpriv->gadget, req, dir);
+		if (ret < 0)
+			return ret;
+
+		pkt->dma = req->dma;
 	} else {
+		if (pkt->dma == DMA_ADDR_INVALID)
+			return -EIO;
+
 		usb_gadget_unmap_request(&gpriv->gadget, req, dir);
-		return 0;
+		ret = 0;
+		pkt->dma = DMA_ADDR_INVALID;
 	}
+
+	return ret;
 }
 
 /*
------------------------------------------------

Best regards
---
Kuninori Morimoto
--
To unsubscribe from this list: send the line "unsubscribe linux-usb" in
the body of a message to majordomo-u79uwXL29TY76Z2rM5mHXA@public.gmane.org
More majordomo info at  http://vger.kernel.org/majordomo-info.html

Re: [PATCH 4/9] usb: renesas: gadget: use generic map/unmap routines

[Felipe Balbi]

[-- Attachment #1: Type: text/plain, Size: 2426 bytes --]

Hi,

On Mon, Dec 19, 2011 at 05:46:56PM -0800, Kuninori Morimoto wrote:
> I tried this patch, but renesas_usbhs didn't work.
> It seems have some bugs.
> 
> 1. renesas_usbhs dma needs pkt->dma, but this patch didn't care it.
> 2. dma direction seems wrong
>    ("dir" needs 0/1, not DMA_xxx_DEVICE for usb_gadget_xx_request())
> 
> And, renesas_usbhs can not use scatter/gather type dma
> 
> #
> # this is not super important, but
> #
> # int usb_gadget_map_request(struct usb_gadget *gadget,
> #		struct usb_request *req, int direction)
> #
> # this "direction = 0/1" is a little bit un-understandable for me.
> # it is difficult to understand "which direction ?" from code.
> # if "direction = DMA_TO_DEVICE/DMA_FROM_DEVICE, it is understandable ;P

I see. The thing is that we want usb_gadget_map/unmap_request() to
handle that. In the long run, we might want to have a direction flag on
the public struct usb_request and remove this extra parameter, but I'm
still considering that :-)

> Can you please add below fix patch ?

thanks, will do as soon as you fix below :-)

> ------------------------------------------------
> diff --git a/drivers/usb/renesas_usbhs/mod_gadget.c b/drivers/usb/renesas_usbhs/mod_gadget.c
> index cb92a1d..c467067 100644
> --- a/drivers/usb/renesas_usbhs/mod_gadget.c
> +++ b/drivers/usb/renesas_usbhs/mod_gadget.c
> @@ -173,15 +173,32 @@ static int usbhsg_dma_map_ctrl(struct usbhs_pkt *pkt, int map)
>  	struct usbhsg_uep *uep = usbhsg_pipe_to_uep(pipe);
>  	struct usbhsg_gpriv *gpriv = usbhsg_uep_to_gpriv(uep);
>  	enum dma_data_direction dir;
> +	int ret;
>  
> -	dir = usbhs_pipe_is_dir_in(pipe) ? DMA_FROM_DEVICE : DMA_TO_DEVICE;
> +	dir = !usbhs_pipe_is_dir_in(pipe);
>  
>  	if (map) {
> -		return usb_gadget_map_request(&gpriv->gadget, req, dir);
> +		if (req->num_sgs) /* it can not use scatter/gather */
> +			return -EIO;

it would be better to through a big fat WARN() in this case. Gadget
drivers are supposed to check whether you support SGs (by looking into
gadget->sg_suported) before giving you a request with SGs.

> +		if (pkt->dma != DMA_ADDR_INVALID)
> +			return -EIO;

no no, we want to remove the whole DMA_ADDR_INVALID thing. What we're
doing now is that UDC is required to map the request buffer. So gadget
drivers must not do it. We shouldn't have this DMA_ADDR_INVALID macro
anymore :-)

-- 
balbi

[-- Attachment #2: Digital signature --]
[-- Type: application/pgp-signature, Size: 836 bytes --]

Re: [PATCH 4/9] usb: renesas: gadget: use generic map/unmap routines

[Kuninori Morimoto]

Hi Felipe

Thank you for your hard work

> those routines have everything we need to map/unmap
> USB requests and it's better to use them.
> 
> Signed-off-by: Felipe Balbi <balbi@ti.com>
> ---
>  drivers/usb/renesas_usbhs/mod_gadget.c |   60 ++++----------------------------
>  1 files changed, 7 insertions(+), 53 deletions(-)
> 
> diff --git a/drivers/usb/renesas_usbhs/mod_gadget.c b/drivers/usb/renesas_usbhs/mod_gadget.c
> index 528691d5f..cb92a1d 100644
> --- a/drivers/usb/renesas_usbhs/mod_gadget.c
> +++ b/drivers/usb/renesas_usbhs/mod_gadget.c
> @@ -165,69 +165,23 @@ static void usbhsg_queue_push(struct usbhsg_uep *uep,
>  /*
>   *		dma map/unmap
>   */
> -static int usbhsg_dma_map(struct device *dev,
> -			  struct usbhs_pkt *pkt,
> -			  enum dma_data_direction dir)
> -{
> -	struct usbhsg_request *ureq = usbhsg_pkt_to_ureq(pkt);
> -	struct usb_request *req = &ureq->req;
> -
> -	if (pkt->dma != DMA_ADDR_INVALID) {
> -		dev_err(dev, "dma is already mapped\n");
> -		return -EIO;
> -	}
> -
> -	if (req->dma == DMA_ADDR_INVALID) {
> -		pkt->dma = dma_map_single(dev, pkt->buf, pkt->length, dir);
> -	} else {
> -		dma_sync_single_for_device(dev, req->dma, req->length, dir);
> -		pkt->dma = req->dma;
> -	}
> -
> -	if (dma_mapping_error(dev, pkt->dma)) {
> -		dev_err(dev, "dma mapping error %llx\n", (u64)pkt->dma);
> -		return -EIO;
> -	}
> -
> -	return 0;
> -}
> -
> -static int usbhsg_dma_unmap(struct device *dev,
> -			    struct usbhs_pkt *pkt,
> -			    enum dma_data_direction dir)
> +static int usbhsg_dma_map_ctrl(struct usbhs_pkt *pkt, int map)
>  {
>  	struct usbhsg_request *ureq = usbhsg_pkt_to_ureq(pkt);
>  	struct usb_request *req = &ureq->req;
> -
> -	if (pkt->dma == DMA_ADDR_INVALID) {
> -		dev_err(dev, "dma is not mapped\n");
> -		return -EIO;
> -	}
> -
> -	if (req->dma == DMA_ADDR_INVALID)
> -		dma_unmap_single(dev, pkt->dma, pkt->length, dir);
> -	else
> -		dma_sync_single_for_cpu(dev, req->dma, req->length, dir);
> -
> -	pkt->dma = DMA_ADDR_INVALID;
> -
> -	return 0;
> -}
> -
> -static int usbhsg_dma_map_ctrl(struct usbhs_pkt *pkt, int map)
> -{
>  	struct usbhs_pipe *pipe = pkt->pipe;
>  	struct usbhsg_uep *uep = usbhsg_pipe_to_uep(pipe);
>  	struct usbhsg_gpriv *gpriv = usbhsg_uep_to_gpriv(uep);
> -	struct device *dev = usbhsg_gpriv_to_dev(gpriv);
>  	enum dma_data_direction dir;
>  
>  	dir = usbhs_pipe_is_dir_in(pipe) ? DMA_FROM_DEVICE : DMA_TO_DEVICE;
>  
> -	if (map)
> -		return usbhsg_dma_map(dev, pkt, dir);
> -	else
> -		return usbhsg_dma_unmap(dev, pkt, dir);
> +	if (map) {
> +		return usb_gadget_map_request(&gpriv->gadget, req, dir);
> +	} else {
> +		usb_gadget_unmap_request(&gpriv->gadget, req, dir);
> +		return 0;
> +	}
>  }

I tried this patch, but renesas_usbhs didn't work.
It seems have some bugs.

1. renesas_usbhs dma needs pkt->dma, but this patch didn't care it.
2. dma direction seems wrong
   ("dir" needs 0/1, not DMA_xxx_DEVICE for usb_gadget_xx_request())

And, renesas_usbhs can not use scatter/gather type dma

#
# this is not super important, but
#
# int usb_gadget_map_request(struct usb_gadget *gadget,
#		struct usb_request *req, int direction)
#
# this "direction = 0/1" is a little bit un-understandable for me.
# it is difficult to understand "which direction ?" from code.
# if "direction = DMA_TO_DEVICE/DMA_FROM_DEVICE, it is understandable ;P
#

Can you please add below fix patch ?
------------------------------------------------
diff --git a/drivers/usb/renesas_usbhs/mod_gadget.c b/drivers/usb/renesas_usbhs/mod_gadget.c
index cb92a1d..c467067 100644
--- a/drivers/usb/renesas_usbhs/mod_gadget.c
+++ b/drivers/usb/renesas_usbhs/mod_gadget.c
@@ -173,15 +173,32 @@ static int usbhsg_dma_map_ctrl(struct usbhs_pkt *pkt, int map)
 	struct usbhsg_uep *uep = usbhsg_pipe_to_uep(pipe);
 	struct usbhsg_gpriv *gpriv = usbhsg_uep_to_gpriv(uep);
 	enum dma_data_direction dir;
+	int ret;
 
-	dir = usbhs_pipe_is_dir_in(pipe) ? DMA_FROM_DEVICE : DMA_TO_DEVICE;
+	dir = !usbhs_pipe_is_dir_in(pipe);
 
 	if (map) {
-		return usb_gadget_map_request(&gpriv->gadget, req, dir);
+		if (req->num_sgs) /* it can not use scatter/gather */
+			return -EIO;
+
+		if (pkt->dma != DMA_ADDR_INVALID)
+			return -EIO;
+
+		ret = usb_gadget_map_request(&gpriv->gadget, req, dir);
+		if (ret < 0)
+			return ret;
+
+		pkt->dma = req->dma;
 	} else {
+		if (pkt->dma == DMA_ADDR_INVALID)
+			return -EIO;
+
 		usb_gadget_unmap_request(&gpriv->gadget, req, dir);
-		return 0;
+		ret = 0;
+		pkt->dma = DMA_ADDR_INVALID;
 	}
+
+	return ret;
 }
 
 /*
------------------------------------------------

Best regards
---
Kuninori Morimoto

Re: [PATCH 4/9] usb: renesas: gadget: use generic map/unmap routines

[Kuninori Morimoto]

Hi Felipe

Thank you for your hard work

> those routines have everything we need to map/unmap
> USB requests and it's better to use them.
> 
> Signed-off-by: Felipe Balbi <balbi-l0cyMroinI0@public.gmane.org>
> ---
>  drivers/usb/renesas_usbhs/mod_gadget.c |   60 ++++----------------------------
>  1 files changed, 7 insertions(+), 53 deletions(-)
> 
> diff --git a/drivers/usb/renesas_usbhs/mod_gadget.c b/drivers/usb/renesas_usbhs/mod_gadget.c
> index 528691d5f..cb92a1d 100644
> --- a/drivers/usb/renesas_usbhs/mod_gadget.c
> +++ b/drivers/usb/renesas_usbhs/mod_gadget.c
> @@ -165,69 +165,23 @@ static void usbhsg_queue_push(struct usbhsg_uep *uep,
>  /*
>   *		dma map/unmap
>   */
> -static int usbhsg_dma_map(struct device *dev,
> -			  struct usbhs_pkt *pkt,
> -			  enum dma_data_direction dir)
> -{
> -	struct usbhsg_request *ureq = usbhsg_pkt_to_ureq(pkt);
> -	struct usb_request *req = &ureq->req;
> -
> -	if (pkt->dma != DMA_ADDR_INVALID) {
> -		dev_err(dev, "dma is already mapped\n");
> -		return -EIO;
> -	}
> -
> -	if (req->dma == DMA_ADDR_INVALID) {
> -		pkt->dma = dma_map_single(dev, pkt->buf, pkt->length, dir);
> -	} else {
> -		dma_sync_single_for_device(dev, req->dma, req->length, dir);
> -		pkt->dma = req->dma;
> -	}
> -
> -	if (dma_mapping_error(dev, pkt->dma)) {
> -		dev_err(dev, "dma mapping error %llx\n", (u64)pkt->dma);
> -		return -EIO;
> -	}
> -
> -	return 0;
> -}
> -
> -static int usbhsg_dma_unmap(struct device *dev,
> -			    struct usbhs_pkt *pkt,
> -			    enum dma_data_direction dir)
> +static int usbhsg_dma_map_ctrl(struct usbhs_pkt *pkt, int map)
>  {
>  	struct usbhsg_request *ureq = usbhsg_pkt_to_ureq(pkt);
>  	struct usb_request *req = &ureq->req;
> -
> -	if (pkt->dma == DMA_ADDR_INVALID) {
> -		dev_err(dev, "dma is not mapped\n");
> -		return -EIO;
> -	}
> -
> -	if (req->dma == DMA_ADDR_INVALID)
> -		dma_unmap_single(dev, pkt->dma, pkt->length, dir);
> -	else
> -		dma_sync_single_for_cpu(dev, req->dma, req->length, dir);
> -
> -	pkt->dma = DMA_ADDR_INVALID;
> -
> -	return 0;
> -}
> -
> -static int usbhsg_dma_map_ctrl(struct usbhs_pkt *pkt, int map)
> -{
>  	struct usbhs_pipe *pipe = pkt->pipe;
>  	struct usbhsg_uep *uep = usbhsg_pipe_to_uep(pipe);
>  	struct usbhsg_gpriv *gpriv = usbhsg_uep_to_gpriv(uep);
> -	struct device *dev = usbhsg_gpriv_to_dev(gpriv);
>  	enum dma_data_direction dir;
>  
>  	dir = usbhs_pipe_is_dir_in(pipe) ? DMA_FROM_DEVICE : DMA_TO_DEVICE;
>  
> -	if (map)
> -		return usbhsg_dma_map(dev, pkt, dir);
> -	else
> -		return usbhsg_dma_unmap(dev, pkt, dir);
> +	if (map) {
> +		return usb_gadget_map_request(&gpriv->gadget, req, dir);
> +	} else {
> +		usb_gadget_unmap_request(&gpriv->gadget, req, dir);
> +		return 0;
> +	}
>  }

I tried this patch, but renesas_usbhs didn't work.
It seems have some bugs.

1. renesas_usbhs dma needs pkt->dma, but this patch didn't care it.
2. dma direction seems wrong
   ("dir" needs 0/1, not DMA_xxx_DEVICE for usb_gadget_xx_request())

And, renesas_usbhs can not use scatter/gather type dma

#
# this is not super important, but
#
# int usb_gadget_map_request(struct usb_gadget *gadget,
#		struct usb_request *req, int direction)
#
# this "direction = 0/1" is a little bit un-understandable for me.
# it is difficult to understand "which direction ?" from code.
# if "direction = DMA_TO_DEVICE/DMA_FROM_DEVICE, it is understandable ;P
#

Can you please add below fix patch ?
------------------------------------------------
diff --git a/drivers/usb/renesas_usbhs/mod_gadget.c b/drivers/usb/renesas_usbhs/mod_gadget.c
index cb92a1d..c467067 100644
--- a/drivers/usb/renesas_usbhs/mod_gadget.c
+++ b/drivers/usb/renesas_usbhs/mod_gadget.c
@@ -173,15 +173,32 @@ static int usbhsg_dma_map_ctrl(struct usbhs_pkt *pkt, int map)
 	struct usbhsg_uep *uep = usbhsg_pipe_to_uep(pipe);
 	struct usbhsg_gpriv *gpriv = usbhsg_uep_to_gpriv(uep);
 	enum dma_data_direction dir;
+	int ret;
 
-	dir = usbhs_pipe_is_dir_in(pipe) ? DMA_FROM_DEVICE : DMA_TO_DEVICE;
+	dir = !usbhs_pipe_is_dir_in(pipe);
 
 	if (map) {
-		return usb_gadget_map_request(&gpriv->gadget, req, dir);
+		if (req->num_sgs) /* it can not use scatter/gather */
+			return -EIO;
+
+		if (pkt->dma != DMA_ADDR_INVALID)
+			return -EIO;
+
+		ret = usb_gadget_map_request(&gpriv->gadget, req, dir);
+		if (ret < 0)
+			return ret;
+
+		pkt->dma = req->dma;
 	} else {
+		if (pkt->dma == DMA_ADDR_INVALID)
+			return -EIO;
+
 		usb_gadget_unmap_request(&gpriv->gadget, req, dir);
-		return 0;
+		ret = 0;
+		pkt->dma = DMA_ADDR_INVALID;
 	}
+
+	return ret;
 }
 
 /*
------------------------------------------------

Best regards
---
Kuninori Morimoto
--
To unsubscribe from this list: send the line "unsubscribe linux-usb" in
the body of a message to majordomo-u79uwXL29TY76Z2rM5mHXA@public.gmane.org
More majordomo info at  http://vger.kernel.org/majordomo-info.html

[PATCH 5/9] usb: gadget: amd5536: use generic map/unmap routines

[Felipe Balbi]

those routines have everything we need to map/unmap
USB requests and it's better to use them.

Signed-off-by: Felipe Balbi <balbi@ti.com>
---
 drivers/usb/gadget/amd5536udc.c |   32 +++++---------------------------
 1 files changed, 5 insertions(+), 27 deletions(-)

diff --git a/drivers/usb/gadget/amd5536udc.c b/drivers/usb/gadget/amd5536udc.c
index e9a2c5c..d3d0282 100644
--- a/drivers/usb/gadget/amd5536udc.c
+++ b/drivers/usb/gadget/amd5536udc.c
@@ -831,20 +831,7 @@ __acquires(ep->dev->lock)
 
 	dev = ep->dev;
 	/* unmap DMA */
-	if (req->dma_mapping) {
-		if (ep->in)
-			pci_unmap_single(dev->pdev,
-					req->req.dma,
-					req->req.length,
-					PCI_DMA_TODEVICE);
-		else
-			pci_unmap_single(dev->pdev,
-					req->req.dma,
-					req->req.length,
-					PCI_DMA_FROMDEVICE);
-		req->dma_mapping = 0;
-		req->req.dma = DMA_DONT_USE;
-	}
+	usb_gadget_unmap_request(&dev->gadget, &req->req, ep->in);
 
 	halted = ep->halted;
 	ep->halted = 1;
@@ -1095,20 +1082,11 @@ udc_queue(struct usb_ep *usbep, struct usb_request *usbreq, gfp_t gfp)
 		return -ESHUTDOWN;
 
 	/* map dma (usually done before) */
-	if (ep->dma && usbreq->length != 0
-			&& (usbreq->dma == DMA_DONT_USE || usbreq->dma == 0)) {
+	if (ep->dma) {
 		VDBG(dev, "DMA map req %p\n", req);
-		if (ep->in)
-			usbreq->dma = pci_map_single(dev->pdev,
-						usbreq->buf,
-						usbreq->length,
-						PCI_DMA_TODEVICE);
-		else
-			usbreq->dma = pci_map_single(dev->pdev,
-						usbreq->buf,
-						usbreq->length,
-						PCI_DMA_FROMDEVICE);
-		req->dma_mapping = 1;
+		retval = usb_gadget_map_request(&udc->gadget, &req->req, ep->in);
+		if (retval)
+			return retval;
 	}
 
 	VDBG(dev, "%s queue req %p, len %d req->td_data=%p buf %p\n",
-- 
1.7.8.rc3

[PATCH 5/9] usb: gadget: amd5536: use generic map/unmap routines

[Felipe Balbi]

those routines have everything we need to map/unmap
USB requests and it's better to use them.

Signed-off-by: Felipe Balbi <balbi@ti.com>
---
 drivers/usb/gadget/amd5536udc.c |   32 +++++---------------------------
 1 files changed, 5 insertions(+), 27 deletions(-)

diff --git a/drivers/usb/gadget/amd5536udc.c b/drivers/usb/gadget/amd5536udc.c
index e9a2c5c..d3d0282 100644
--- a/drivers/usb/gadget/amd5536udc.c
+++ b/drivers/usb/gadget/amd5536udc.c
@@ -831,20 +831,7 @@ __acquires(ep->dev->lock)
 
 	dev = ep->dev;
 	/* unmap DMA */
-	if (req->dma_mapping) {
-		if (ep->in)
-			pci_unmap_single(dev->pdev,
-					req->req.dma,
-					req->req.length,
-					PCI_DMA_TODEVICE);
-		else
-			pci_unmap_single(dev->pdev,
-					req->req.dma,
-					req->req.length,
-					PCI_DMA_FROMDEVICE);
-		req->dma_mapping = 0;
-		req->req.dma = DMA_DONT_USE;
-	}
+	usb_gadget_unmap_request(&dev->gadget, &req->req, ep->in);
 
 	halted = ep->halted;
 	ep->halted = 1;
@@ -1095,20 +1082,11 @@ udc_queue(struct usb_ep *usbep, struct usb_request *usbreq, gfp_t gfp)
 		return -ESHUTDOWN;
 
 	/* map dma (usually done before) */
-	if (ep->dma && usbreq->length != 0
-			&& (usbreq->dma == DMA_DONT_USE || usbreq->dma == 0)) {
+	if (ep->dma) {
 		VDBG(dev, "DMA map req %p\n", req);
-		if (ep->in)
-			usbreq->dma = pci_map_single(dev->pdev,
-						usbreq->buf,
-						usbreq->length,
-						PCI_DMA_TODEVICE);
-		else
-			usbreq->dma = pci_map_single(dev->pdev,
-						usbreq->buf,
-						usbreq->length,
-						PCI_DMA_FROMDEVICE);
-		req->dma_mapping = 1;
+		retval = usb_gadget_map_request(&udc->gadget, &req->req, ep->in);
+		if (retval)
+			return retval;
 	}
 
 	VDBG(dev, "%s queue req %p, len %d req->td_data=%p buf %p\n",
-- 
1.7.8.rc3

[PATCH 6/9] usb: gadget: r8a66597: use generic map/unmap routines

[Felipe Balbi]

those routines have everything we need to map/unmap
USB requests and it's better to use them.

Signed-off-by: Felipe Balbi <balbi@ti.com>
---
 drivers/usb/gadget/r8a66597-udc.c |   10 ++--------
 1 files changed, 2 insertions(+), 8 deletions(-)

diff --git a/drivers/usb/gadget/r8a66597-udc.c b/drivers/usb/gadget/r8a66597-udc.c
index f5b8d21..72a9a67 100644
--- a/drivers/usb/gadget/r8a66597-udc.c
+++ b/drivers/usb/gadget/r8a66597-udc.c
@@ -663,11 +663,7 @@ static int sudmac_alloc_channel(struct r8a66597 *r8a66597,
 	ep->fifoctr = D0FIFOCTR;
 
 	/* dma mapping */
-	req->req.dma = dma_map_single(r8a66597_to_dev(ep->r8a66597),
-				req->req.buf, req->req.length,
-				dma->dir ? DMA_TO_DEVICE : DMA_FROM_DEVICE);
-
-	return 0;
+	return usb_gadget_map_request(&r8a66597->gadget, &req->req, dma->dir);
 }
 
 static void sudmac_free_channel(struct r8a66597 *r8a66597,
@@ -677,9 +673,7 @@ static void sudmac_free_channel(struct r8a66597 *r8a66597,
 	if (!r8a66597_is_sudmac(r8a66597))
 		return;
 
-	dma_unmap_single(r8a66597_to_dev(ep->r8a66597),
-			 req->req.dma, req->req.length,
-			 ep->dma->dir ? DMA_TO_DEVICE : DMA_FROM_DEVICE);
+	usb_gadget_map_request(&r8a66597->gadget, &req->req, ep->dma->dir);
 
 	r8a66597_bclr(r8a66597, DREQE, ep->fifosel);
 	r8a66597_change_curpipe(r8a66597, 0, 0, ep->fifosel);
-- 
1.7.8.rc3

[PATCH 6/9] usb: gadget: r8a66597: use generic map/unmap routines

[Felipe Balbi]

those routines have everything we need to map/unmap
USB requests and it's better to use them.

Signed-off-by: Felipe Balbi <balbi@ti.com>
---
 drivers/usb/gadget/r8a66597-udc.c |   10 ++--------
 1 files changed, 2 insertions(+), 8 deletions(-)

diff --git a/drivers/usb/gadget/r8a66597-udc.c b/drivers/usb/gadget/r8a66597-udc.c
index f5b8d21..72a9a67 100644
--- a/drivers/usb/gadget/r8a66597-udc.c
+++ b/drivers/usb/gadget/r8a66597-udc.c
@@ -663,11 +663,7 @@ static int sudmac_alloc_channel(struct r8a66597 *r8a66597,
 	ep->fifoctr = D0FIFOCTR;
 
 	/* dma mapping */
-	req->req.dma = dma_map_single(r8a66597_to_dev(ep->r8a66597),
-				req->req.buf, req->req.length,
-				dma->dir ? DMA_TO_DEVICE : DMA_FROM_DEVICE);
-
-	return 0;
+	return usb_gadget_map_request(&r8a66597->gadget, &req->req, dma->dir);
 }
 
 static void sudmac_free_channel(struct r8a66597 *r8a66597,
@@ -677,9 +673,7 @@ static void sudmac_free_channel(struct r8a66597 *r8a66597,
 	if (!r8a66597_is_sudmac(r8a66597))
 		return;
 
-	dma_unmap_single(r8a66597_to_dev(ep->r8a66597),
-			 req->req.dma, req->req.length,
-			 ep->dma->dir ? DMA_TO_DEVICE : DMA_FROM_DEVICE);
+	usb_gadget_map_request(&r8a66597->gadget, &req->req, ep->dma->dir);
 
 	r8a66597_bclr(r8a66597, DREQE, ep->fifosel);
 	r8a66597_change_curpipe(r8a66597, 0, 0, ep->fifosel);
-- 
1.7.8.rc3

[PATCH 7/9] usb: gadget: net2272: use generic map/umap routines

[Felipe Balbi]

those routines have everything we need to map/unmap
USB requests and it's better to use them.

Signed-off-by: Felipe Balbi <balbi@ti.com>
---
 drivers/usb/gadget/net2272.c |   18 ++++++++----------
 1 files changed, 8 insertions(+), 10 deletions(-)

diff --git a/drivers/usb/gadget/net2272.c b/drivers/usb/gadget/net2272.c
index 4c81d54..db99d74 100644
--- a/drivers/usb/gadget/net2272.c
+++ b/drivers/usb/gadget/net2272.c
@@ -385,12 +385,9 @@ net2272_done(struct net2272_ep *ep, struct net2272_request *req, int status)
 		status = req->req.status;
 
 	dev = ep->dev;
-	if (use_dma && req->mapped) {
-		dma_unmap_single(dev->dev, req->req.dma, req->req.length,
-			ep->is_in ? DMA_TO_DEVICE : DMA_FROM_DEVICE);
-		req->req.dma = DMA_ADDR_INVALID;
-		req->mapped = 0;
-	}
+	if (use_dma)
+		usb_gadget_map_request(&dev->gadget, &req->req,
+				ep->is_in);
 
 	if (status && status != -ESHUTDOWN)
 		dev_vdbg(dev->dev, "complete %s req %p stat %d len %u/%u buf %p\n",
@@ -850,10 +847,11 @@ net2272_queue(struct usb_ep *_ep, struct usb_request *_req, gfp_t gfp_flags)
 		return -ESHUTDOWN;
 
 	/* set up dma mapping in case the caller didn't */
-	if (use_dma && ep->dma && _req->dma == DMA_ADDR_INVALID) {
-		_req->dma = dma_map_single(dev->dev, _req->buf, _req->length,
-			ep->is_in ? DMA_TO_DEVICE : DMA_FROM_DEVICE);
-		req->mapped = 1;
+	if (use_dma && ep->dma) {
+		status = usb_gadget_map_request(&dev->gadget, &req->req,
+				ep->is_in);
+		if (status)
+			return status;
 	}
 
 	dev_vdbg(dev->dev, "%s queue req %p, len %d buf %p dma %08llx %s\n",
-- 
1.7.8.rc3

[PATCH 7/9] usb: gadget: net2272: use generic map/umap routines

[Felipe Balbi]

those routines have everything we need to map/unmap
USB requests and it's better to use them.

Signed-off-by: Felipe Balbi <balbi@ti.com>
---
 drivers/usb/gadget/net2272.c |   18 ++++++++----------
 1 files changed, 8 insertions(+), 10 deletions(-)

diff --git a/drivers/usb/gadget/net2272.c b/drivers/usb/gadget/net2272.c
index 4c81d54..db99d74 100644
--- a/drivers/usb/gadget/net2272.c
+++ b/drivers/usb/gadget/net2272.c
@@ -385,12 +385,9 @@ net2272_done(struct net2272_ep *ep, struct net2272_request *req, int status)
 		status = req->req.status;
 
 	dev = ep->dev;
-	if (use_dma && req->mapped) {
-		dma_unmap_single(dev->dev, req->req.dma, req->req.length,
-			ep->is_in ? DMA_TO_DEVICE : DMA_FROM_DEVICE);
-		req->req.dma = DMA_ADDR_INVALID;
-		req->mapped = 0;
-	}
+	if (use_dma)
+		usb_gadget_map_request(&dev->gadget, &req->req,
+				ep->is_in);
 
 	if (status && status != -ESHUTDOWN)
 		dev_vdbg(dev->dev, "complete %s req %p stat %d len %u/%u buf %p\n",
@@ -850,10 +847,11 @@ net2272_queue(struct usb_ep *_ep, struct usb_request *_req, gfp_t gfp_flags)
 		return -ESHUTDOWN;
 
 	/* set up dma mapping in case the caller didn't */
-	if (use_dma && ep->dma && _req->dma == DMA_ADDR_INVALID) {
-		_req->dma = dma_map_single(dev->dev, _req->buf, _req->length,
-			ep->is_in ? DMA_TO_DEVICE : DMA_FROM_DEVICE);
-		req->mapped = 1;
+	if (use_dma && ep->dma) {
+		status = usb_gadget_map_request(&dev->gadget, &req->req,
+				ep->is_in);
+		if (status)
+			return status;
 	}
 
 	dev_vdbg(dev->dev, "%s queue req %p, len %d buf %p dma %08llx %s\n",
-- 
1.7.8.rc3

[PATCH 8/9] usb: gadget: net2280: use generic map/unmap routines

[Felipe Balbi]

those routines have everything we need to map/unmap
USB requests and it's better to use them.

Signed-off-by: Felipe Balbi <balbi@ti.com>
---
 drivers/usb/gadget/net2280.c |   19 +++++++++----------
 1 files changed, 9 insertions(+), 10 deletions(-)

diff --git a/drivers/usb/gadget/net2280.c b/drivers/usb/gadget/net2280.c
index cf1f364..59d4794 100644
--- a/drivers/usb/gadget/net2280.c
+++ b/drivers/usb/gadget/net2280.c
@@ -806,12 +806,8 @@ done (struct net2280_ep *ep, struct net2280_request *req, int status)
 		status = req->req.status;
 
 	dev = ep->dev;
-	if (req->mapped) {
-		pci_unmap_single (dev->pdev, req->req.dma, req->req.length,
-			ep->is_in ? PCI_DMA_TODEVICE : PCI_DMA_FROMDEVICE);
-		req->req.dma = DMA_ADDR_INVALID;
-		req->mapped = 0;
-	}
+	if (req->mapped)
+		usb_gadget_unmap_request(&dev->gadget, &req->req, ep->is_in);
 
 	if (status && status != -ESHUTDOWN)
 		VDEBUG (dev, "complete %s req %p stat %d len %u/%u\n",
@@ -857,10 +853,13 @@ net2280_queue (struct usb_ep *_ep, struct usb_request *_req, gfp_t gfp_flags)
 		return -EOPNOTSUPP;
 
 	/* set up dma mapping in case the caller didn't */
-	if (ep->dma && _req->dma == DMA_ADDR_INVALID) {
-		_req->dma = pci_map_single (dev->pdev, _req->buf, _req->length,
-			ep->is_in ? PCI_DMA_TODEVICE : PCI_DMA_FROMDEVICE);
-		req->mapped = 1;
+	if (ep->dma) {
+		int ret;
+
+		ret = usb_gadget_map_request(&dev->gadget, &req->req,
+				ep->is_in);
+		if (ret)
+			return ret;
 	}
 
 #if 0
-- 
1.7.8.rc3

[PATCH 8/9] usb: gadget: net2280: use generic map/unmap routines

[Felipe Balbi]

those routines have everything we need to map/unmap
USB requests and it's better to use them.

Signed-off-by: Felipe Balbi <balbi@ti.com>
---
 drivers/usb/gadget/net2280.c |   19 +++++++++----------
 1 files changed, 9 insertions(+), 10 deletions(-)

diff --git a/drivers/usb/gadget/net2280.c b/drivers/usb/gadget/net2280.c
index cf1f364..59d4794 100644
--- a/drivers/usb/gadget/net2280.c
+++ b/drivers/usb/gadget/net2280.c
@@ -806,12 +806,8 @@ done (struct net2280_ep *ep, struct net2280_request *req, int status)
 		status = req->req.status;
 
 	dev = ep->dev;
-	if (req->mapped) {
-		pci_unmap_single (dev->pdev, req->req.dma, req->req.length,
-			ep->is_in ? PCI_DMA_TODEVICE : PCI_DMA_FROMDEVICE);
-		req->req.dma = DMA_ADDR_INVALID;
-		req->mapped = 0;
-	}
+	if (req->mapped)
+		usb_gadget_unmap_request(&dev->gadget, &req->req, ep->is_in);
 
 	if (status && status != -ESHUTDOWN)
 		VDEBUG (dev, "complete %s req %p stat %d len %u/%u\n",
@@ -857,10 +853,13 @@ net2280_queue (struct usb_ep *_ep, struct usb_request *_req, gfp_t gfp_flags)
 		return -EOPNOTSUPP;
 
 	/* set up dma mapping in case the caller didn't */
-	if (ep->dma && _req->dma == DMA_ADDR_INVALID) {
-		_req->dma = pci_map_single (dev->pdev, _req->buf, _req->length,
-			ep->is_in ? PCI_DMA_TODEVICE : PCI_DMA_FROMDEVICE);
-		req->mapped = 1;
+	if (ep->dma) {
+		int ret;
+
+		ret = usb_gadget_map_request(&dev->gadget, &req->req,
+				ep->is_in);
+		if (ret)
+			return ret;
 	}
 
 #if 0
-- 
1.7.8.rc3

Re: [PATCH 8/9] usb: gadget: net2280: use generic map/unmap routines

[Alan Stern]

On Mon, 19 Dec 2011, Felipe Balbi wrote:

> those routines have everything we need to map/unmap
> USB requests and it's better to use them.
> 
> Signed-off-by: Felipe Balbi <balbi@ti.com>
> ---
>  drivers/usb/gadget/net2280.c |   19 +++++++++----------
>  1 files changed, 9 insertions(+), 10 deletions(-)
> 
> diff --git a/drivers/usb/gadget/net2280.c b/drivers/usb/gadget/net2280.c
> index cf1f364..59d4794 100644
> --- a/drivers/usb/gadget/net2280.c
> +++ b/drivers/usb/gadget/net2280.c

> @@ -857,10 +853,13 @@ net2280_queue (struct usb_ep *_ep, struct usb_request *_req, gfp_t gfp_flags)
>  		return -EOPNOTSUPP;
>  
>  	/* set up dma mapping in case the caller didn't */
> -	if (ep->dma && _req->dma == DMA_ADDR_INVALID) {
> -		_req->dma = pci_map_single (dev->pdev, _req->buf, _req->length,
> -			ep->is_in ? PCI_DMA_TODEVICE : PCI_DMA_FROMDEVICE);
> -		req->mapped = 1;
> +	if (ep->dma) {
> +		int ret;
> +
> +		ret = usb_gadget_map_request(&dev->gadget, &req->req,
> +				ep->is_in);

As mentioned for the goku patch, &req->req can be replaced by _req.

Alan Stern

Re: [PATCH 8/9] usb: gadget: net2280: use generic map/unmap routines

[Felipe Balbi]

[-- Attachment #1: Type: text/plain, Size: 1242 bytes --]

Hi,

On Mon, Dec 19, 2011 at 10:21:36AM -0500, Alan Stern wrote:
> On Mon, 19 Dec 2011, Felipe Balbi wrote:
> 
> > those routines have everything we need to map/unmap
> > USB requests and it's better to use them.
> > 
> > Signed-off-by: Felipe Balbi <balbi@ti.com>
> > ---
> >  drivers/usb/gadget/net2280.c |   19 +++++++++----------
> >  1 files changed, 9 insertions(+), 10 deletions(-)
> > 
> > diff --git a/drivers/usb/gadget/net2280.c b/drivers/usb/gadget/net2280.c
> > index cf1f364..59d4794 100644
> > --- a/drivers/usb/gadget/net2280.c
> > +++ b/drivers/usb/gadget/net2280.c
> 
> > @@ -857,10 +853,13 @@ net2280_queue (struct usb_ep *_ep, struct usb_request *_req, gfp_t gfp_flags)
> >  		return -EOPNOTSUPP;
> >  
> >  	/* set up dma mapping in case the caller didn't */
> > -	if (ep->dma && _req->dma == DMA_ADDR_INVALID) {
> > -		_req->dma = pci_map_single (dev->pdev, _req->buf, _req->length,
> > -			ep->is_in ? PCI_DMA_TODEVICE : PCI_DMA_FROMDEVICE);
> > -		req->mapped = 1;
> > +	if (ep->dma) {
> > +		int ret;
> > +
> > +		ret = usb_gadget_map_request(&dev->gadget, &req->req,
> > +				ep->is_in);
> 
> As mentioned for the goku patch, &req->req can be replaced by _req.

sure

-- 
balbi

[-- Attachment #2: Digital signature --]
[-- Type: application/pgp-signature, Size: 836 bytes --]

[PATCH 9/9] usb: gadget: goku: use generic map/unmap routines

[Felipe Balbi]

those routines have everything we need to map/unmap
USB requests and it's better to use them.

Signed-off-by: Felipe Balbi <balbi@ti.com>
---
 drivers/usb/gadget/goku_udc.c |   17 +++++++----------
 1 files changed, 7 insertions(+), 10 deletions(-)

diff --git a/drivers/usb/gadget/goku_udc.c b/drivers/usb/gadget/goku_udc.c
index 5af70fcc..bc47735 100644
--- a/drivers/usb/gadget/goku_udc.c
+++ b/drivers/usb/gadget/goku_udc.c
@@ -310,12 +310,8 @@ done(struct goku_ep *ep, struct goku_request *req, int status)
 		status = req->req.status;
 
 	dev = ep->dev;
-	if (req->mapped) {
-		pci_unmap_single(dev->pdev, req->req.dma, req->req.length,
-			ep->is_in ? PCI_DMA_TODEVICE : PCI_DMA_FROMDEVICE);
-		req->req.dma = DMA_ADDR_INVALID;
-		req->mapped = 0;
-	}
+	if (req->mapped)
+		usb_gadget_unmap_request(&dev->gadget, &req->req, ep->is_in);
 
 #ifndef USB_TRACE
 	if (status && status != -ESHUTDOWN)
@@ -736,10 +732,11 @@ goku_queue(struct usb_ep *_ep, struct usb_request *_req, gfp_t gfp_flags)
 		return -EBUSY;
 
 	/* set up dma mapping in case the caller didn't */
-	if (ep->dma && _req->dma == DMA_ADDR_INVALID) {
-		_req->dma = pci_map_single(dev->pdev, _req->buf, _req->length,
-			ep->is_in ? PCI_DMA_TODEVICE : PCI_DMA_FROMDEVICE);
-		req->mapped = 1;
+	if (ep->dma) {
+		status = usb_gadget_map_request(&dev->gadget, &req->req,
+				ep->is_in);
+		if (status)
+			return status;
 	}
 
 #ifdef USB_TRACE
-- 
1.7.8.rc3

[PATCH 9/9] usb: gadget: goku: use generic map/unmap routines

[Felipe Balbi]

those routines have everything we need to map/unmap
USB requests and it's better to use them.

Signed-off-by: Felipe Balbi <balbi@ti.com>
---
 drivers/usb/gadget/goku_udc.c |   17 +++++++----------
 1 files changed, 7 insertions(+), 10 deletions(-)

diff --git a/drivers/usb/gadget/goku_udc.c b/drivers/usb/gadget/goku_udc.c
index 5af70fcc..bc47735 100644
--- a/drivers/usb/gadget/goku_udc.c
+++ b/drivers/usb/gadget/goku_udc.c
@@ -310,12 +310,8 @@ done(struct goku_ep *ep, struct goku_request *req, int status)
 		status = req->req.status;
 
 	dev = ep->dev;
-	if (req->mapped) {
-		pci_unmap_single(dev->pdev, req->req.dma, req->req.length,
-			ep->is_in ? PCI_DMA_TODEVICE : PCI_DMA_FROMDEVICE);
-		req->req.dma = DMA_ADDR_INVALID;
-		req->mapped = 0;
-	}
+	if (req->mapped)
+		usb_gadget_unmap_request(&dev->gadget, &req->req, ep->is_in);
 
 #ifndef USB_TRACE
 	if (status && status != -ESHUTDOWN)
@@ -736,10 +732,11 @@ goku_queue(struct usb_ep *_ep, struct usb_request *_req, gfp_t gfp_flags)
 		return -EBUSY;
 
 	/* set up dma mapping in case the caller didn't */
-	if (ep->dma && _req->dma == DMA_ADDR_INVALID) {
-		_req->dma = pci_map_single(dev->pdev, _req->buf, _req->length,
-			ep->is_in ? PCI_DMA_TODEVICE : PCI_DMA_FROMDEVICE);
-		req->mapped = 1;
+	if (ep->dma) {
+		status = usb_gadget_map_request(&dev->gadget, &req->req,
+				ep->is_in);
+		if (status)
+			return status;
 	}
 
 #ifdef USB_TRACE
-- 
1.7.8.rc3

Re: [PATCH 9/9] usb: gadget: goku: use generic map/unmap routines

[Sergei Shtylyov]

Hello.

On 19-12-2011 14:30, Felipe Balbi wrote:

> those routines have everything we need to map/unmap
> USB requests and it's better to use them.

> Signed-off-by: Felipe Balbi<balbi@ti.com>
> ---
>   drivers/usb/gadget/goku_udc.c |   17 +++++++----------
>   1 files changed, 7 insertions(+), 10 deletions(-)

> diff --git a/drivers/usb/gadget/goku_udc.c b/drivers/usb/gadget/goku_udc.c
> index 5af70fcc..bc47735 100644
> --- a/drivers/usb/gadget/goku_udc.c
> +++ b/drivers/usb/gadget/goku_udc.c
[...]
> @@ -736,10 +732,11 @@ goku_queue(struct usb_ep *_ep, struct usb_request *_req, gfp_t gfp_flags)
>   		return -EBUSY;
>
>   	/* set up dma mapping in case the caller didn't */
> -	if (ep->dma&&  _req->dma == DMA_ADDR_INVALID) {
> -		_req->dma = pci_map_single(dev->pdev, _req->buf, _req->length,
> -			ep->is_in ? PCI_DMA_TODEVICE : PCI_DMA_FROMDEVICE);
> -		req->mapped = 1;
> +	if (ep->dma) {
> +		status = usb_gadget_map_request(&dev->gadget, &req->req,

    Not '&_req->req'?

WBR, Sergei

Re: [PATCH 9/9] usb: gadget: goku: use generic map/unmap routines

[Sergei Shtylyov]

Hello.

On 19-12-2011 14:30, Felipe Balbi wrote:

> those routines have everything we need to map/unmap
> USB requests and it's better to use them.

> Signed-off-by: Felipe Balbi<balbi-l0cyMroinI0@public.gmane.org>
> ---
>   drivers/usb/gadget/goku_udc.c |   17 +++++++----------
>   1 files changed, 7 insertions(+), 10 deletions(-)

> diff --git a/drivers/usb/gadget/goku_udc.c b/drivers/usb/gadget/goku_udc.c
> index 5af70fcc..bc47735 100644
> --- a/drivers/usb/gadget/goku_udc.c
> +++ b/drivers/usb/gadget/goku_udc.c
[...]
> @@ -736,10 +732,11 @@ goku_queue(struct usb_ep *_ep, struct usb_request *_req, gfp_t gfp_flags)
>   		return -EBUSY;
>
>   	/* set up dma mapping in case the caller didn't */
> -	if (ep->dma&&  _req->dma == DMA_ADDR_INVALID) {
> -		_req->dma = pci_map_single(dev->pdev, _req->buf, _req->length,
> -			ep->is_in ? PCI_DMA_TODEVICE : PCI_DMA_FROMDEVICE);
> -		req->mapped = 1;
> +	if (ep->dma) {
> +		status = usb_gadget_map_request(&dev->gadget, &req->req,

    Not '&_req->req'?

WBR, Sergei
--
To unsubscribe from this list: send the line "unsubscribe linux-usb" in
the body of a message to majordomo-u79uwXL29TY76Z2rM5mHXA@public.gmane.org
More majordomo info at  http://vger.kernel.org/majordomo-info.html

Re: [PATCH 9/9] usb: gadget: goku: use generic map/unmap routines

[Sergei Shtylyov]

Hello.

On 19-12-2011 17:02, Sergei Shtylyov wrote:

>> those routines have everything we need to map/unmap
>> USB requests and it's better to use them.

>> Signed-off-by: Felipe Balbi<balbi@ti.com>
>> ---
>> drivers/usb/gadget/goku_udc.c | 17 +++++++----------
>> 1 files changed, 7 insertions(+), 10 deletions(-)

>> diff --git a/drivers/usb/gadget/goku_udc.c b/drivers/usb/gadget/goku_udc.c
>> index 5af70fcc..bc47735 100644
>> --- a/drivers/usb/gadget/goku_udc.c
>> +++ b/drivers/usb/gadget/goku_udc.c
> [...]
>> @@ -736,10 +732,11 @@ goku_queue(struct usb_ep *_ep, struct usb_request
>> *_req, gfp_t gfp_flags)
>> return -EBUSY;

>> /* set up dma mapping in case the caller didn't */
>> - if (ep->dma&& _req->dma == DMA_ADDR_INVALID) {
>> - _req->dma = pci_map_single(dev->pdev, _req->buf, _req->length,
>> - ep->is_in ? PCI_DMA_TODEVICE : PCI_DMA_FROMDEVICE);
>> - req->mapped = 1;
>> + if (ep->dma) {
>> + status = usb_gadget_map_request(&dev->gadget, &req->req,

> Not '&_req->req'?

    Or just '_req'?

WBR, Sergei

Re: [PATCH 9/9] usb: gadget: goku: use generic map/unmap routines

[Sergei Shtylyov]

Hello.

On 19-12-2011 17:02, Sergei Shtylyov wrote:

>> those routines have everything we need to map/unmap
>> USB requests and it's better to use them.

>> Signed-off-by: Felipe Balbi<balbi@ti.com>
>> ---
>> drivers/usb/gadget/goku_udc.c | 17 +++++++----------
>> 1 files changed, 7 insertions(+), 10 deletions(-)

>> diff --git a/drivers/usb/gadget/goku_udc.c b/drivers/usb/gadget/goku_udc.c
>> index 5af70fcc..bc47735 100644
>> --- a/drivers/usb/gadget/goku_udc.c
>> +++ b/drivers/usb/gadget/goku_udc.c
> [...]
>> @@ -736,10 +732,11 @@ goku_queue(struct usb_ep *_ep, struct usb_request
>> *_req, gfp_t gfp_flags)
>> return -EBUSY;

>> /* set up dma mapping in case the caller didn't */
>> - if (ep->dma&& _req->dma == DMA_ADDR_INVALID) {
>> - _req->dma = pci_map_single(dev->pdev, _req->buf, _req->length,
>> - ep->is_in ? PCI_DMA_TODEVICE : PCI_DMA_FROMDEVICE);
>> - req->mapped = 1;
>> + if (ep->dma) {
>> + status = usb_gadget_map_request(&dev->gadget, &req->req,

> Not '&_req->req'?

    Or just '_req'?

WBR, Sergei

Re: [PATCH 9/9] usb: gadget: goku: use generic map/unmap routines

[Felipe Balbi]

[-- Attachment #1: Type: text/plain, Size: 1306 bytes --]

On Mon, Dec 19, 2011 at 05:02:51PM +0400, Sergei Shtylyov wrote:
> Hello.
> 
> On 19-12-2011 14:30, Felipe Balbi wrote:
> 
> >those routines have everything we need to map/unmap
> >USB requests and it's better to use them.
> 
> >Signed-off-by: Felipe Balbi<balbi@ti.com>
> >---
> >  drivers/usb/gadget/goku_udc.c |   17 +++++++----------
> >  1 files changed, 7 insertions(+), 10 deletions(-)
> 
> >diff --git a/drivers/usb/gadget/goku_udc.c b/drivers/usb/gadget/goku_udc.c
> >index 5af70fcc..bc47735 100644
> >--- a/drivers/usb/gadget/goku_udc.c
> >+++ b/drivers/usb/gadget/goku_udc.c
> [...]
> >@@ -736,10 +732,11 @@ goku_queue(struct usb_ep *_ep, struct usb_request *_req, gfp_t gfp_flags)
> >  		return -EBUSY;
> >
> >  	/* set up dma mapping in case the caller didn't */
> >-	if (ep->dma&&  _req->dma == DMA_ADDR_INVALID) {
> >-		_req->dma = pci_map_single(dev->pdev, _req->buf, _req->length,
> >-			ep->is_in ? PCI_DMA_TODEVICE : PCI_DMA_FROMDEVICE);
> >-		req->mapped = 1;
> >+	if (ep->dma) {
> >+		status = usb_gadget_map_request(&dev->gadget, &req->req,
> 
>    Not '&_req->req'?

of course not. _req is the usb_request not Goku's internal
representation. I could change that to:

	usb_gadget_map_request(&dev->gadget, _req, ep->is_in);

though.

-- 
balbi

[-- Attachment #2: Digital signature --]
[-- Type: application/pgp-signature, Size: 836 bytes --]

Re: [PATCH 9/9] usb: gadget: goku: use generic map/unmap routines

[Felipe Balbi]

[-- Attachment #1: Type: text/plain, Size: 1306 bytes --]

On Mon, Dec 19, 2011 at 05:02:51PM +0400, Sergei Shtylyov wrote:
> Hello.
> 
> On 19-12-2011 14:30, Felipe Balbi wrote:
> 
> >those routines have everything we need to map/unmap
> >USB requests and it's better to use them.
> 
> >Signed-off-by: Felipe Balbi<balbi@ti.com>
> >---
> >  drivers/usb/gadget/goku_udc.c |   17 +++++++----------
> >  1 files changed, 7 insertions(+), 10 deletions(-)
> 
> >diff --git a/drivers/usb/gadget/goku_udc.c b/drivers/usb/gadget/goku_udc.c
> >index 5af70fcc..bc47735 100644
> >--- a/drivers/usb/gadget/goku_udc.c
> >+++ b/drivers/usb/gadget/goku_udc.c
> [...]
> >@@ -736,10 +732,11 @@ goku_queue(struct usb_ep *_ep, struct usb_request *_req, gfp_t gfp_flags)
> >  		return -EBUSY;
> >
> >  	/* set up dma mapping in case the caller didn't */
> >-	if (ep->dma&&  _req->dma == DMA_ADDR_INVALID) {
> >-		_req->dma = pci_map_single(dev->pdev, _req->buf, _req->length,
> >-			ep->is_in ? PCI_DMA_TODEVICE : PCI_DMA_FROMDEVICE);
> >-		req->mapped = 1;
> >+	if (ep->dma) {
> >+		status = usb_gadget_map_request(&dev->gadget, &req->req,
> 
>    Not '&_req->req'?

of course not. _req is the usb_request not Goku's internal
representation. I could change that to:

	usb_gadget_map_request(&dev->gadget, _req, ep->is_in);

though.

-- 
balbi

[-- Attachment #2: Digital signature --]
[-- Type: application/pgp-signature, Size: 836 bytes --]

Re: [PATCH 9/9] usb: gadget: goku: use generic map/unmap routines

[Sergei Shtylyov]

Hello.

On 19-12-2011 17:09, Felipe Balbi wrote:

>> On 19-12-2011 14:30, Felipe Balbi wrote:

>>> those routines have everything we need to map/unmap
>>> USB requests and it's better to use them.

>>> Signed-off-by: Felipe Balbi<balbi@ti.com>
>>> ---
>>>   drivers/usb/gadget/goku_udc.c |   17 +++++++----------
>>>   1 files changed, 7 insertions(+), 10 deletions(-)

>>> diff --git a/drivers/usb/gadget/goku_udc.c b/drivers/usb/gadget/goku_udc.c
>>> index 5af70fcc..bc47735 100644
>>> --- a/drivers/usb/gadget/goku_udc.c
>>> +++ b/drivers/usb/gadget/goku_udc.c
>> [...]
>>> @@ -736,10 +732,11 @@ goku_queue(struct usb_ep *_ep, struct usb_request *_req, gfp_t gfp_flags)
>>>   		return -EBUSY;
>>>
>>>   	/* set up dma mapping in case the caller didn't */
>>> -	if (ep->dma&&   _req->dma == DMA_ADDR_INVALID) {
>>> -		_req->dma = pci_map_single(dev->pdev, _req->buf, _req->length,
>>> -			ep->is_in ? PCI_DMA_TODEVICE : PCI_DMA_FROMDEVICE);
>>> -		req->mapped = 1;
>>> +	if (ep->dma) {
>>> +		status = usb_gadget_map_request(&dev->gadget,&req->req,

>>     Not '&_req->req'?

> of course not. _req is the usb_request not Goku's internal
> representation. I could change that to:

> 	usb_gadget_map_request(&dev->gadget, _req, ep->is_in);

> though.

    Yes, I've corrected myself already.

WBR, Sergei

Re: [PATCH 9/9] usb: gadget: goku: use generic map/unmap routines

[Sergei Shtylyov]

Hello.

On 19-12-2011 17:09, Felipe Balbi wrote:

>> On 19-12-2011 14:30, Felipe Balbi wrote:

>>> those routines have everything we need to map/unmap
>>> USB requests and it's better to use them.

>>> Signed-off-by: Felipe Balbi<balbi@ti.com>
>>> ---
>>>   drivers/usb/gadget/goku_udc.c |   17 +++++++----------
>>>   1 files changed, 7 insertions(+), 10 deletions(-)

>>> diff --git a/drivers/usb/gadget/goku_udc.c b/drivers/usb/gadget/goku_udc.c
>>> index 5af70fcc..bc47735 100644
>>> --- a/drivers/usb/gadget/goku_udc.c
>>> +++ b/drivers/usb/gadget/goku_udc.c
>> [...]
>>> @@ -736,10 +732,11 @@ goku_queue(struct usb_ep *_ep, struct usb_request *_req, gfp_t gfp_flags)
>>>   		return -EBUSY;
>>>
>>>   	/* set up dma mapping in case the caller didn't */
>>> -	if (ep->dma&&   _req->dma == DMA_ADDR_INVALID) {
>>> -		_req->dma = pci_map_single(dev->pdev, _req->buf, _req->length,
>>> -			ep->is_in ? PCI_DMA_TODEVICE : PCI_DMA_FROMDEVICE);
>>> -		req->mapped = 1;
>>> +	if (ep->dma) {
>>> +		status = usb_gadget_map_request(&dev->gadget,&req->req,

>>     Not '&_req->req'?

> of course not. _req is the usb_request not Goku's internal
> representation. I could change that to:

> 	usb_gadget_map_request(&dev->gadget, _req, ep->is_in);

> though.

    Yes, I've corrected myself already.

WBR, Sergei

[PATCH 0/9] usb: gadget: generic map/unmap routines

[Felipe Balbi]

Hi all,

here's a rebased version of generic map/unmap patchset.

Also available on generic-map-unmap branch of my tree, some
of the patches have been tested before and already have a
Tested-by tag.

Felipe Balbi (9):
  usb: gadget: add generic map/unmap request utilities
  usb: dwc3: gadget: use generic map/unmap routines
  usb: gadget: langwell: use generic map/unmap functions
  usb: renesas: gadget: use generic map/unmap routines
  usb: gadget: amd5536: use generic map/unmap routines
  usb: gadget: r8a66597: use generic map/unmap routines
  usb: gadget: net2272: use generic map/umap routines
  usb: gadget: net2280: use generic map/unmap routines
  usb: gadget: goku: use generic map/unmap routines

 drivers/usb/dwc3/core.h                |    2 -
 drivers/usb/dwc3/ep0.c                 |   16 +++++-
 drivers/usb/dwc3/gadget.c              |   93 ++++++--------------------------
 drivers/usb/dwc3/gadget.h              |    2 -
 drivers/usb/gadget/amd5536udc.c        |   33 ++---------
 drivers/usb/gadget/goku_udc.c          |   18 +++----
 drivers/usb/gadget/langwell_udc.c      |   45 +++-------------
 drivers/usb/gadget/net2272.c           |   18 +++----
 drivers/usb/gadget/net2280.c           |   19 +++----
 drivers/usb/gadget/r8a66597-udc.c      |   10 +---
 drivers/usb/gadget/udc-core.c          |   52 ++++++++++++++++++
 drivers/usb/renesas_usbhs/mod_gadget.c |   73 ++++++-------------------
 include/linux/usb/gadget.h             |   10 ++++
 13 files changed, 149 insertions(+), 242 deletions(-)

-- 
1.7.8.2

[PATCH 5/9] usb: gadget: amd5536: use generic map/unmap routines

[Felipe Balbi]

those routines have everything we need to map/unmap
USB requests and it's better to use them.

Signed-off-by: Felipe Balbi <balbi@ti.com>
---
 drivers/usb/gadget/amd5536udc.c |   33 ++++++---------------------------
 1 files changed, 6 insertions(+), 27 deletions(-)

diff --git a/drivers/usb/gadget/amd5536udc.c b/drivers/usb/gadget/amd5536udc.c
index c16ff55..e0ad9ee 100644
--- a/drivers/usb/gadget/amd5536udc.c
+++ b/drivers/usb/gadget/amd5536udc.c
@@ -831,20 +831,8 @@ __acquires(ep->dev->lock)
 
 	dev = ep->dev;
 	/* unmap DMA */
-	if (req->dma_mapping) {
-		if (ep->in)
-			pci_unmap_single(dev->pdev,
-					req->req.dma,
-					req->req.length,
-					PCI_DMA_TODEVICE);
-		else
-			pci_unmap_single(dev->pdev,
-					req->req.dma,
-					req->req.length,
-					PCI_DMA_FROMDEVICE);
-		req->dma_mapping = 0;
-		req->req.dma = DMA_DONT_USE;
-	}
+	if (ep->dma)
+		usb_gadget_unmap_request(&dev->gadget, &req->req, ep->in);
 
 	halted = ep->halted;
 	ep->halted = 1;
@@ -1095,20 +1083,11 @@ udc_queue(struct usb_ep *usbep, struct usb_request *usbreq, gfp_t gfp)
 		return -ESHUTDOWN;
 
 	/* map dma (usually done before) */
-	if (ep->dma && usbreq->length != 0
-			&& (usbreq->dma == DMA_DONT_USE || usbreq->dma == 0)) {
+	if (ep->dma) {
 		VDBG(dev, "DMA map req %p\n", req);
-		if (ep->in)
-			usbreq->dma = pci_map_single(dev->pdev,
-						usbreq->buf,
-						usbreq->length,
-						PCI_DMA_TODEVICE);
-		else
-			usbreq->dma = pci_map_single(dev->pdev,
-						usbreq->buf,
-						usbreq->length,
-						PCI_DMA_FROMDEVICE);
-		req->dma_mapping = 1;
+		retval = usb_gadget_map_request(&udc->gadget, usbreq, ep->in);
+		if (retval)
+			return retval;
 	}
 
 	VDBG(dev, "%s queue req %p, len %d req->td_data=%p buf %p\n",
-- 
1.7.8.2

[PATCH 5/9] usb: gadget: amd5536: use generic map/unmap routines

[Felipe Balbi]

those routines have everything we need to map/unmap
USB requests and it's better to use them.

Signed-off-by: Felipe Balbi <balbi@ti.com>
---
 drivers/usb/gadget/amd5536udc.c |   33 ++++++---------------------------
 1 files changed, 6 insertions(+), 27 deletions(-)

diff --git a/drivers/usb/gadget/amd5536udc.c b/drivers/usb/gadget/amd5536udc.c
index c16ff55..e0ad9ee 100644
--- a/drivers/usb/gadget/amd5536udc.c
+++ b/drivers/usb/gadget/amd5536udc.c
@@ -831,20 +831,8 @@ __acquires(ep->dev->lock)
 
 	dev = ep->dev;
 	/* unmap DMA */
-	if (req->dma_mapping) {
-		if (ep->in)
-			pci_unmap_single(dev->pdev,
-					req->req.dma,
-					req->req.length,
-					PCI_DMA_TODEVICE);
-		else
-			pci_unmap_single(dev->pdev,
-					req->req.dma,
-					req->req.length,
-					PCI_DMA_FROMDEVICE);
-		req->dma_mapping = 0;
-		req->req.dma = DMA_DONT_USE;
-	}
+	if (ep->dma)
+		usb_gadget_unmap_request(&dev->gadget, &req->req, ep->in);
 
 	halted = ep->halted;
 	ep->halted = 1;
@@ -1095,20 +1083,11 @@ udc_queue(struct usb_ep *usbep, struct usb_request *usbreq, gfp_t gfp)
 		return -ESHUTDOWN;
 
 	/* map dma (usually done before) */
-	if (ep->dma && usbreq->length != 0
-			&& (usbreq->dma == DMA_DONT_USE || usbreq->dma == 0)) {
+	if (ep->dma) {
 		VDBG(dev, "DMA map req %p\n", req);
-		if (ep->in)
-			usbreq->dma = pci_map_single(dev->pdev,
-						usbreq->buf,
-						usbreq->length,
-						PCI_DMA_TODEVICE);
-		else
-			usbreq->dma = pci_map_single(dev->pdev,
-						usbreq->buf,
-						usbreq->length,
-						PCI_DMA_FROMDEVICE);
-		req->dma_mapping = 1;
+		retval = usb_gadget_map_request(&udc->gadget, usbreq, ep->in);
+		if (retval)
+			return retval;
 	}
 
 	VDBG(dev, "%s queue req %p, len %d req->td_data=%p buf %p\n",
-- 
1.7.8.2