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>

diff --git a/drivers/usb/gadget/f_mass_storage.c b/drivers/usb/gadget/f_mass_storage.c
index 6d8e533949eb3cb3a7c13212f36610e1b25090d9..125587ac5d0b0ff4cf5f7c8e4192affffc97681a 100644 (file)
--- 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 a6eacb59571b6075bddbb6388b132135334d0206..d04e0e6b019dc9db9b8d2e00d6640fd471f3331f 100644 (file)
--- 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 b015561fd602a526d6c76aa52cff3a04f94d026e..3179b8bb6ceda3ed3f1dab2760ed8ad603c5f367 100644 (file)
--- 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;