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

Mass-storage and file-storage gadgets align the length to maximum-packet-size
when preparing the request to receive CBW. This is unnecessary and prevents the
controller driver from knowing that a short-packet is expected.

It is incorrect to set short_not_ok when preparing the request to receive CBW.
CBW will be a short-packet so short_not_ok must not be set.

This makes bh->bulk_out_intended_length unnecessary so it is also removed.

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

3 files changed, 10 insertions, 49 deletions

diff --git a/drivers/usb/gadget/f_mass_storage.c b/drivers/usb/gadget/f_mass_storage.c
index 6d8e533949eb..125587ac5d0b 100644
--- a/drivers/usb/gadget/f_mass_storage.c
+++ b/drivers/usb/gadget/f_mass_storage.c
@@ -474,20 +474,6 @@ 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)
@@ -586,9 +572,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 != bh->bulk_out_intended_length)
+        if (req->status || req->actual != req->length)
                 DBG(common, "%s --> %d, %u/%u\n", __func__,
-                    req->status, req->actual, bh->bulk_out_intended_length);
+                    req->status, req->actual, req->length);
         if (req->status == -ECONNRESET)         /* Request was cancelled */
                 usb_ep_fifo_flush(ep);
 
@@ -975,7 +961,6 @@ 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 */
@@ -1652,7 +1637,6 @@ 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 */
@@ -2322,8 +2306,8 @@ static int get_next_command(struct fsg_common *common)
         }
 
         /* Queue a request to read a Bulk-only CBW */
-        set_bulk_out_req_length(common, bh, USB_BULK_CB_WRAP_LEN);
-        bh->outreq->short_not_ok = 1;
+        bh->outreq->length = USB_BULK_CB_WRAP_LEN;
+        bh->outreq->short_not_ok = 0;
         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 a6eacb59571b..d04e0e6b019d 100644
--- a/drivers/usb/gadget/file_storage.c
+++ b/drivers/usb/gadget/file_storage.c
@@ -497,19 +497,6 @@ 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;
 
@@ -730,10 +717,9 @@ 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 != bh->bulk_out_intended_length)
+        if (req->status || req->actual != req->length)
                 DBG(fsg, "%s --> %d, %u/%u\n", __func__,
-                                req->status, req->actual,
-                                bh->bulk_out_intended_length);
+                                req->status, req->actual, req->length);
         if (req->status == -ECONNRESET)         // Request was cancelled
                 usb_ep_fifo_flush(ep);
 
@@ -1349,8 +1335,7 @@ static int do_write(struct fsg_dev *fsg)
 
                         /* amount is always divisible by 512, hence by
                          * the bulk-out maxpacket size */
-                        bh->outreq->length = bh->bulk_out_intended_length =
-                                        amount;
+                        bh->outreq->length = amount;
                         bh->outreq->short_not_ok = 1;
                         start_transfer(fsg, fsg->bulk_out, bh->outreq,
                                         &bh->outreq_busy, &bh->state);
@@ -2010,8 +1995,7 @@ 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 = bh->bulk_out_intended_length =
-                                        amount;
+                        bh->outreq->length = amount;
                         bh->outreq->short_not_ok = 1;
                         start_transfer(fsg, fsg->bulk_out, bh->outreq,
                                         &bh->outreq_busy, &bh->state);
@@ -2688,8 +2672,8 @@ static int get_next_command(struct fsg_dev *fsg)
                 }
 
                 /* Queue a request to read a Bulk-only CBW */
-                set_bulk_out_req_length(fsg, bh, USB_BULK_CB_WRAP_LEN);
-                bh->outreq->short_not_ok = 1;
+                bh->outreq->length = USB_BULK_CB_WRAP_LEN;
+                bh->outreq->short_not_ok = 0;
                 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 b015561fd602..3179b8bb6ced 100644
--- a/drivers/usb/gadget/storage_common.c
+++ b/drivers/usb/gadget/storage_common.c
@@ -286,13 +286,6 @@ 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;