[U-Boot] [PATCH v5 0/2] common: usb_storage : Implement logic to calculate optimal

[U-Boot] [PATCH v5 0/2] common: usb_storage : Implement logic to calculate optimal

[Rajesh Bhagat]

Performs code cleanup by making common function for usb_stor_read/write
and implements the logic to calculate the optimal usb maximum trasfer blocks
instead of sending USB_MAX_XFER_BLK blocks which is 65535 and 20 in case
of EHCI and other USB protocols respectively.

Rajesh Bhagat (2):
  common: usb_storage: Make common function for    
    usb_stor_read/usb_stor_write
  common: usb_storage : Implement logic to calculate optimal usb
    maximum trasfer blocks

 common/usb_storage.c |  196 ++++++++++++++++++++++++++------------------------
 include/usb.h        |    1 +
 2 files changed, 103 insertions(+), 94 deletions(-)

-- 
1.7.7.4

[U-Boot] [PATCH v5 1/2] common: usb_storage: Make common function for usb_stor_read/usb_stor_write

[Rajesh Bhagat]

Performs code cleanup by making common function for usb_stor_read/
usb_stor_write. Currently only difference in these fucntions is call
to usb_read_10/usb_write_10 scsi commands.

Signed-off-by: Rajesh Bhagat <rajesh.bhagat@nxp.com>
---
Changes in v5:
 - Converts USB_STOR_OPERATION_FUNC macro to a function
 - Corrects the multi line comment accroding to coding style
 - Renames variable to dev to remove code duplication

Changes in v4:
 - Adds code to make common function for read/write

 common/usb_storage.c |  129 +++++++++++++++----------------------------------
 1 files changed, 40 insertions(+), 89 deletions(-)

diff --git a/common/usb_storage.c b/common/usb_storage.c
index 7e6e52d..f060637 100644
--- a/common/usb_storage.c
+++ b/common/usb_storage.c
@@ -1104,12 +1104,22 @@ static void usb_bin_fixup(struct usb_device_descriptor descriptor,
 }
 #endif /* CONFIG_USB_BIN_FIXUP */
 
+#define USB_STOR_OP_TYPE	(is_write ? "write" : "read")
+static int usb_stor_operation(ccb *srb, struct us_data *ss, unsigned long start,
+			      unsigned short blocks, bool is_write)
+{
+	return is_write ? usb_write_10(srb, ss, start, blocks) :
+		usb_read_10(srb, ss, start, blocks);
+}
+
 #ifdef CONFIG_BLK
-static unsigned long usb_stor_read(struct udevice *dev, lbaint_t blknr,
-				   lbaint_t blkcnt, void *buffer)
+static unsigned long usb_stor_read_write(struct udevice *dev, lbaint_t blknr,
+					 lbaint_t blkcnt, const void *buffer,
+					 bool is_write)
 #else
