Revert "usb: usb_storage: do not align length of request for CBW to maxp size"

This reverts commit 806e8f8fcc27e1753947bd9f059ba2316cf8f92a.

To quote Alan Stern:
	The necessity for this patch has been under discussion.

	It turns out the UDC that Mian has been working on and Felipe's
	UDC have contradictory requirements.  Mian's UDC driver wants a
	bulk-OUT transfer length to be shorter than the maxpacket size
	if a short packet is expected, whereas Felipe's UDC hardware
	always needs bulk-OUT transfer lengths to be evenly divisible by
	the maxpacket size.

	Mian has agreed to go back over the driver to resolve this
	conflict.  This means we probably will not want this patch after
	all.  (In fact, we may ultimately decide to change the gadget
	framework to require that bulk-OUT transfer lengths _always_ be
	divisible by the maxpacket size -- only the g_file_storage and
	g_mass_storage gadgets would need to be changed.)

Cc: Mian Yousaf Kaukab <mian.yousaf.kaukab@stericsson.com>
Cc: Michal Nazarewicz <mina86@mina86.com>
Cc: Alan Stern <stern@rowland.harvard.edu>
Signed-off-by: Greg Kroah-Hartman <gregkh@suse.de>

diff --git a/drivers/usb/gadget/f_mass_storage.c b/drivers/usb/gadget/f_mass_storage.c
index 7d95a2c..01ae27b 100644 (file)
--- a/drivers/usb/gadget/f_mass_storage.c
+++ b/drivers/usb/gadget/f_mass_storage.c
@@ -474,6 +474,20 @@ static int exception_in_progress(struct fsg_common *common)
        return common->state > FSG_STATE_IDLE;
 }
 
+/* Make bulk-out requests be divisible by the maxpacket size */
+static void set_bulk_out_req_length(struct fsg_common *common,
+                                   struct fsg_buffhd *bh, unsigned int length)
+{
+       unsigned int    rem;
+
+       bh->bulk_out_intended_length = length;
+       rem = length % common->bulk_out_maxpacket;
+       if (rem > 0)
+               length += common->bulk_out_maxpacket - rem;
+       bh->outreq->length = length;
+}
+
+
 /*-------------------------------------------------------------------------*/
 
 static int fsg_set_halt(struct fsg_dev *fsg, struct usb_ep *ep)
@@ -572,9 +586,9 @@ static void bulk_out_complete(struct usb_ep *ep, struct usb_request *req)
        struct fsg_buffhd       *bh = req->context;
 
        dump_msg(common, "bulk-out", req->buf, req->actual);
-       if (req->status || req->actual != req->length)
+       if (req->status || req->actual != bh->bulk_out_intended_length)
                DBG(common, "%s --> %d, %u/%u\n", __func__,
-                   req->status, req->actual, req->length);
+                   req->status, req->actual, bh->bulk_out_intended_length);
        if (req->status == -ECONNRESET)         /* Request was cancelled */
                usb_ep_fifo_flush(ep);
 
@@ -966,6 +980,7 @@ static int do_write(struct fsg_common *common)
                         * the bulk-out maxpacket size
                         */
                        bh->outreq->length = amount;
+                       bh->bulk_out_intended_length = amount;
                        bh->outreq->short_not_ok = 1;
                        if (!start_out_transfer(common, bh))
                                /* Dunno what to do if common->fsg is NULL */
@@ -1611,6 +1626,7 @@ static int throw_away_data(struct fsg_common *common)
                         * the bulk-out maxpacket size.
                         */
                        bh->outreq->length = amount;
+                       bh->bulk_out_intended_length = amount;
                        bh->outreq->short_not_ok = 1;
                        if (!start_out_transfer(common, bh))
                                /* Dunno what to do if common->fsg is NULL */
@@ -2279,8 +2295,8 @@ static int get_next_command(struct fsg_common *common)
        }
 
        /* Queue a request to read a Bulk-only CBW */
-       bh->outreq->length = USB_BULK_CB_WRAP_LEN;
-       bh->outreq->short_not_ok = 0;
+       set_bulk_out_req_length(common, bh, USB_BULK_CB_WRAP_LEN);
+       bh->outreq->short_not_ok = 1;
        if (!start_out_transfer(common, bh))
                /* Don't know what to do if common->fsg is NULL */
                return -EIO;

diff --git a/drivers/usb/gadget/file_storage.c b/drivers/usb/gadget/file_storage.c
index aebfb81..fcfc77c 100644 (file)
--- a/drivers/usb/gadget/file_storage.c
+++ b/drivers/usb/gadget/file_storage.c
@@ -497,6 +497,19 @@ static int exception_in_progress(struct fsg_dev *fsg)
        return (fsg->state > FSG_STATE_IDLE);
 }
 
+/* Make bulk-out requests be divisible by the maxpacket size */
+static void set_bulk_out_req_length(struct fsg_dev *fsg,
+               struct fsg_buffhd *bh, unsigned int length)
+{
+       unsigned int    rem;
+
+       bh->bulk_out_intended_length = length;
+       rem = length % fsg->bulk_out_maxpacket;
+       if (rem > 0)
+               length += fsg->bulk_out_maxpacket - rem;
+       bh->outreq->length = length;
+}
+
 static struct fsg_dev                  *the_fsg;
 static struct usb_gadget_driver                fsg_driver;
 
@@ -717,9 +730,10 @@ static void bulk_out_complete(struct usb_ep *ep, struct usb_request *req)
        struct fsg_buffhd       *bh = req->context;
 
        dump_msg(fsg, "bulk-out", req->buf, req->actual);
-       if (req->status || req->actual != req->length)
+       if (req->status || req->actual != bh->bulk_out_intended_length)
                DBG(fsg, "%s --> %d, %u/%u\n", __func__,
-                               req->status, req->actual, req->length);
+                               req->status, req->actual,
+                               bh->bulk_out_intended_length);
        if (req->status == -ECONNRESET)         // Request was cancelled
                usb_ep_fifo_flush(ep);
 
@@ -1335,7 +1349,8 @@ static int do_write(struct fsg_dev *fsg)
 
                        /* amount is always divisible by 512, hence by
                         * the bulk-out maxpacket size */
-                       bh->outreq->length = amount;
+                       bh->outreq->length = bh->bulk_out_intended_length =
+                                       amount;
                        bh->outreq->short_not_ok = 1;
                        start_transfer(fsg, fsg->bulk_out, bh->outreq,
                                        &bh->outreq_busy, &bh->state);
@@ -1964,7 +1979,8 @@ static int throw_away_data(struct fsg_dev *fsg)
 
                        /* amount is always divisible by 512, hence by
                         * the bulk-out maxpacket size */
-                       bh->outreq->length = amount;
+                       bh->outreq->length = bh->bulk_out_intended_length =
+                                       amount;
                        bh->outreq->short_not_ok = 1;
                        start_transfer(fsg, fsg->bulk_out, bh->outreq,
                                        &bh->outreq_busy, &bh->state);
@@ -2643,8 +2659,8 @@ static int get_next_command(struct fsg_dev *fsg)
                }
 
                /* Queue a request to read a Bulk-only CBW */
-               bh->outreq->length = USB_BULK_CB_WRAP_LEN;
-               bh->outreq->short_not_ok = 0;
+               set_bulk_out_req_length(fsg, bh, USB_BULK_CB_WRAP_LEN);
+               bh->outreq->short_not_ok = 1;
                start_transfer(fsg, fsg->bulk_out, bh->outreq,
                                &bh->outreq_busy, &bh->state);
 

diff --git a/drivers/usb/gadget/storage_common.c b/drivers/usb/gadget/storage_common.c
index 86fcebd..109635a 100644 (file)
--- a/drivers/usb/gadget/storage_common.c
+++ b/drivers/usb/gadget/storage_common.c
@@ -286,6 +286,13 @@ struct fsg_buffhd {
        enum fsg_buffer_state           state;
        struct fsg_buffhd               *next;
 
+       /*
+        * The NetChip 2280 is faster, and handles some protocol faults
+        * better, if we don't submit any short bulk-out read requests.
+        * So we will record the intended request length here.
+        */
+       unsigned int                    bulk_out_intended_length;
+
        struct usb_request              *inreq;
        int                             inreq_busy;
        struct usb_request              *outreq;