-static unsigned long usb_stor_read(struct blk_desc *block_dev, lbaint_t blknr,
-				   lbaint_t blkcnt, void *buffer)
+static unsigned long usb_stor_read_write(struct blk_desc *block_dev,
+					 lbaint_t blknr, lbaint_t blkcnt,
+					 const void *buffer, bool is_write)
 #endif
 {
 	lbaint_t start, blks;
@@ -1129,9 +1139,9 @@ static unsigned long usb_stor_read(struct blk_desc *block_dev, lbaint_t blknr,
 #ifdef CONFIG_BLK
 	block_dev = dev_get_uclass_platdata(dev);
 	udev = dev_get_parent_priv(dev_get_parent(dev));
-	debug("\nusb_read: udev %d\n", block_dev->devnum);
+	debug("\nusb_%s: udev %d\n", USB_STOR_OP_TYPE, block_dev->devnum);
 #else
-	debug("\nusb_read: udev %d\n", block_dev->devnum);
+	debug("\nusb_%s: udev %d\n", USB_STOR_OP_TYPE, block_dev->devnum);
 	udev = usb_dev_desc[block_dev->devnum].priv;
 	if (!udev) {
 		debug("%s: No device\n", __func__);
@@ -1146,11 +1156,15 @@ static unsigned long usb_stor_read(struct blk_desc *block_dev, lbaint_t blknr,
 	start = blknr;
 	blks = blkcnt;
 
-	debug("\nusb_read: dev %d startblk " LBAF ", blccnt " LBAF " buffer %"
-	      PRIxPTR "\n", block_dev->devnum, start, blks, buf_addr);
+	debug("\nusb_%s: dev %d startblk " LBAF ", blccnt " LBAF " buffer %"
+	      PRIxPTR "\n", USB_STOR_OP_TYPE, block_dev->devnum, start, blks,
+	      buf_addr);
 
 	do {
-		/* XXX need some comment here */
+		/*
+		 * If read/write fails retry for max retry count else
+		 * return with number of blocks written successfully.
+		 */
 		retry = 2;
 		srb->pdata = (unsigned char *)buf_addr;
 		if (blks > USB_MAX_XFER_BLK)
@@ -1162,8 +1176,8 @@ retry_it:
 			usb_show_progress();
 		srb->datalen = block_dev->blksz * smallblks;
 		srb->pdata = (unsigned char *)buf_addr;
-		if (usb_read_10(srb, ss, start, smallblks)) {
-			debug("Read ERROR\n");
+		if (usb_stor_operation(srb, ss, start, smallblks, is_write)) {
+			debug("%s ERROR\n", USB_STOR_OP_TYPE);
 			usb_request_sense(srb, ss);
 			if (retry--)
 				goto retry_it;
@@ -1176,9 +1190,9 @@ retry_it:
 	} while (blks != 0);
 	ss->flags &= ~USB_READY;
 
-	debug("usb_read: end startblk " LBAF
+	debug("usb_%s: end startblk " LBAF
 	      ", blccnt %x buffer %" PRIxPTR "\n",
-	      start, smallblks, buf_addr);
+	      USB_STOR_OP_TYPE, start, smallblks, buf_addr);
 
 	usb_disable_asynch(0); /* asynch transfer allowed */
 	if (blkcnt >= USB_MAX_XFER_BLK)
@@ -1186,90 +1200,27 @@ retry_it:
 	return blkcnt;
 }
 
+
 #ifdef CONFIG_BLK
-static unsigned long usb_stor_write(struct udevice *dev, lbaint_t blknr,
-				    lbaint_t blkcnt, const void *buffer)
+static unsigned long usb_stor_read(struct udevice *dev, lbaint_t blknr,
+				   lbaint_t blkcnt, void *buffer)
 #else
-static unsigned long usb_stor_write(struct blk_desc *block_dev, lbaint_t blknr,
-				    lbaint_t blkcnt, const void *buffer)
+static unsigned long usb_stor_read(struct blk_desc *dev, lbaint_t blknr,
+				   lbaint_t blkcnt, void *buffer)
 #endif
 {
-	lbaint_t start, blks;
-	uintptr_t buf_addr;
-	unsigned short smallblks;
-	struct usb_device *udev;
-	struct us_data *ss;
-	int retry;
-	ccb *srb = &usb_ccb;
-#ifdef CONFIG_BLK
-	struct blk_desc *block_dev;
-#endif
-
-	if (blkcnt == 0)
-		return 0;
+	return usb_stor_read_write(dev, blknr, blkcnt, buffer, false);
+}
 
-	/* Setup  device */
 #ifdef CONFIG_BLK
-	block_dev = dev_get_uclass_platdata(dev);
-	udev = dev_get_parent_priv(dev_get_parent(dev));
-	debug("\nusb_read: udev %d\n", block_dev->devnum);
+static unsigned long usb_stor_write(struct udevice *dev, lbaint_t blknr,
+				    lbaint_t blkcnt, const void *buffer)
 #else
-	debug("\nusb_read: udev %d\n", block_dev->devnum);
-	udev = usb_dev_desc[block_dev->devnum].priv;
-	if (!udev) {
-		debug("%s: No device\n", __func__);
-		return 0;
-	}
+static unsigned long usb_stor_write(struct blk_desc *dev, lbaint_t blknr,
+				    lbaint_t blkcnt, const void *buffer)
 #endif
-	ss = (struct us_data *)udev->privptr;
-
-	usb_disable_asynch(1); /* asynch transfer not allowed */
-
-	srb->lun = block_dev->lun;
-	buf_addr = (uintptr_t)buffer;
-	start = blknr;
-	blks = blkcnt;
-
-	debug("\nusb_write: dev %d startblk " LBAF ", blccnt " LBAF " buffer %"
-	      PRIxPTR "\n", block_dev->devnum, start, blks, buf_addr);
-
-	do {
-		/* If write fails retry for max retry count else
-		 * return with number of blocks written successfully.
-		 */
-		retry = 2;
-		srb->pdata = (unsigned char *)buf_addr;
-		if (blks > USB_MAX_XFER_BLK)
-			smallblks = USB_MAX_XFER_BLK;
-		else
-			smallblks = (unsigned short) blks;
-retry_it:
-		if (smallblks == USB_MAX_XFER_BLK)
-			usb_show_progress();
-		srb->datalen = block_dev->blksz * smallblks;
-		srb->pdata = (unsigned char *)buf_addr;
-		if (usb_write_10(srb, ss, start, smallblks)) {
-			debug("Write ERROR\n");
-			usb_request_sense(srb, ss);
-			if (retry--)
-				goto retry_it;
-			blkcnt -= blks;
-			break;
-		}
-		start += smallblks;
-		blks -= smallblks;
-		buf_addr += srb->datalen;
-	} while (blks != 0);
-	ss->flags &= ~USB_READY;
-
-	debug("usb_write: end startblk " LBAF ", blccnt %x buffer %"
-	      PRIxPTR "\n", start, smallblks, buf_addr);
-
-	usb_disable_asynch(0); /* asynch transfer allowed */
-	if (blkcnt >= USB_MAX_XFER_BLK)
-		debug("\n");
-	return blkcnt;
-
+{
+	return usb_stor_read_write(dev, blknr, blkcnt, buffer, true);
 }
 
 /* Probe to see if a new device is actually a Storage device */
-- 
1.7.7.4

[U-Boot] [PATCH v5 1/2] common: usb_storage: Make common function for usb_stor_read/usb_stor_write

[Marek Vasut]

On 06/13/2016 06:03 AM, Rajesh Bhagat wrote:
> Performs code cleanup by making common function for usb_stor_read/
> usb_stor_write. Currently only difference in these fucntions is call
> to usb_read_10/usb_write_10 scsi commands.
> 
> Signed-off-by: Rajesh Bhagat <rajesh.bhagat@nxp.com>
> ---
> Changes in v5:
>  - Converts USB_STOR_OPERATION_FUNC macro to a function
>  - Corrects the multi line comment accroding to coding style
>  - Renames variable to dev to remove code duplication
> 
> Changes in v4:
>  - Adds code to make common function for read/write
> 
>  common/usb_storage.c |  129 +++++++++++++++----------------------------------
>  1 files changed, 40 insertions(+), 89 deletions(-)
> 
> diff --git a/common/usb_storage.c b/common/usb_storage.c
> index 7e6e52d..f060637 100644
> --- a/common/usb_storage.c
> +++ b/common/usb_storage.c
> @@ -1104,12 +1104,22 @@ static void usb_bin_fixup(struct usb_device_descriptor descriptor,
>  }
>  #endif /* CONFIG_USB_BIN_FIXUP */
>  
> +#define USB_STOR_OP_TYPE	(is_write ? "write" : "read")

I just noticed this gem here. It's a macro which uses a variable, but
the variable is not passed in as it's argument. Just inline this, it's
not worth having it as a macro here.

> +static int usb_stor_operation(ccb *srb, struct us_data *ss, unsigned long start,
> +			      unsigned short blocks, bool is_write)
> +{
> +	return is_write ? usb_write_10(srb, ss, start, blocks) :
> +		usb_read_10(srb, ss, start, blocks);

usb_read_10() and usb_write_10() look exactly the same for all but the
command . You should do this unification at that level instead.

> +}
> +
>  #ifdef CONFIG_BLK
> -static unsigned long usb_stor_read(struct udevice *dev, lbaint_t blknr,
> -				   lbaint_t blkcnt, void *buffer)
> +static unsigned long usb_stor_read_write(struct udevice *dev, lbaint_t blknr,
> +					 lbaint_t blkcnt, const void *buffer,
> +					 bool is_write)
>  #else
> -static unsigned long usb_stor_read(struct blk_desc *block_dev, lbaint_t blknr,
> -				   lbaint_t blkcnt, void *buffer)
> +static unsigned long usb_stor_read_write(struct blk_desc *block_dev,
> +					 lbaint_t blknr, lbaint_t blkcnt,
> +					 const void *buffer, bool is_write)
>  #endif
>  {
>  	lbaint_t start, blks;
> @@ -1129,9 +1139,9 @@ static unsigned long usb_stor_read(struct blk_desc *block_dev, lbaint_t blknr,
>  #ifdef CONFIG_BLK
>  	block_dev = dev_get_uclass_platdata(dev);
>  	udev = dev_get_parent_priv(dev_get_parent(dev));
> -	debug("\nusb_read: udev %d\n", block_dev->devnum);
> +	debug("\nusb_%s: udev %d\n", USB_STOR_OP_TYPE, block_dev->devnum);
>  #else
> -	debug("\nusb_read: udev %d\n", block_dev->devnum);
> +	debug("\nusb_%s: udev %d\n", USB_STOR_OP_TYPE, block_dev->devnum);

You can just use "\n%s: ..." and use __func__ instead of
USB_STOR_OP_TYPE here, that'd be less cryptic than "usb_read:" and it's
used all over the place already anyway.

>  	udev = usb_dev_desc[block_dev->devnum].priv;
>  	if (!udev) {
>  		debug("%s: No device\n", __func__);
> @@ -1146,11 +1156,15 @@ static unsigned long usb_stor_read(struct blk_desc *block_dev, lbaint_t blknr,
>  	start = blknr;
>  	blks = blkcnt;
>  
> -	debug("\nusb_read: dev %d startblk " LBAF ", blccnt " LBAF " buffer %"
> -	      PRIxPTR "\n", block_dev->devnum, start, blks, buf_addr);
> +	debug("\nusb_%s: dev %d startblk " LBAF ", blccnt " LBAF " buffer %"
> +	      PRIxPTR "\n", USB_STOR_OP_TYPE, block_dev->devnum, start, blks,
> +	      buf_addr);

DTTO here.

>  	do {
> -		/* XXX need some comment here */
> +		/*
> +		 * If read/write fails retry for max retry count else
> +		 * return with number of blocks written successfully.
> +		 */
>  		retry = 2;
>  		srb->pdata = (unsigned char *)buf_addr;
>  		if (blks > USB_MAX_XFER_BLK)
> @@ -1162,8 +1176,8 @@ retry_it:
>  			usb_show_progress();
>  		srb->datalen = block_dev->blksz * smallblks;
>  		srb->pdata = (unsigned char *)buf_addr;
> -		if (usb_read_10(srb, ss, start, smallblks)) {
> -			debug("Read ERROR\n");
> +		if (usb_stor_operation(srb, ss, start, smallblks, is_write)) {
> +			debug("%s ERROR\n", USB_STOR_OP_TYPE);
>  			usb_request_sense(srb, ss);
>  			if (retry--)
>  				goto retry_it;
> @@ -1176,9 +1190,9 @@ retry_it:
>  	} while (blks != 0);
>  	ss->flags &= ~USB_READY;
>  
> -	debug("usb_read: end startblk " LBAF
> +	debug("usb_%s: end startblk " LBAF
>  	      ", blccnt %x buffer %" PRIxPTR "\n",
> -	      start, smallblks, buf_addr);
> +	      USB_STOR_OP_TYPE, start, smallblks, buf_addr);
>  
>  	usb_disable_asynch(0); /* asynch transfer allowed */
>  	if (blkcnt >= USB_MAX_XFER_BLK)
> @@ -1186,90 +1200,27 @@ retry_it:
>  	return blkcnt;
>  }

[...]

-- 
Best regards,
Marek Vasut

[U-Boot] [PATCH v5 1/2] common: usb_storage: Make common function for usb_stor_read/usb_stor_write

[Rajesh Bhagat]

> -----Original Message-----
> From: Marek Vasut [mailto:marex at denx.de]
> Sent: Monday, June 13, 2016 7:00 PM
> To: Rajesh Bhagat <rajesh.bhagat@nxp.com>; u-boot at lists.denx.de
> Cc: sjg at chromium.org; york sun <york.sun@nxp.com>; Sriram Dash
> <sriram.dash@nxp.com>
> Subject: Re: [PATCH v5 1/2] common: usb_storage: Make common function for
> usb_stor_read/usb_stor_write
> 
> On 06/13/2016 06:03 AM, Rajesh Bhagat wrote:
> > Performs code cleanup by making common function for usb_stor_read/
> > usb_stor_write. Currently only difference in these fucntions is call
> > to usb_read_10/usb_write_10 scsi commands.
> >
> > Signed-off-by: Rajesh Bhagat <rajesh.bhagat@nxp.com>
> > ---
> > Changes in v5:
> >  - Converts USB_STOR_OPERATION_FUNC macro to a function
> >  - Corrects the multi line comment accroding to coding style
> >  - Renames variable to dev to remove code duplication
> >
> > Changes in v4:
> >  - Adds code to make common function for read/write
> >
> >  common/usb_storage.c |  129
> > +++++++++++++++----------------------------------
> >  1 files changed, 40 insertions(+), 89 deletions(-)
> >
> > diff --git a/common/usb_storage.c b/common/usb_storage.c index
> > 7e6e52d..f060637 100644
> > --- a/common/usb_storage.c
> > +++ b/common/usb_storage.c
> > @@ -1104,12 +1104,22 @@ static void usb_bin_fixup(struct
> > usb_device_descriptor descriptor,  }  #endif /* CONFIG_USB_BIN_FIXUP
> > */
> >
> > +#define USB_STOR_OP_TYPE	(is_write ? "write" : "read")
> 

Hello Marek, 

> I just noticed this gem here. It's a macro which uses a variable, but the variable is not
> passed in as it's argument. Just inline this, it's not worth having it as a macro here.
> 

Will take care in v6. As pointed in last comment, I will be using __func__ and remove this 
macro which was  just used to differentiate b/w read/write operations in debug logs. 

> > +static int usb_stor_operation(ccb *srb, struct us_data *ss, unsigned long start,
> > +			      unsigned short blocks, bool is_write) {
> > +	return is_write ? usb_write_10(srb, ss, start, blocks) :
> > +		usb_read_10(srb, ss, start, blocks);
> 
> usb_read_10() and usb_write_10() look exactly the same for all but the command .
> You should do this unification at that level instead.
> 

Will take care in v6. Will unify the code to usb_read_write_10 and add is_write parameter to 
process different command. And then it can be called directly instead of making a wrapper
function. 

> > +}
> > +
> >  #ifdef CONFIG_BLK
> > -static unsigned long usb_stor_read(struct udevice *dev, lbaint_t blknr,
> > -				   lbaint_t blkcnt, void *buffer)
> > +static unsigned long usb_stor_read_write(struct udevice *dev, lbaint_t blknr,
> > +					 lbaint_t blkcnt, const void *buffer,
> > +					 bool is_write)
> >  #else
> > -static unsigned long usb_stor_read(struct blk_desc *block_dev, lbaint_t blknr,
> > -				   lbaint_t blkcnt, void *buffer)
> > +static unsigned long usb_stor_read_write(struct blk_desc *block_dev,
> > +					 lbaint_t blknr, lbaint_t blkcnt,
> > +					 const void *buffer, bool is_write)
> >  #endif
> >  {
> >  	lbaint_t start, blks;
> > @@ -1129,9 +1139,9 @@ static unsigned long usb_stor_read(struct
> > blk_desc *block_dev, lbaint_t blknr,  #ifdef CONFIG_BLK
> >  	block_dev = dev_get_uclass_platdata(dev);
> >  	udev = dev_get_parent_priv(dev_get_parent(dev));
> > -	debug("\nusb_read: udev %d\n", block_dev->devnum);
> > +	debug("\nusb_%s: udev %d\n", USB_STOR_OP_TYPE, block_dev->devnum);
> >  #else
> > -	debug("\nusb_read: udev %d\n", block_dev->devnum);
> > +	debug("\nusb_%s: udev %d\n", USB_STOR_OP_TYPE, block_dev->devnum);
> 
> You can just use "\n%s: ..." and use __func__ instead of USB_STOR_OP_TYPE here,
> that'd be less cryptic than "usb_read:" and it's used all over the place already anyway.
> 

Will take care in v6.

> >  	udev = usb_dev_desc[block_dev->devnum].priv;
> >  	if (!udev) {
> >  		debug("%s: No device\n", __func__); @@ -1146,11 +1156,15 @@ static
> > unsigned long usb_stor_read(struct blk_desc *block_dev, lbaint_t blknr,
> >  	start = blknr;
> >  	blks = blkcnt;
> >
> > -	debug("\nusb_read: dev %d startblk " LBAF ", blccnt " LBAF " buffer %"
> > -	      PRIxPTR "\n", block_dev->devnum, start, blks, buf_addr);
> > +	debug("\nusb_%s: dev %d startblk " LBAF ", blccnt " LBAF " buffer %"
> > +	      PRIxPTR "\n", USB_STOR_OP_TYPE, block_dev->devnum, start, blks,
> > +	      buf_addr);
> 
> DTTO here.

Will take care in v6.

Best Regards,
Rajesh Bhagat 

> 
> >  	do {
> > -		/* XXX need some comment here */
> > +		/*
> > +		 * If read/write fails retry for max retry count else
> > +		 * return with number of blocks written successfully.
> > +		 */
> >  		retry = 2;
> >  		srb->pdata = (unsigned char *)buf_addr;
> >  		if (blks > USB_MAX_XFER_BLK)
> > @@ -1162,8 +1176,8 @@ retry_it:
> >  			usb_show_progress();
> >  		srb->datalen = block_dev->blksz * smallblks;
> >  		srb->pdata = (unsigned char *)buf_addr;
> > -		if (usb_read_10(srb, ss, start, smallblks)) {
> > -			debug("Read ERROR\n");
> > +		if (usb_stor_operation(srb, ss, start, smallblks, is_write)) {
> > +			debug("%s ERROR\n", USB_STOR_OP_TYPE);
> >  			usb_request_sense(srb, ss);
> >  			if (retry--)
> >  				goto retry_it;
> > @@ -1176,9 +1190,9 @@ retry_it:
> >  	} while (blks != 0);
> >  	ss->flags &= ~USB_READY;
> >
> > -	debug("usb_read: end startblk " LBAF
> > +	debug("usb_%s: end startblk " LBAF
> >  	      ", blccnt %x buffer %" PRIxPTR "\n",
> > -	      start, smallblks, buf_addr);
> > +	      USB_STOR_OP_TYPE, start, smallblks, buf_addr);
> >
> >  	usb_disable_asynch(0); /* asynch transfer allowed */
> >  	if (blkcnt >= USB_MAX_XFER_BLK)
> > @@ -1186,90 +1200,27 @@ retry_it:
> >  	return blkcnt;
> >  }
> 
> [...]
> 
> --
> Best regards,
> Marek Vasut

[U-Boot] [PATCH v5 2/2] common: usb_storage : Implement logic to calculate optimal usb maximum trasfer blocks

[Rajesh Bhagat]

From: Rajesh Bhagat <rajesh.bhagat@freescale.com>

Implements the logic to calculate the optimal usb maximum trasfer blocks
instead of sending USB_MAX_XFER_BLK blocks which is 65535 and 20 in case
of EHCI and other USB protocols respectively.

It defines USB_MIN_XFER_BLK/USB_MAX_XFER_BLK trasfer blocks that should
be checked for success starting from minimum to maximum, and rest of the
read/write are performed with that optimal value. It tries to increase/
decrease the blocks in follwing scenarios:

1.decrease blocks: when read/write for a particular number of blocks
fails.
2. increase blocks: when read/write for a particular number of blocks
pass and amount left to trasfer is greater than current number of
blocks.

Currently changes are done for EHCI where min = 4096 and max = 65535
is taken. And for other cases code is left unchanged by keeping min
= max = 20.

Signed-off-by: Sriram Dash <sriram.dash@nxp.com>
Signed-off-by: Rajesh Bhagat <rajesh.bhagat@nxp.com>
---
Changes in v5:
 - None

Changes in v4:
 - Adds udev paramater in dec/inc_cur_xfer_blks function and adds
   sanity check on it.
 - Changes type of pos varible to unsigned int in dec/inc_cur_xfer_blks
 - Removes usage of pos varible from usb_stor_read/write

Changes in v3:
 - Adds cur_xfer_blks in struct usb_device to retain values
 - Adds functions dec/inc_cur_xfer_blks to remove code duplication
 - Moves check from macro to calling functions

Changes in v2:
 - Removes table to store blocks and use formula (1 << (12 + n)) - 1
 - Adds logic to start from minimum, go to maximum in each read/write

 common/usb_storage.c |   67 ++++++++++++++++++++++++++++++++++++++++++++++---
 include/usb.h        |    1 +
 2 files changed, 63 insertions(+), 5 deletions(-)

diff --git a/common/usb_storage.c b/common/usb_storage.c
index f060637..9b09412 100644
--- a/common/usb_storage.c
+++ b/common/usb_storage.c
@@ -106,11 +106,16 @@ struct us_data {
  * enough free heap space left, but the SCSI READ(10) and WRITE(10) commands are
  * limited to 65535 blocks.
  */
+#define USB_MIN_XFER_BLK	4095
 #define USB_MAX_XFER_BLK	65535
 #else
+#define USB_MIN_XFER_BLK	20
 #define USB_MAX_XFER_BLK	20
 #endif
 
+#define GET_CUR_XFER_BLKS(blks)	(LOG2((blks + 1) / (USB_MIN_XFER_BLK + 1)))
+#define CALC_CUR_XFER_BLKS(pos)	((1 << (12 + pos)) - 1)
+
 #ifndef CONFIG_BLK
 static struct us_data usb_stor[USB_MAX_STOR_DEV];
 #endif
@@ -141,6 +146,44 @@ static void usb_show_progress(void)
 	debug(".");
 }
 
+static int dec_cur_xfer_blks(struct usb_device *udev)
+{
+	/* decrease the cur_xfer_blks */
+	unsigned int pos;
+	unsigned short size;
+
+	if (!udev)
+		return -EINVAL;
+
+	pos = GET_CUR_XFER_BLKS(udev->cur_xfer_blks);
+	size  = pos ? CALC_CUR_XFER_BLKS(pos - 1) : 0;
+
+	if (size < USB_MIN_XFER_BLK)
+		return -EINVAL;
+
+	udev->cur_xfer_blks = size;
+	return 0;
+}
+
+static int inc_cur_xfer_blks(struct usb_device *udev, lbaint_t blks)
+{
+	/* try to increase the cur_xfer_blks */
+	unsigned int pos;
+	unsigned short size;
+
+	if (!udev)
+		return -EINVAL;
+
+	pos = GET_CUR_XFER_BLKS(udev->cur_xfer_blks);
+	size = CALC_CUR_XFER_BLKS(pos + 1);
+
+	if (size > blks || size > USB_MAX_XFER_BLK)
+		return -EINVAL;
+
+	udev->cur_xfer_blks = size;
+	return 0;
+}
+
 /*******************************************************************************
  * show info on storage devices; 'usb start/init' must be invoked earlier
  * as we only retrieve structures populated during devices initialization
@@ -1128,6 +1171,7 @@ static unsigned long usb_stor_read_write(struct blk_desc *block_dev,
 	struct usb_device *udev;
 	struct us_data *ss;
 	int retry;
+	bool retry_flag = false;
 	ccb *srb = &usb_ccb;
 #ifdef CONFIG_BLK
 	struct blk_desc *block_dev;
@@ -1167,26 +1211,36 @@ static unsigned long usb_stor_read_write(struct blk_desc *block_dev,
 		 */
 		retry = 2;
 		srb->pdata = (unsigned char *)buf_addr;
-		if (blks > USB_MAX_XFER_BLK)
-			smallblks = USB_MAX_XFER_BLK;
+		if (blks > udev->cur_xfer_blks)
+			smallblks = udev->cur_xfer_blks;
 		else
 			smallblks = (unsigned short) blks;
 retry_it:
-		if (smallblks == USB_MAX_XFER_BLK)
+		debug("usb_%s: retry #%d, cur_xfer_blks %hu, smallblks %hu\n",
+		      USB_STOR_OP_TYPE, retry, udev->cur_xfer_blks,
+		      smallblks);
+		if (smallblks == udev->cur_xfer_blks)
 			usb_show_progress();
 		srb->datalen = block_dev->blksz * smallblks;
 		srb->pdata = (unsigned char *)buf_addr;
 		if (usb_stor_operation(srb, ss, start, smallblks, is_write)) {
 			debug("%s ERROR\n", USB_STOR_OP_TYPE);
 			usb_request_sense(srb, ss);
-			if (retry--)
+			if (retry--) {
+				if (!dec_cur_xfer_blks(udev))
+					smallblks = udev->cur_xfer_blks;
+				retry_flag = true;
 				goto retry_it;
+			}
 			blkcnt -= blks;
 			break;
 		}
 		start += smallblks;
 		blks -= smallblks;
 		buf_addr += srb->datalen;
+
+		if (!retry_flag && !inc_cur_xfer_blks(udev, blks))
+			smallblks = udev->cur_xfer_blks;
 	} while (blks != 0);
 	ss->flags &= ~USB_READY;
 
@@ -1195,7 +1249,7 @@ retry_it:
 	      USB_STOR_OP_TYPE, start, smallblks, buf_addr);
 
 	usb_disable_asynch(0); /* asynch transfer allowed */
-	if (blkcnt >= USB_MAX_XFER_BLK)
+	if (blkcnt >= udev->cur_xfer_blks)
 		debug("\n");
 	return blkcnt;
 }
@@ -1282,6 +1336,9 @@ int usb_storage_probe(struct usb_device *dev, unsigned int ifnum,
 		break;
 	}
 
+	/* Initialize the current transfer blocks to minimum value */
+	dev->cur_xfer_blks = USB_MIN_XFER_BLK;
+
 	/*
 	 * We are expecting a minimum of 2 endpoints - in and out (bulk).
 	 * An optional interrupt is OK (necessary for CBI protocol).
diff --git a/include/usb.h b/include/usb.h
index 02a0ccd..b815816 100644
--- a/include/usb.h
+++ b/include/usb.h
@@ -153,6 +153,7 @@ struct usb_device {
 	struct udevice *dev;		/* Pointer to associated device */
 	struct udevice *controller_dev;	/* Pointer to associated controller */
 #endif
+	unsigned short cur_xfer_blks;   /* Current maximum transfer blocks */
 };
 
 struct int_queue;
-- 
1.7.7.4

[U-Boot] [PATCH v5 2/2] common: usb_storage : Implement logic to calculate optimal usb maximum trasfer blocks

[Marek Vasut]

On 06/13/2016 06:03 AM, Rajesh Bhagat wrote:
> From: Rajesh Bhagat <rajesh.bhagat@freescale.com>
> 
> Implements the logic to calculate the optimal usb maximum trasfer blocks
> instead of sending USB_MAX_XFER_BLK blocks which is 65535 and 20 in case
> of EHCI and other USB protocols respectively.
> 
> It defines USB_MIN_XFER_BLK/USB_MAX_XFER_BLK trasfer blocks that should
> be checked for success starting from minimum to maximum, and rest of the
> read/write are performed with that optimal value. It tries to increase/
> decrease the blocks in follwing scenarios:
> 
> 1.decrease blocks: when read/write for a particular number of blocks
> fails.
> 2. increase blocks: when read/write for a particular number of blocks
> pass and amount left to trasfer is greater than current number of
> blocks.
> 
> Currently changes are done for EHCI where min = 4096 and max = 65535
> is taken. And for other cases code is left unchanged by keeping min
> = max = 20.
> 
> Signed-off-by: Sriram Dash <sriram.dash@nxp.com>
> Signed-off-by: Rajesh Bhagat <rajesh.bhagat@nxp.com>
> ---
> Changes in v5:
>  - None
> 
> Changes in v4:
>  - Adds udev paramater in dec/inc_cur_xfer_blks function and adds
>    sanity check on it.
>  - Changes type of pos varible to unsigned int in dec/inc_cur_xfer_blks
>  - Removes usage of pos varible from usb_stor_read/write
> 
> Changes in v3:
>  - Adds cur_xfer_blks in struct usb_device to retain values
>  - Adds functions dec/inc_cur_xfer_blks to remove code duplication
>  - Moves check from macro to calling functions
> 
> Changes in v2:
>  - Removes table to store blocks and use formula (1 << (12 + n)) - 1
>  - Adds logic to start from minimum, go to maximum in each read/write
> 
>  common/usb_storage.c |   67 ++++++++++++++++++++++++++++++++++++++++++++++---
>  include/usb.h        |    1 +
>  2 files changed, 63 insertions(+), 5 deletions(-)
> 
> diff --git a/common/usb_storage.c b/common/usb_storage.c
> index f060637..9b09412 100644
> --- a/common/usb_storage.c
> +++ b/common/usb_storage.c
> @@ -106,11 +106,16 @@ struct us_data {
>   * enough free heap space left, but the SCSI READ(10) and WRITE(10) commands are
>   * limited to 65535 blocks.
>   */
> +#define USB_MIN_XFER_BLK	4095
>  #define USB_MAX_XFER_BLK	65535
>  #else
> +#define USB_MIN_XFER_BLK	20
>  #define USB_MAX_XFER_BLK	20
>  #endif
>  
> +#define GET_CUR_XFER_BLKS(blks)	(LOG2((blks + 1) / (USB_MIN_XFER_BLK + 1)))
> +#define CALC_CUR_XFER_BLKS(pos)	((1 << (12 + pos)) - 1)

Parenthesis around variables are missing.

>  #ifndef CONFIG_BLK
>  static struct us_data usb_stor[USB_MAX_STOR_DEV];
>  #endif
> @@ -141,6 +146,44 @@ static void usb_show_progress(void)
>  	debug(".");
>  }
>  
> +static int dec_cur_xfer_blks(struct usb_device *udev)
> +{
> +	/* decrease the cur_xfer_blks */
> +	unsigned int pos;
> +	unsigned short size;
> +
> +	if (!udev)
> +		return -EINVAL;
> +
> +	pos = GET_CUR_XFER_BLKS(udev->cur_xfer_blks);
> +	size  = pos ? CALC_CUR_XFER_BLKS(pos - 1) : 0;

If pos == 0 , the condition below will be true (size will be 2047),
so this extra ternary is unnecessary.

> +	if (size < USB_MIN_XFER_BLK)
> +		return -EINVAL;
> +
> +	udev->cur_xfer_blks = size;
> +	return 0;
> +}
> +
> +static int inc_cur_xfer_blks(struct usb_device *udev, lbaint_t blks)
> +{
> +	/* try to increase the cur_xfer_blks */
> +	unsigned int pos;
> +	unsigned short size;
> +
> +	if (!udev)
> +		return -EINVAL;
> +
> +	pos = GET_CUR_XFER_BLKS(udev->cur_xfer_blks);
> +	size = CALC_CUR_XFER_BLKS(pos + 1);
> +
> +	if (size > blks || size > USB_MAX_XFER_BLK)
> +		return -EINVAL;

Why don't you clamp the size to min(blks, USB_MAX_XFER_BLK) instead ?

> +	udev->cur_xfer_blks = size;
> +	return 0;
> +}
> +
>  /*******************************************************************************
>   * show info on storage devices; 'usb start/init' must be invoked earlier
>   * as we only retrieve structures populated during devices initialization
> @@ -1128,6 +1171,7 @@ static unsigned long usb_stor_read_write(struct blk_desc *block_dev,
>  	struct usb_device *udev;
>  	struct us_data *ss;
>  	int retry;
> +	bool retry_flag = false;
>  	ccb *srb = &usb_ccb;
>  #ifdef CONFIG_BLK
>  	struct blk_desc *block_dev;
> @@ -1167,26 +1211,36 @@ static unsigned long usb_stor_read_write(struct blk_desc *block_dev,
>  		 */
>  		retry = 2;
>  		srb->pdata = (unsigned char *)buf_addr;
> -		if (blks > USB_MAX_XFER_BLK)
> -			smallblks = USB_MAX_XFER_BLK;
> +		if (blks > udev->cur_xfer_blks)
> +			smallblks = udev->cur_xfer_blks;
>  		else
>  			smallblks = (unsigned short) blks;
>  retry_it:
> -		if (smallblks == USB_MAX_XFER_BLK)
> +		debug("usb_%s: retry #%d, cur_xfer_blks %hu, smallblks %hu\n",
> +		      USB_STOR_OP_TYPE, retry, udev->cur_xfer_blks,
> +		      smallblks);
> +		if (smallblks == udev->cur_xfer_blks)
>  			usb_show_progress();
>  		srb->datalen = block_dev->blksz * smallblks;
>  		srb->pdata = (unsigned char *)buf_addr;
>  		if (usb_stor_operation(srb, ss, start, smallblks, is_write)) {
>  			debug("%s ERROR\n", USB_STOR_OP_TYPE);
>  			usb_request_sense(srb, ss);
> -			if (retry--)
> +			if (retry--) {
> +				if (!dec_cur_xfer_blks(udev))
> +					smallblks = udev->cur_xfer_blks;
> +				retry_flag = true;
>  				goto retry_it;
> +			}
>  			blkcnt -= blks;
>  			break;
>  		}
>  		start += smallblks;
>  		blks -= smallblks;
>  		buf_addr += srb->datalen;
> +
> +		if (!retry_flag && !inc_cur_xfer_blks(udev, blks))
> +			smallblks = udev->cur_xfer_blks;
>  	} while (blks != 0);
>  	ss->flags &= ~USB_READY;
>  
> @@ -1195,7 +1249,7 @@ retry_it:
>  	      USB_STOR_OP_TYPE, start, smallblks, buf_addr);
>  
>  	usb_disable_asynch(0); /* asynch transfer allowed */
> -	if (blkcnt >= USB_MAX_XFER_BLK)
> +	if (blkcnt >= udev->cur_xfer_blks)
>  		debug("\n");
>  	return blkcnt;
>  }
> @@ -1282,6 +1336,9 @@ int usb_storage_probe(struct usb_device *dev, unsigned int ifnum,
>  		break;
>  	}
>  
> +	/* Initialize the current transfer blocks to minimum value */
> +	dev->cur_xfer_blks = USB_MIN_XFER_BLK;
> +
>  	/*
>  	 * We are expecting a minimum of 2 endpoints - in and out (bulk).
>  	 * An optional interrupt is OK (necessary for CBI protocol).
> diff --git a/include/usb.h b/include/usb.h
> index 02a0ccd..b815816 100644
> --- a/include/usb.h
> +++ b/include/usb.h
> @@ -153,6 +153,7 @@ struct usb_device {
>  	struct udevice *dev;		/* Pointer to associated device */
>  	struct udevice *controller_dev;	/* Pointer to associated controller */
>  #endif
> +	unsigned short cur_xfer_blks;   /* Current maximum transfer blocks */
>  };
>  
>  struct int_queue;
> 


-- 
Best regards,
Marek Vasut

[U-Boot] [PATCH v5 2/2] common: usb_storage : Implement logic to calculate optimal usb maximum trasfer blocks

[Rajesh Bhagat]

> -----Original Message-----
> From: Marek Vasut [mailto:marex at denx.de]
> Sent: Monday, June 13, 2016 7:07 PM
> To: Rajesh Bhagat <rajesh.bhagat@nxp.com>; u-boot at lists.denx.de
> Cc: sjg at chromium.org; york sun <york.sun@nxp.com>; Sriram Dash
> <sriram.dash@nxp.com>; Rajesh Bhagat <rajesh.bhagat@freescale.com>
> Subject: Re: [PATCH v5 2/2] common: usb_storage : Implement logic to calculate
> optimal usb maximum trasfer blocks
> 
> On 06/13/2016 06:03 AM, Rajesh Bhagat wrote:
> > From: Rajesh Bhagat <rajesh.bhagat@freescale.com>
> >
> > Implements the logic to calculate the optimal usb maximum trasfer
> > blocks instead of sending USB_MAX_XFER_BLK blocks which is 65535 and
> > 20 in case of EHCI and other USB protocols respectively.
> >
> > It defines USB_MIN_XFER_BLK/USB_MAX_XFER_BLK trasfer blocks that
> > should be checked for success starting from minimum to maximum, and
> > rest of the read/write are performed with that optimal value. It tries
> > to increase/ decrease the blocks in follwing scenarios:
> >
> > 1.decrease blocks: when read/write for a particular number of blocks
> > fails.
> > 2. increase blocks: when read/write for a particular number of blocks
> > pass and amount left to trasfer is greater than current number of
> > blocks.
> >
> > Currently changes are done for EHCI where min = 4096 and max = 65535
> > is taken. And for other cases code is left unchanged by keeping min =
> > max = 20.
> >
> > Signed-off-by: Sriram Dash <sriram.dash@nxp.com>
> > Signed-off-by: Rajesh Bhagat <rajesh.bhagat@nxp.com>
> > ---
> > Changes in v5:
> >  - None
> >
> > Changes in v4:
> >  - Adds udev paramater in dec/inc_cur_xfer_blks function and adds
> >    sanity check on it.
> >  - Changes type of pos varible to unsigned int in
> > dec/inc_cur_xfer_blks
> >  - Removes usage of pos varible from usb_stor_read/write
> >
> > Changes in v3:
> >  - Adds cur_xfer_blks in struct usb_device to retain values
> >  - Adds functions dec/inc_cur_xfer_blks to remove code duplication
> >  - Moves check from macro to calling functions
> >
> > Changes in v2:
> >  - Removes table to store blocks and use formula (1 << (12 + n)) - 1
> >  - Adds logic to start from minimum, go to maximum in each read/write
> >
> >  common/usb_storage.c |   67
> ++++++++++++++++++++++++++++++++++++++++++++++---
> >  include/usb.h        |    1 +
> >  2 files changed, 63 insertions(+), 5 deletions(-)
> >
> > diff --git a/common/usb_storage.c b/common/usb_storage.c index
> > f060637..9b09412 100644
> > --- a/common/usb_storage.c
> > +++ b/common/usb_storage.c
> > @@ -106,11 +106,16 @@ struct us_data {
> >   * enough free heap space left, but the SCSI READ(10) and WRITE(10) commands
> are
> >   * limited to 65535 blocks.
> >   */
> > +#define USB_MIN_XFER_BLK	4095
> >  #define USB_MAX_XFER_BLK	65535
> >  #else
> > +#define USB_MIN_XFER_BLK	20
> >  #define USB_MAX_XFER_BLK	20
> >  #endif
> >
> > +#define GET_CUR_XFER_BLKS(blks)	(LOG2((blks + 1) /
> (USB_MIN_XFER_BLK + 1)))
> > +#define CALC_CUR_XFER_BLKS(pos)	((1 << (12 + pos)) - 1)

Hello Marek,

> 
> Parenthesis around variables are missing.
> 

Will take care in v6. 

> >  #ifndef CONFIG_BLK
> >  static struct us_data usb_stor[USB_MAX_STOR_DEV];  #endif @@ -141,6
> > +146,44 @@ static void usb_show_progress(void)
> >  	debug(".");
> >  }
> >
> > +static int dec_cur_xfer_blks(struct usb_device *udev) {
> > +	/* decrease the cur_xfer_blks */
> > +	unsigned int pos;
> > +	unsigned short size;
> > +
> > +	if (!udev)
> > +		return -EINVAL;
> > +
> > +	pos = GET_CUR_XFER_BLKS(udev->cur_xfer_blks);
> > +	size  = pos ? CALC_CUR_XFER_BLKS(pos - 1) : 0;
> 
> If pos == 0 , the condition below will be true (size will be 2047), so this extra ternary
> is unnecessary.
> 

Will take care in v6. Will remove the extra ternary operator used, as 2047 will follow the 
below check (size < USB_MIN_XFER_BLK) and code will work fine. 

> > +	if (size < USB_MIN_XFER_BLK)
> > +		return -EINVAL;
> > +
> > +	udev->cur_xfer_blks = size;
> > +	return 0;
> > +}
> > +
> > +static int inc_cur_xfer_blks(struct usb_device *udev, lbaint_t blks)
> > +{
> > +	/* try to increase the cur_xfer_blks */
> > +	unsigned int pos;
> > +	unsigned short size;
> > +
> > +	if (!udev)
> > +		return -EINVAL;
> > +
> > +	pos = GET_CUR_XFER_BLKS(udev->cur_xfer_blks);
> > +	size = CALC_CUR_XFER_BLKS(pos + 1);
> > +
> > +	if (size > blks || size > USB_MAX_XFER_BLK)
> > +		return -EINVAL;
> 
> Why don't you clamp the size to min(blks, USB_MAX_XFER_BLK) instead ?
> 

Do you mean below statement?

if (size > min(blks, USB_MAX_XFER_BLK))
	return -EINVAL;

> > +	udev->cur_xfer_blks = size;
> > +	return 0;
> > +}
> > +
> >
> /**********************************************************************
> *********
> >   * show info on storage devices; 'usb start/init' must be invoked earlier
> >   * as we only retrieve structures populated during devices
> > initialization @@ -1128,6 +1171,7 @@ static unsigned long
> usb_stor_read_write(struct blk_desc *block_dev,
> >  	struct usb_device *udev;
> >  	struct us_data *ss;
> >  	int retry;
> > +	bool retry_flag = false;
> >  	ccb *srb = &usb_ccb;
> >  #ifdef CONFIG_BLK
> >  	struct blk_desc *block_dev;
> > @@ -1167,26 +1211,36 @@ static unsigned long usb_stor_read_write(struct
> blk_desc *block_dev,
> >  		 */
> >  		retry = 2;
> >  		srb->pdata = (unsigned char *)buf_addr;
> > -		if (blks > USB_MAX_XFER_BLK)
> > -			smallblks = USB_MAX_XFER_BLK;
> > +		if (blks > udev->cur_xfer_blks)
> > +			smallblks = udev->cur_xfer_blks;
> >  		else
> >  			smallblks = (unsigned short) blks;
> >  retry_it:
> > -		if (smallblks == USB_MAX_XFER_BLK)
> > +		debug("usb_%s: retry #%d, cur_xfer_blks %hu, smallblks %hu\n",
> > +		      USB_STOR_OP_TYPE, retry, udev->cur_xfer_blks,
> > +		      smallblks);
> > +		if (smallblks == udev->cur_xfer_blks)
> >  			usb_show_progress();
> >  		srb->datalen = block_dev->blksz * smallblks;
> >  		srb->pdata = (unsigned char *)buf_addr;
> >  		if (usb_stor_operation(srb, ss, start, smallblks, is_write)) {
> >  			debug("%s ERROR\n", USB_STOR_OP_TYPE);
> >  			usb_request_sense(srb, ss);
> > -			if (retry--)
> > +			if (retry--) {
> > +				if (!dec_cur_xfer_blks(udev))
> > +					smallblks = udev->cur_xfer_blks;
> > +				retry_flag = true;
> >  				goto retry_it;
> > +			}
> >  			blkcnt -= blks;
> >  			break;
> >  		}
> >  		start += smallblks;
> >  		blks -= smallblks;
> >  		buf_addr += srb->datalen;
> > +
> > +		if (!retry_flag && !inc_cur_xfer_blks(udev, blks))
> > +			smallblks = udev->cur_xfer_blks;
> >  	} while (blks != 0);
> >  	ss->flags &= ~USB_READY;
> >
> > @@ -1195,7 +1249,7 @@ retry_it:
> >  	      USB_STOR_OP_TYPE, start, smallblks, buf_addr);
> >
> >  	usb_disable_asynch(0); /* asynch transfer allowed */
> > -	if (blkcnt >= USB_MAX_XFER_BLK)
> > +	if (blkcnt >= udev->cur_xfer_blks)
> >  		debug("\n");
> >  	return blkcnt;
> >  }
> > @@ -1282,6 +1336,9 @@ int usb_storage_probe(struct usb_device *dev, unsigned
> int ifnum,
> >  		break;
> >  	}
> >
> > +	/* Initialize the current transfer blocks to minimum value */
> > +	dev->cur_xfer_blks = USB_MIN_XFER_BLK;
> > +
> >  	/*
> >  	 * We are expecting a minimum of 2 endpoints - in and out (bulk).
> >  	 * An optional interrupt is OK (necessary for CBI protocol).
> > diff --git a/include/usb.h b/include/usb.h index 02a0ccd..b815816
> > 100644
> > --- a/include/usb.h
> > +++ b/include/usb.h
> > @@ -153,6 +153,7 @@ struct usb_device {
> >  	struct udevice *dev;		/* Pointer to associated device */
> >  	struct udevice *controller_dev;	/* Pointer to associated controller */
> >  #endif
> > +	unsigned short cur_xfer_blks;   /* Current maximum transfer blocks */
> >  };
> >
> >  struct int_queue;
> >
> 

Best Regards,
Rajesh Bhagat 

> 
> --
> Best regards,
> Marek Vasut

[U-Boot] [PATCH v5 2/2] common: usb_storage : Implement logic to calculate optimal usb maximum trasfer blocks

[Marek Vasut]

On 06/14/2016 05:41 AM, Rajesh Bhagat wrote:
> 
> 
>> -----Original Message-----
>> From: Marek Vasut [mailto:marex at denx.de]
>> Sent: Monday, June 13, 2016 7:07 PM
>> To: Rajesh Bhagat <rajesh.bhagat@nxp.com>; u-boot at lists.denx.de
>> Cc: sjg at chromium.org; york sun <york.sun@nxp.com>; Sriram Dash
>> <sriram.dash@nxp.com>; Rajesh Bhagat <rajesh.bhagat@freescale.com>
>> Subject: Re: [PATCH v5 2/2] common: usb_storage : Implement logic to calculate
>> optimal usb maximum trasfer blocks
>>
>> On 06/13/2016 06:03 AM, Rajesh Bhagat wrote:
>>> From: Rajesh Bhagat <rajesh.bhagat@freescale.com>
>>>
>>> Implements the logic to calculate the optimal usb maximum trasfer
>>> blocks instead of sending USB_MAX_XFER_BLK blocks which is 65535 and
>>> 20 in case of EHCI and other USB protocols respectively.
>>>
>>> It defines USB_MIN_XFER_BLK/USB_MAX_XFER_BLK trasfer blocks that
>>> should be checked for success starting from minimum to maximum, and
>>> rest of the read/write are performed with that optimal value. It tries
>>> to increase/ decrease the blocks in follwing scenarios:
>>>
>>> 1.decrease blocks: when read/write for a particular number of blocks
>>> fails.
>>> 2. increase blocks: when read/write for a particular number of blocks
>>> pass and amount left to trasfer is greater than current number of
>>> blocks.
>>>
>>> Currently changes are done for EHCI where min = 4096 and max = 65535
>>> is taken. And for other cases code is left unchanged by keeping min =
>>> max = 20.
>>>
>>> Signed-off-by: Sriram Dash <sriram.dash@nxp.com>
>>> Signed-off-by: Rajesh Bhagat <rajesh.bhagat@nxp.com>
>>> ---
>>> Changes in v5:
>>>  - None
>>>
>>> Changes in v4:
>>>  - Adds udev paramater in dec/inc_cur_xfer_blks function and adds
>>>    sanity check on it.
>>>  - Changes type of pos varible to unsigned int in
>>> dec/inc_cur_xfer_blks
>>>  - Removes usage of pos varible from usb_stor_read/write
>>>
>>> Changes in v3:
>>>  - Adds cur_xfer_blks in struct usb_device to retain values
>>>  - Adds functions dec/inc_cur_xfer_blks to remove code duplication
>>>  - Moves check from macro to calling functions
>>>
>>> Changes in v2:
>>>  - Removes table to store blocks and use formula (1 << (12 + n)) - 1
>>>  - Adds logic to start from minimum, go to maximum in each read/write
>>>
>>>  common/usb_storage.c |   67
>> ++++++++++++++++++++++++++++++++++++++++++++++---
>>>  include/usb.h        |    1 +
>>>  2 files changed, 63 insertions(+), 5 deletions(-)
>>>
>>> diff --git a/common/usb_storage.c b/common/usb_storage.c index
>>> f060637..9b09412 100644
>>> --- a/common/usb_storage.c
>>> +++ b/common/usb_storage.c
>>> @@ -106,11 +106,16 @@ struct us_data {
>>>   * enough free heap space left, but the SCSI READ(10) and WRITE(10) commands
>> are
>>>   * limited to 65535 blocks.
>>>   */
>>> +#define USB_MIN_XFER_BLK	4095
>>>  #define USB_MAX_XFER_BLK	65535
>>>  #else
>>> +#define USB_MIN_XFER_BLK	20
>>>  #define USB_MAX_XFER_BLK	20
>>>  #endif
>>>
>>> +#define GET_CUR_XFER_BLKS(blks)	(LOG2((blks + 1) /
>> (USB_MIN_XFER_BLK + 1)))
>>> +#define CALC_CUR_XFER_BLKS(pos)	((1 << (12 + pos)) - 1)
> 
> Hello Marek,
> 
>>
>> Parenthesis around variables are missing.
>>
> 
> Will take care in v6. 
> 
>>>  #ifndef CONFIG_BLK
>>>  static struct us_data usb_stor[USB_MAX_STOR_DEV];  #endif @@ -141,6
>>> +146,44 @@ static void usb_show_progress(void)
>>>  	debug(".");
>>>  }
>>>
>>> +static int dec_cur_xfer_blks(struct usb_device *udev) {
>>> +	/* decrease the cur_xfer_blks */
>>> +	unsigned int pos;
>>> +	unsigned short size;
>>> +
>>> +	if (!udev)
>>> +		return -EINVAL;
>>> +
>>> +	pos = GET_CUR_XFER_BLKS(udev->cur_xfer_blks);
>>> +	size  = pos ? CALC_CUR_XFER_BLKS(pos - 1) : 0;
>>
>> If pos == 0 , the condition below will be true (size will be 2047), so this extra ternary
>> is unnecessary.
>>
> 
> Will take care in v6. Will remove the extra ternary operator used, as 2047 will follow the 
> below check (size < USB_MIN_XFER_BLK) and code will work fine. 
> 
>>> +	if (size < USB_MIN_XFER_BLK)
>>> +		return -EINVAL;
>>> +
>>> +	udev->cur_xfer_blks = size;
>>> +	return 0;
>>> +}
>>> +
>>> +static int inc_cur_xfer_blks(struct usb_device *udev, lbaint_t blks)
>>> +{
>>> +	/* try to increase the cur_xfer_blks */
>>> +	unsigned int pos;
>>> +	unsigned short size;
>>> +
>>> +	if (!udev)
>>> +		return -EINVAL;
>>> +
>>> +	pos = GET_CUR_XFER_BLKS(udev->cur_xfer_blks);
>>> +	size = CALC_CUR_XFER_BLKS(pos + 1);
>>> +
>>> +	if (size > blks || size > USB_MAX_XFER_BLK)
>>> +		return -EINVAL;
>>
>> Why don't you clamp the size to min(blks, USB_MAX_XFER_BLK) instead ?
>>
> 
> Do you mean below statement?
> 
> if (size > min(blks, USB_MAX_XFER_BLK))
> 	return -EINVAL;

Yes, if that makes sense.


-- 
Best regards,
Marek Vasut

[U-Boot] [PATCH v5 2/2] common: usb_storage : Implement logic to calculate optimal usb maximum trasfer blocks

[Rajesh Bhagat]

> -----Original Message-----
> From: Marek Vasut [mailto:marex at denx.de]
> Sent: Tuesday, June 14, 2016 5:41 PM
> To: Rajesh Bhagat <rajesh.bhagat@nxp.com>; u-boot at lists.denx.de
> Cc: sjg at chromium.org; york sun <york.sun@nxp.com>; Sriram Dash
> <sriram.dash@nxp.com>; Rajesh Bhagat <rajesh.bhagat@freescale.com>
> Subject: Re: [PATCH v5 2/2] common: usb_storage : Implement logic to calculate
> optimal usb maximum trasfer blocks
> 
> On 06/14/2016 05:41 AM, Rajesh Bhagat wrote:
> >
> >
> >> -----Original Message-----
> >> From: Marek Vasut [mailto:marex at denx.de]
> >> Sent: Monday, June 13, 2016 7:07 PM
> >> To: Rajesh Bhagat <rajesh.bhagat@nxp.com>; u-boot at lists.denx.de
> >> Cc: sjg at chromium.org; york sun <york.sun@nxp.com>; Sriram Dash
> >> <sriram.dash@nxp.com>; Rajesh Bhagat <rajesh.bhagat@freescale.com>
> >> Subject: Re: [PATCH v5 2/2] common: usb_storage : Implement logic to
> >> calculate optimal usb maximum trasfer blocks
> >>
> >> On 06/13/2016 06:03 AM, Rajesh Bhagat wrote:
> >>> From: Rajesh Bhagat <rajesh.bhagat@freescale.com>
> >>>
> >>> Implements the logic to calculate the optimal usb maximum trasfer
> >>> blocks instead of sending USB_MAX_XFER_BLK blocks which is 65535 and
> >>> 20 in case of EHCI and other USB protocols respectively.
> >>>
> >>> It defines USB_MIN_XFER_BLK/USB_MAX_XFER_BLK trasfer blocks that
> >>> should be checked for success starting from minimum to maximum, and
> >>> rest of the read/write are performed with that optimal value. It
> >>> tries to increase/ decrease the blocks in follwing scenarios:
> >>>
> >>> 1.decrease blocks: when read/write for a particular number of blocks
> >>> fails.
> >>> 2. increase blocks: when read/write for a particular number of
> >>> blocks pass and amount left to trasfer is greater than current
> >>> number of blocks.
> >>>
> >>> Currently changes are done for EHCI where min = 4096 and max = 65535
> >>> is taken. And for other cases code is left unchanged by keeping min
> >>> = max = 20.
> >>>
> >>> Signed-off-by: Sriram Dash <sriram.dash@nxp.com>
> >>> Signed-off-by: Rajesh Bhagat <rajesh.bhagat@nxp.com>
> >>> ---
> >>> Changes in v5:
> >>>  - None
> >>>
> >>> Changes in v4:
> >>>  - Adds udev paramater in dec/inc_cur_xfer_blks function and adds
> >>>    sanity check on it.
> >>>  - Changes type of pos varible to unsigned int in
> >>> dec/inc_cur_xfer_blks
> >>>  - Removes usage of pos varible from usb_stor_read/write
> >>>
> >>> Changes in v3:
> >>>  - Adds cur_xfer_blks in struct usb_device to retain values
> >>>  - Adds functions dec/inc_cur_xfer_blks to remove code duplication
> >>>  - Moves check from macro to calling functions
> >>>
> >>> Changes in v2:
> >>>  - Removes table to store blocks and use formula (1 << (12 + n)) - 1
> >>>  - Adds logic to start from minimum, go to maximum in each
> >>> read/write
> >>>
> >>>  common/usb_storage.c |   67
> >> ++++++++++++++++++++++++++++++++++++++++++++++---
> >>>  include/usb.h        |    1 +
> >>>  2 files changed, 63 insertions(+), 5 deletions(-)
> >>>
> >>> diff --git a/common/usb_storage.c b/common/usb_storage.c index
> >>> f060637..9b09412 100644
> >>> --- a/common/usb_storage.c
> >>> +++ b/common/usb_storage.c
> >>> @@ -106,11 +106,16 @@ struct us_data {
> >>>   * enough free heap space left, but the SCSI READ(10) and WRITE(10)
> >>> commands
> >> are
> >>>   * limited to 65535 blocks.
> >>>   */
> >>> +#define USB_MIN_XFER_BLK	4095
> >>>  #define USB_MAX_XFER_BLK	65535
> >>>  #else
> >>> +#define USB_MIN_XFER_BLK	20
> >>>  #define USB_MAX_XFER_BLK	20
> >>>  #endif
> >>>
> >>> +#define GET_CUR_XFER_BLKS(blks)	(LOG2((blks + 1) /
> >> (USB_MIN_XFER_BLK + 1)))
> >>> +#define CALC_CUR_XFER_BLKS(pos)	((1 << (12 + pos)) - 1)
> >
> > Hello Marek,
> >
> >>
> >> Parenthesis around variables are missing.
> >>
> >
> > Will take care in v6.
> >
> >>>  #ifndef CONFIG_BLK
> >>>  static struct us_data usb_stor[USB_MAX_STOR_DEV];  #endif @@ -141,6
> >>> +146,44 @@ static void usb_show_progress(void)
> >>>  	debug(".");
> >>>  }
> >>>
> >>> +static int dec_cur_xfer_blks(struct usb_device *udev) {
> >>> +	/* decrease the cur_xfer_blks */
> >>> +	unsigned int pos;
> >>> +	unsigned short size;
> >>> +
> >>> +	if (!udev)
> >>> +		return -EINVAL;
> >>> +
> >>> +	pos = GET_CUR_XFER_BLKS(udev->cur_xfer_blks);
> >>> +	size  = pos ? CALC_CUR_XFER_BLKS(pos - 1) : 0;
> >>
> >> If pos == 0 , the condition below will be true (size will be 2047),
> >> so this extra ternary is unnecessary.
> >>
> >
> > Will take care in v6. Will remove the extra ternary operator used, as
> > 2047 will follow the below check (size < USB_MIN_XFER_BLK) and code will work
> fine.
> >
> >>> +	if (size < USB_MIN_XFER_BLK)
> >>> +		return -EINVAL;
> >>> +
> >>> +	udev->cur_xfer_blks = size;
> >>> +	return 0;
> >>> +}
> >>> +
> >>> +static int inc_cur_xfer_blks(struct usb_device *udev, lbaint_t
> >>> +blks) {
> >>> +	/* try to increase the cur_xfer_blks */
> >>> +	unsigned int pos;
> >>> +	unsigned short size;
> >>> +
> >>> +	if (!udev)
> >>> +		return -EINVAL;
> >>> +
> >>> +	pos = GET_CUR_XFER_BLKS(udev->cur_xfer_blks);
> >>> +	size = CALC_CUR_XFER_BLKS(pos + 1);
> >>> +
> >>> +	if (size > blks || size > USB_MAX_XFER_BLK)
> >>> +		return -EINVAL;
> >>
> >> Why don't you clamp the size to min(blks, USB_MAX_XFER_BLK) instead ?
> >>
> >
> > Do you mean below statement?
> >
> > if (size > min(blks, USB_MAX_XFER_BLK))
> > 	return -EINVAL;
> 
> Yes, if that makes sense.
> 

Will take care in v6. Yes it does, as it is keeping the logic intact for size to be less than blks and
USB_MAX_XFER_BLK both.

Best Regards,
Rajesh Bhagat

> 
> --
> Best regards,
> Marek Vasut