26 files changed, 111 insertions, 117 deletions

diff --git a/drivers/usb/gadget/dbgp.c b/drivers/usb/gadget/dbgp.c
index dbe92ee88477..052209e89271 100644
--- a/drivers/usb/gadget/dbgp.c
+++ b/drivers/usb/gadget/dbgp.c
@@ -173,7 +173,9 @@ fail_1:
 
 static int __enable_ep(struct usb_ep *ep, struct usb_endpoint_descriptor *desc)
 {
-        int err = usb_ep_enable(ep, desc);
+        int err;
+        ep->desc = desc;
+        err = usb_ep_enable(ep);
         ep->driver_data = dbgp.gadget;
         return err;
 }
@@ -268,8 +270,8 @@ static int __init dbgp_configure_endpoints(struct usb_gadget *gadget)
         dbgp.serial->in = dbgp.i_ep;
         dbgp.serial->out = dbgp.o_ep;
 
-        dbgp.serial->in_desc = &i_desc;
-        dbgp.serial->out_desc = &o_desc;
+        dbgp.serial->in->desc = &i_desc;
+        dbgp.serial->out->desc = &o_desc;
 
         if (gserial_setup(gadget, 1) < 0) {
                 stp = 3;
diff --git a/drivers/usb/gadget/f_acm.c b/drivers/usb/gadget/f_acm.c
index bd6226cbae86..d04b4a68220d 100644
--- a/drivers/usb/gadget/f_acm.c
+++ b/drivers/usb/gadget/f_acm.c
@@ -62,7 +62,6 @@ struct f_acm {
         struct acm_ep_descs             hs;
 
         struct usb_ep                   *notify;
-        struct usb_endpoint_descriptor  *notify_desc;
         struct usb_request              *notify_req;
 
         struct usb_cdc_line_coding      port_line_coding;       /* 8-N-1 etc */
@@ -405,11 +404,11 @@ static int acm_set_alt(struct usb_function *f, unsigned intf, unsigned alt)
                         usb_ep_disable(acm->notify);
                 } else {
                         VDBG(cdev, "init acm ctrl interface %d\n", intf);
-                        acm->notify_desc = ep_choose(cdev->gadget,
+                        acm->notify->desc = ep_choose(cdev->gadget,
                                         acm->hs.notify,
                                         acm->fs.notify);
                 }
-                usb_ep_enable(acm->notify, acm->notify_desc);
+                usb_ep_enable(acm->notify);
                 acm->notify->driver_data = acm;
 
         } else if (intf == acm->data_id) {
@@ -418,9 +417,9 @@ static int acm_set_alt(struct usb_function *f, unsigned intf, unsigned alt)
                         gserial_disconnect(&acm->port);
                 } else {
                         DBG(cdev, "activate acm ttyGS%d\n", acm->port_num);
-                        acm->port.in_desc = ep_choose(cdev->gadget,
+                        acm->port.in->desc = ep_choose(cdev->gadget,
                                         acm->hs.in, acm->fs.in);
-                        acm->port.out_desc = ep_choose(cdev->gadget,
+                        acm->port.out->desc = ep_choose(cdev->gadget,
                                         acm->hs.out, acm->fs.out);
                 }
                 gserial_connect(&acm->port, acm->port_num);
diff --git a/drivers/usb/gadget/f_audio.c b/drivers/usb/gadget/f_audio.c
index 8ee330a2ab58..02a02700b51d 100644
--- a/drivers/usb/gadget/f_audio.c
+++ b/drivers/usb/gadget/f_audio.c
@@ -279,7 +279,6 @@ struct f_audio {
 
         /* endpoints handle full and/or high speeds */
         struct usb_ep                   *out_ep;
-        struct usb_endpoint_descriptor  *out_desc;
 
         spinlock_t                      lock;
         struct f_audio_buf *copy_buf;
@@ -575,7 +574,7 @@ static int f_audio_set_alt(struct usb_function *f, unsigned intf, unsigned alt)
 
         if (intf == 1) {
                 if (alt == 1) {
-                        usb_ep_enable(out_ep, audio->out_desc);
+                        usb_ep_enable(out_ep);
                         out_ep->driver_data = audio;
                         audio->copy_buf = f_audio_buffer_alloc(audio_buf_size);
                         if (IS_ERR(audio->copy_buf))
@@ -677,6 +676,7 @@ f_audio_bind(struct usb_configuration *c, struct usb_function *f)
         if (!ep)
                 goto fail;
         audio->out_ep = ep;
+        audio->out_ep->desc = &as_out_ep_desc;
         ep->driver_data = cdev; /* claim */
 
         status = -ENOMEM;
@@ -776,7 +776,6 @@ int __init audio_bind_config(struct usb_configuration *c)
         audio->card.func.set_alt = f_audio_set_alt;
         audio->card.func.setup = f_audio_setup;
         audio->card.func.disable = f_audio_disable;
-        audio->out_desc = &as_out_ep_desc;
 
         control_selector_init(audio);
 
diff --git a/drivers/usb/gadget/f_ecm.c b/drivers/usb/gadget/f_ecm.c
index 544257a89ed2..7c996f271ccb 100644
--- a/drivers/usb/gadget/f_ecm.c
+++ b/drivers/usb/gadget/f_ecm.c
@@ -68,7 +68,6 @@ struct f_ecm {
         struct ecm_ep_descs             hs;
 
         struct usb_ep                   *notify;
-        struct usb_endpoint_descriptor  *notify_desc;
         struct usb_request              *notify_req;
         u8                              notify_state;
         bool                            is_open;
@@ -466,11 +465,11 @@ static int ecm_set_alt(struct usb_function *f, unsigned intf, unsigned alt)
                         usb_ep_disable(ecm->notify);
                 } else {
                         VDBG(cdev, "init ecm ctrl %d\n", intf);
-                        ecm->notify_desc = ep_choose(cdev->gadget,
+                        ecm->notify->desc = ep_choose(cdev->gadget,
                                         ecm->hs.notify,
                                         ecm->fs.notify);
                 }
-                usb_ep_enable(ecm->notify, ecm->notify_desc);
+                usb_ep_enable(ecm->notify);
                 ecm->notify->driver_data = ecm;
 
         /* Data interface has two altsettings, 0 and 1 */
@@ -483,11 +482,11 @@ static int ecm_set_alt(struct usb_function *f, unsigned intf, unsigned alt)
                         gether_disconnect(&ecm->port);
                 }
 
-                if (!ecm->port.in) {
+                if (!ecm->port.in_ep->desc) {
                         DBG(cdev, "init ecm\n");
-                        ecm->port.in = ep_choose(cdev->gadget,
+                        ecm->port.in_ep->desc = ep_choose(cdev->gadget,
                                         ecm->hs.in, ecm->fs.in);
-                        ecm->port.out = ep_choose(cdev->gadget,
+                        ecm->port.out_ep->desc = ep_choose(cdev->gadget,
                                         ecm->hs.out, ecm->fs.out);
                 }
 
@@ -549,7 +548,7 @@ static void ecm_disable(struct usb_function *f)
         if (ecm->notify->driver_data) {
                 usb_ep_disable(ecm->notify);
                 ecm->notify->driver_data = NULL;
-                ecm->notify_desc = NULL;
+                ecm->notify->desc = NULL;
         }
 }
 
@@ -723,9 +722,9 @@ fail:
         /* we might as well release our claims on endpoints */
         if (ecm->notify)
                 ecm->notify->driver_data = NULL;
-        if (ecm->port.out)
+        if (ecm->port.out_ep->desc)
                 ecm->port.out_ep->driver_data = NULL;
-        if (ecm->port.in)
+        if (ecm->port.in_ep->desc)
                 ecm->port.in_ep->driver_data = NULL;
 
         ERROR(cdev, "%s: can't bind, err %d\n", f->name, status);
diff --git a/drivers/usb/gadget/f_eem.c b/drivers/usb/gadget/f_eem.c
index b3c304290150..fea8e3b08b5f 100644
--- a/drivers/usb/gadget/f_eem.c
+++ b/drivers/usb/gadget/f_eem.c
@@ -176,11 +176,11 @@ static int eem_set_alt(struct usb_function *f, unsigned intf, unsigned alt)
                         gether_disconnect(&eem->port);
                 }
 
-                if (!eem->port.in) {
+                if (!eem->port.in_ep->desc) {
                         DBG(cdev, "init eem\n");
-                        eem->port.in = ep_choose(cdev->gadget,
+                        eem->port.in_ep->desc = ep_choose(cdev->gadget,
                                         eem->hs.in, eem->fs.in);
-                        eem->port.out = ep_choose(cdev->gadget,
+                        eem->port.out_ep->desc = ep_choose(cdev->gadget,
                                         eem->hs.out, eem->fs.out);
                 }
 
@@ -289,9 +289,9 @@ fail:
                 usb_free_descriptors(f->descriptors);
 
         /* we might as well release our claims on endpoints */
-        if (eem->port.out)
+        if (eem->port.out_ep->desc)
                 eem->port.out_ep->driver_data = NULL;
-        if (eem->port.in)
+        if (eem->port.in_ep->desc)
                 eem->port.in_ep->driver_data = NULL;
 
         ERROR(cdev, "%s: can't bind, err %d\n", f->name, status);
diff --git a/drivers/usb/gadget/f_fs.c b/drivers/usb/gadget/f_fs.c
index 19fffccc370d..c161a9aaeb7e 100644
--- a/drivers/usb/gadget/f_fs.c
+++ b/drivers/usb/gadget/f_fs.c
@@ -1544,7 +1544,8 @@ static int ffs_func_eps_enable(struct ffs_function *func)
                 ds = ep->descs[ep->descs[1] ? 1 : 0];
 
                 ep->ep->driver_data = ep;
-                ret = usb_ep_enable(ep->ep, ds);
+                ep->ep->desc = ds;
+                ret = usb_ep_enable(ep->ep);
                 if (likely(!ret)) {
                         epfile->ep = ep;
                         epfile->in = usb_endpoint_dir_in(ds);
diff --git a/drivers/usb/gadget/f_hid.c b/drivers/usb/gadget/f_hid.c
index 598e7e2ab80c..12879b6f787c 100644
--- a/drivers/usb/gadget/f_hid.c
+++ b/drivers/usb/gadget/f_hid.c
@@ -416,7 +416,6 @@ static int hidg_set_alt(struct usb_function *f, unsigned intf, unsigned alt)
 {
         struct usb_composite_dev                *cdev = f->config->cdev;
         struct f_hidg                           *hidg = func_to_hidg(f);
-        const struct usb_endpoint_descriptor    *ep_desc;
         int status = 0;
 
         VDBG(cdev, "hidg_set_alt intf:%d alt:%d\n", intf, alt);
@@ -426,9 +425,9 @@ static int hidg_set_alt(struct usb_function *f, unsigned intf, unsigned alt)
                 if (hidg->in_ep->driver_data != NULL)
                         usb_ep_disable(hidg->in_ep);
 
-                ep_desc = ep_choose(f->config->cdev->gadget,
+                hidg->in_ep->desc = ep_choose(f->config->cdev->gadget,
                                 hidg->hs_in_ep_desc, hidg->fs_in_ep_desc);
-                status = usb_ep_enable(hidg->in_ep, ep_desc);
+                status = usb_ep_enable(hidg->in_ep);
                 if (status < 0) {
                         ERROR(cdev, "Enable endpoint FAILED!\n");
                         goto fail;
diff --git a/drivers/usb/gadget/f_loopback.c b/drivers/usb/gadget/f_loopback.c
index b37960f9e753..34e3ccaf0884 100644
--- a/drivers/usb/gadget/f_loopback.c
+++ b/drivers/usb/gadget/f_loopback.c
@@ -250,26 +250,24 @@ static int
 enable_loopback(struct usb_composite_dev *cdev, struct f_loopback *loop)
 {
         int                                     result = 0;
-        const struct usb_endpoint_descriptor    *src, *sink;
         struct usb_ep                           *ep;
         struct usb_request                      *req;
         unsigned                                i;
 
-        src = ep_choose(cdev->gadget,
-                        &hs_loop_source_desc, &fs_loop_source_desc);
-        sink = ep_choose(cdev->gadget,
-                        &hs_loop_sink_desc, &fs_loop_sink_desc);
-
         /* one endpoint writes data back IN to the host */
         ep = loop->in_ep;
-        result = usb_ep_enable(ep, src);
+        ep->desc = ep_choose(cdev->gadget,
+                        &hs_loop_source_desc, &fs_loop_source_desc);
+        result = usb_ep_enable(ep);
         if (result < 0)
                 return result;
         ep->driver_data = loop;
 
         /* one endpoint just reads OUT packets */
         ep = loop->out_ep;
-        result = usb_ep_enable(ep, sink);
+        ep->desc = ep_choose(cdev->gadget,
+                        &hs_loop_sink_desc, &fs_loop_sink_desc);
+        result = usb_ep_enable(ep);
         if (result < 0) {
 fail0:
                 ep = loop->in_ep;
diff --git a/drivers/usb/gadget/f_mass_storage.c b/drivers/usb/gadget/f_mass_storage.c
index efb58f9f5aa9..4eee43412121 100644
--- a/drivers/usb/gadget/f_mass_storage.c
+++ b/drivers/usb/gadget/f_mass_storage.c
@@ -2330,7 +2330,8 @@ static int enable_endpoint(struct fsg_common *common, struct usb_ep *ep,
         int     rc;
 
         ep->driver_data = common;
-        rc = usb_ep_enable(ep, d);
+        ep->desc = (struct usb_endpoint_descriptor *)d;
+        rc = usb_ep_enable(ep);
         if (rc)
                 ERROR(common, "can't enable %s, result %d\n", ep->name, rc);
         return rc;
diff --git a/drivers/usb/gadget/f_ncm.c b/drivers/usb/gadget/f_ncm.c
index 86902a60bcdb..06daa1bc9ffd 100644
--- a/drivers/usb/gadget/f_ncm.c
+++ b/drivers/usb/gadget/f_ncm.c
@@ -70,7 +70,6 @@ struct f_ncm {
         struct ncm_ep_descs             hs;
 
         struct usb_ep                   *notify;
-        struct usb_endpoint_descriptor  *notify_desc;
         struct usb_request              *notify_req;
         u8                              notify_state;
         bool                            is_open;
@@ -804,11 +803,11 @@ static int ncm_set_alt(struct usb_function *f, unsigned intf, unsigned alt)
                         usb_ep_disable(ncm->notify);
                 } else {
                         DBG(cdev, "init ncm ctrl %d\n", intf);
-                        ncm->notify_desc = ep_choose(cdev->gadget,
+                        ncm->notify->desc = ep_choose(cdev->gadget,
                                         ncm->hs.notify,
                                         ncm->fs.notify);
                 }
-                usb_ep_enable(ncm->notify, ncm->notify_desc);
+                usb_ep_enable(ncm->notify);
                 ncm->notify->driver_data = ncm;
 
         /* Data interface has two altsettings, 0 and 1 */
@@ -829,12 +828,12 @@ static int ncm_set_alt(struct usb_function *f, unsigned intf, unsigned alt)
                 if (alt == 1) {
                         struct net_device       *net;
 
-                        if (!ncm->port.in) {
+                        if (!ncm->port.in_ep->desc) {
                                 DBG(cdev, "init ncm\n");
-                                ncm->port.in = ep_choose(cdev->gadget,
+                                ncm->port.in_ep->desc = ep_choose(cdev->gadget,
                                                          ncm->hs.in,
                                                          ncm->fs.in);
-                                ncm->port.out = ep_choose(cdev->gadget,
+                                ncm->port.out_ep->desc = ep_choose(cdev->gadget,
                                                           ncm->hs.out,
                                                           ncm->fs.out);
                         }
@@ -1111,7 +1110,7 @@ static void ncm_disable(struct usb_function *f)
         if (ncm->notify->driver_data) {
                 usb_ep_disable(ncm->notify);
                 ncm->notify->driver_data = NULL;
-                ncm->notify_desc = NULL;
+                ncm->notify->desc = NULL;
         }
 }
 
@@ -1288,9 +1287,9 @@ fail:
         /* we might as well release our claims on endpoints */
         if (ncm->notify)
                 ncm->notify->driver_data = NULL;
-        if (ncm->port.out)
+        if (ncm->port.out_ep->desc)
                 ncm->port.out_ep->driver_data = NULL;
-        if (ncm->port.in)
+        if (ncm->port.in_ep->desc)
                 ncm->port.in_ep->driver_data = NULL;
 
         ERROR(cdev, "%s: can't bind, err %d\n", f->name, status);
diff --git a/drivers/usb/gadget/f_obex.c b/drivers/usb/gadget/f_obex.c
index 8f8c64371475..a6dbda090ca5 100644
--- a/drivers/usb/gadget/f_obex.c
+++ b/drivers/usb/gadget/f_obex.c
@@ -227,11 +227,11 @@ static int obex_set_alt(struct usb_function *f, unsigned intf, unsigned alt)
                         gserial_disconnect(&obex->port);
                 }
 
-                if (!obex->port.in_desc) {
+                if (!obex->port.in->desc) {
                         DBG(cdev, "init obex ttyGS%d\n", obex->port_num);
-                        obex->port.in_desc = ep_choose(cdev->gadget,
+                        obex->port.in->desc = ep_choose(cdev->gadget,
                                         obex->hs.obex_in, obex->fs.obex_in);
-                        obex->port.out_desc = ep_choose(cdev->gadget,
+                        obex->port.out->desc = ep_choose(cdev->gadget,
                                         obex->hs.obex_out, obex->fs.obex_out);
                 }
 
diff --git a/drivers/usb/gadget/f_phonet.c b/drivers/usb/gadget/f_phonet.c
index 5e1495097ec3..dc63f161a10a 100644
--- a/drivers/usb/gadget/f_phonet.c
+++ b/drivers/usb/gadget/f_phonet.c
@@ -427,17 +427,16 @@ static int pn_set_alt(struct usb_function *f, unsigned intf, unsigned alt)
                 spin_lock(&port->lock);
                 __pn_reset(f);
                 if (alt == 1) {
-                        struct usb_endpoint_descriptor *out, *in;
                         int i;
 
-                        out = ep_choose(gadget,
+                        fp->out_ep->desc = ep_choose(gadget,
                                         &pn_hs_sink_desc,
                                         &pn_fs_sink_desc);
-                        in = ep_choose(gadget,
+                        fp->in_ep->desc = ep_choose(gadget,
                                         &pn_hs_source_desc,
                                         &pn_fs_source_desc);
-                        usb_ep_enable(fp->out_ep, out);
-                        usb_ep_enable(fp->in_ep, in);
+                        usb_ep_enable(fp->out_ep);
+                        usb_ep_enable(fp->in_ep);
 
                         port->usb = fp;
                         fp->out_ep->driver_data = fp;
diff --git a/drivers/usb/gadget/f_rndis.c b/drivers/usb/gadget/f_rndis.c
index fa12ec8364ef..4646254a8924 100644
--- a/drivers/usb/gadget/f_rndis.c
+++ b/drivers/usb/gadget/f_rndis.c
@@ -92,7 +92,6 @@ struct f_rndis {
         struct rndis_ep_descs           hs;
 
         struct usb_ep                   *notify;
-        struct usb_endpoint_descriptor  *notify_desc;
         struct usb_request              *notify_req;
         atomic_t                        notify_count;
 };
@@ -486,11 +485,11 @@ static int rndis_set_alt(struct usb_function *f, unsigned intf, unsigned alt)
                         usb_ep_disable(rndis->notify);
                 } else {
                         VDBG(cdev, "init rndis ctrl %d\n", intf);
-                        rndis->notify_desc = ep_choose(cdev->gadget,
+                        rndis->notify->desc = ep_choose(cdev->gadget,
                                         rndis->hs.notify,
                                         rndis->fs.notify);
                 }
-                usb_ep_enable(rndis->notify, rndis->notify_desc);
+                usb_ep_enable(rndis->notify);
                 rndis->notify->driver_data = rndis;
 
         } else if (intf == rndis->data_id) {
@@ -501,11 +500,11 @@ static int rndis_set_alt(struct usb_function *f, unsigned intf, unsigned alt)
                         gether_disconnect(&rndis->port);
                 }
 
-                if (!rndis->port.in) {
+                if (!rndis->port.in_ep->desc) {
                         DBG(cdev, "init rndis\n");
-                        rndis->port.in = ep_choose(cdev->gadget,
+                        rndis->port.in_ep->desc = ep_choose(cdev->gadget,
                                         rndis->hs.in, rndis->fs.in);
-                        rndis->port.out = ep_choose(cdev->gadget,
+                        rndis->port.out_ep->desc = ep_choose(cdev->gadget,
                                         rndis->hs.out, rndis->fs.out);
                 }
 
@@ -738,9 +737,9 @@ fail:
         /* we might as well release our claims on endpoints */
         if (rndis->notify)
                 rndis->notify->driver_data = NULL;
-        if (rndis->port.out)
+        if (rndis->port.out_ep->desc)
                 rndis->port.out_ep->driver_data = NULL;
-        if (rndis->port.in)
+        if (rndis->port.in_ep->desc)
                 rndis->port.in_ep->driver_data = NULL;
 
         ERROR(cdev, "%s: can't bind, err %d\n", f->name, status);
diff --git a/drivers/usb/gadget/f_serial.c b/drivers/usb/gadget/f_serial.c
index 490b00b01a7d..a9ce6261d156 100644
--- a/drivers/usb/gadget/f_serial.c
+++ b/drivers/usb/gadget/f_serial.c
@@ -138,9 +138,9 @@ static int gser_set_alt(struct usb_function *f, unsigned intf, unsigned alt)
                 gserial_disconnect(&gser->port);
         } else {
                 DBG(cdev, "activate generic ttyGS%d\n", gser->port_num);
-                gser->port.in_desc = ep_choose(cdev->gadget,
+                gser->port.in->desc = ep_choose(cdev->gadget,
                                 gser->hs.in, gser->fs.in);
-                gser->port.out_desc = ep_choose(cdev->gadget,
+                gser->port.out->desc = ep_choose(cdev->gadget,
                                 gser->hs.out, gser->fs.out);
         }
         gserial_connect(&gser->port, gser->port_num);
diff --git a/drivers/usb/gadget/f_sourcesink.c b/drivers/usb/gadget/f_sourcesink.c
index e403a534dd55..0ffddd33a55c 100644
--- a/drivers/usb/gadget/f_sourcesink.c
+++ b/drivers/usb/gadget/f_sourcesink.c
@@ -343,15 +343,12 @@ static int
 enable_source_sink(struct usb_composite_dev *cdev, struct f_sourcesink *ss)
 {
         int                                     result = 0;
-        const struct usb_endpoint_descriptor    *src, *sink;
         struct usb_ep                           *ep;
 
-        src = ep_choose(cdev->gadget, &hs_source_desc, &fs_source_desc);
-        sink = ep_choose(cdev->gadget, &hs_sink_desc, &fs_sink_desc);
-
         /* one endpoint writes (sources) zeroes IN (to the host) */
         ep = ss->in_ep;
-        result = usb_ep_enable(ep, src);
+        ep->desc = ep_choose(cdev->gadget, &hs_source_desc, &fs_source_desc);
+        result = usb_ep_enable(ep);
         if (result < 0)
                 return result;
         ep->driver_data = ss;
@@ -367,7 +364,8 @@ fail:
 
         /* one endpoint reads (sinks) anything OUT (from the host) */
         ep = ss->out_ep;
-        result = usb_ep_enable(ep, sink);
+        ep->desc = ep_choose(cdev->gadget, &hs_sink_desc, &fs_sink_desc);
+        result = usb_ep_enable(ep);
         if (result < 0)
                 goto fail;
         ep->driver_data = ss;
diff --git a/drivers/usb/gadget/f_subset.c b/drivers/usb/gadget/f_subset.c
index 8675ca415329..aecaed1724aa 100644
--- a/drivers/usb/gadget/f_subset.c
+++ b/drivers/usb/gadget/f_subset.c
@@ -243,9 +243,9 @@ static int geth_set_alt(struct usb_function *f, unsigned intf, unsigned alt)
         }
 
         DBG(cdev, "init + activate cdc subset\n");
-        geth->port.in = ep_choose(cdev->gadget,
+        geth->port.in_ep->desc = ep_choose(cdev->gadget,
                         geth->hs.in, geth->fs.in);
-        geth->port.out = ep_choose(cdev->gadget,
+        geth->port.out_ep->desc = ep_choose(cdev->gadget,
                         geth->hs.out, geth->fs.out);
 
         net = gether_connect(&geth->port);
@@ -334,9 +334,9 @@ geth_bind(struct usb_configuration *c, struct usb_function *f)
 
 fail:
         /* we might as well release our claims on endpoints */
-        if (geth->port.out)
+        if (geth->port.out_ep->desc)
                 geth->port.out_ep->driver_data = NULL;
-        if (geth->port.in)
+        if (geth->port.in_ep->desc)
                 geth->port.in_ep->driver_data = NULL;
 
         ERROR(cdev, "%s: can't bind, err %d\n", f->name, status);
diff --git a/drivers/usb/gadget/f_uvc.c b/drivers/usb/gadget/f_uvc.c
index be446b7e7eaa..df74d0311910 100644
--- a/drivers/usb/gadget/f_uvc.c
+++ b/drivers/usb/gadget/f_uvc.c
@@ -262,8 +262,10 @@ uvc_function_set_alt(struct usb_function *f, unsigned interface, unsigned alt)
                 if (uvc->state != UVC_STATE_CONNECTED)
                         return 0;
 
-                if (uvc->video.ep)
-                        usb_ep_enable(uvc->video.ep, &uvc_streaming_ep);
+                if (uvc->video.ep) {
+                        uvc->video.ep->desc = &uvc_streaming_ep;
+                        usb_ep_enable(uvc->video.ep);
+                }
 
                 memset(&v4l2_event, 0, sizeof(v4l2_event));
                 v4l2_event.type = UVC_EVENT_STREAMON;
diff --git a/drivers/usb/gadget/file_storage.c b/drivers/usb/gadget/file_storage.c
index 83bee30cdb94..738591a64bb4 100644
--- a/drivers/usb/gadget/file_storage.c
+++ b/drivers/usb/gadget/file_storage.c
@@ -2713,7 +2713,8 @@ static int enable_endpoint(struct fsg_dev *fsg, struct usb_ep *ep,
         int     rc;
 
         ep->driver_data = fsg;
-        rc = usb_ep_enable(ep, d);
+        ep->desc = d;
+        rc = usb_ep_enable(ep);
         if (rc)
                 ERROR(fsg, "can't enable %s, result %d\n", ep->name, rc);
         return rc;
diff --git a/drivers/usb/gadget/gmidi.c b/drivers/usb/gadget/gmidi.c
index 47b86b99d449..4f40f1467438 100644
--- a/drivers/usb/gadget/gmidi.c
+++ b/drivers/usb/gadget/gmidi.c
@@ -537,14 +537,16 @@ static int set_gmidi_config(struct gmidi_device *dev, gfp_t gfp_flags)
         struct usb_ep *ep;
         unsigned i;
 
-        err = usb_ep_enable(dev->in_ep, &bulk_in_desc);
+        dev->in_ep->desc = &bulk_in_desc;
+        err = usb_ep_enable(dev->in_ep);
         if (err) {
                 ERROR(dev, "can't start %s: %d\n", dev->in_ep->name, err);
                 goto fail;
         }
         dev->in_ep->driver_data = dev;
 
-        err = usb_ep_enable(dev->out_ep, &bulk_out_desc);
+        dev->out_ep->desc = &bulk_out_desc;
+        err = usb_ep_enable(dev->out_ep);
         if (err) {
                 ERROR(dev, "can't start %s: %d\n", dev->out_ep->name, err);
                 goto fail;
diff --git a/drivers/usb/gadget/inode.c b/drivers/usb/gadget/inode.c
index a56876aaf76c..a9a455692397 100644
--- a/drivers/usb/gadget/inode.c
+++ b/drivers/usb/gadget/inode.c
@@ -832,14 +832,16 @@ ep_config (struct file *fd, const char __user *buf, size_t len, loff_t *ptr)
         switch (data->dev->gadget->speed) {
         case USB_SPEED_LOW:
         case USB_SPEED_FULL:
-                value = usb_ep_enable (ep, &data->desc);
+                ep->desc = &data->desc;
+                value = usb_ep_enable(ep);
                 if (value == 0)
                         data->state = STATE_EP_ENABLED;
                 break;
 #ifdef  CONFIG_USB_GADGET_DUALSPEED
         case USB_SPEED_HIGH:
                 /* fails if caller didn't provide that descriptor... */
-                value = usb_ep_enable (ep, &data->hs_desc);
+                ep->desc = &data->hs_desc;
+                value = usb_ep_enable(ep);
                 if (value == 0)
                         data->state = STATE_EP_ENABLED;
                 break;
diff --git a/drivers/usb/gadget/printer.c b/drivers/usb/gadget/printer.c
index 271ef94668e7..00e5f19c75ba 100644
--- a/drivers/usb/gadget/printer.c
+++ b/drivers/usb/gadget/printer.c
@@ -89,8 +89,7 @@ struct printer_dev {
         u8                      config;
         s8                      interface;
         struct usb_ep           *in_ep, *out_ep;
-        const struct usb_endpoint_descriptor
-                                *in, *out;
+
         struct list_head        rx_reqs;        /* List of free RX structs */
         struct list_head        rx_reqs_active; /* List of Active RX xfers */
         struct list_head        rx_buffers;     /* List of completed xfers */
@@ -895,19 +894,20 @@ set_printer_interface(struct printer_dev *dev)
 {
         int                     result = 0;
 
-        dev->in = ep_desc(dev->gadget, &hs_ep_in_desc, &fs_ep_in_desc);
+        dev->in_ep->desc = ep_desc(dev->gadget, &hs_ep_in_desc, &fs_ep_in_desc);
         dev->in_ep->driver_data = dev;
 
-        dev->out = ep_desc(dev->gadget, &hs_ep_out_desc, &fs_ep_out_desc);
+        dev->out_ep->desc = ep_desc(dev->gadget, &hs_ep_out_desc,
+                                    &fs_ep_out_desc);
         dev->out_ep->driver_data = dev;
 
-        result = usb_ep_enable(dev->in_ep, dev->in);
+        result = usb_ep_enable(dev->in_ep);
         if (result != 0) {
                 DBG(dev, "enable %s --> %d\n", dev->in_ep->name, result);
                 goto done;
         }
 
-        result = usb_ep_enable(dev->out_ep, dev->out);
+        result = usb_ep_enable(dev->out_ep);
         if (result != 0) {
                 DBG(dev, "enable %s --> %d\n", dev->in_ep->name, result);
                 goto done;
@@ -918,8 +918,8 @@ done:
         if (result != 0) {
                 (void) usb_ep_disable(dev->in_ep);
                 (void) usb_ep_disable(dev->out_ep);
-                dev->in = NULL;
-                dev->out = NULL;
+                dev->in_ep->desc = NULL;
+                dev->out_ep->desc = NULL;
         }
 
         /* caller is responsible for cleanup on error */
@@ -933,12 +933,14 @@ static void printer_reset_interface(struct printer_dev *dev)
 
         DBG(dev, "%s\n", __func__);
 
-        if (dev->in)
+        if (dev->in_ep->desc)
                 usb_ep_disable(dev->in_ep);
 
-        if (dev->out)
+        if (dev->out_ep->desc)
                 usb_ep_disable(dev->out_ep);
 
+        dev->in_ep->desc = NULL;
+        dev->out_ep->desc = NULL;
         dev->interface = -1;
 }
 
@@ -1104,9 +1106,9 @@ static void printer_soft_reset(struct printer_dev *dev)
                 list_add(&req->list, &dev->tx_reqs);
         }
 
-        if (usb_ep_enable(dev->in_ep, dev->in))
+        if (usb_ep_enable(dev->in_ep))
                 DBG(dev, "Failed to enable USB in_ep\n");
-        if (usb_ep_enable(dev->out_ep, dev->out))
+        if (usb_ep_enable(dev->out_ep))
                 DBG(dev, "Failed to enable USB out_ep\n");
 
         wake_up_interruptible(&dev->rx_wait);
diff --git a/drivers/usb/gadget/u_ether.c b/drivers/usb/gadget/u_ether.c
index 2ac1d2147325..b91363e88db7 100644
--- a/drivers/usb/gadget/u_ether.c
+++ b/drivers/usb/gadget/u_ether.c
@@ -693,8 +693,8 @@ static int eth_stop(struct net_device *net)
                 usb_ep_disable(link->out_ep);
                 if (netif_carrier_ok(net)) {
                         DBG(dev, "host still using in/out endpoints\n");
-                        usb_ep_enable(link->in_ep, link->in);
-                        usb_ep_enable(link->out_ep, link->out);
+                        usb_ep_enable(link->in_ep);
+                        usb_ep_enable(link->out_ep);
                 }
         }
         spin_unlock_irqrestore(&dev->lock, flags);
@@ -871,7 +871,7 @@ struct net_device *gether_connect(struct gether *link)
                 return ERR_PTR(-EINVAL);
 
         link->in_ep->driver_data = dev;
-        result = usb_ep_enable(link->in_ep, link->in);
+        result = usb_ep_enable(link->in_ep);
         if (result != 0) {
                 DBG(dev, "enable %s --> %d\n",
                         link->in_ep->name, result);
@@ -879,7 +879,7 @@ struct net_device *gether_connect(struct gether *link)
         }
 
         link->out_ep->driver_data = dev;
-        result = usb_ep_enable(link->out_ep, link->out);
+        result = usb_ep_enable(link->out_ep);
         if (result != 0) {
                 DBG(dev, "enable %s --> %d\n",
                         link->out_ep->name, result);
@@ -969,7 +969,7 @@ void gether_disconnect(struct gether *link)
         }
         spin_unlock(&dev->req_lock);
         link->in_ep->driver_data = NULL;
-        link->in = NULL;
+        link->in_ep->desc = NULL;
 
         usb_ep_disable(link->out_ep);
         spin_lock(&dev->req_lock);
@@ -984,7 +984,7 @@ void gether_disconnect(struct gether *link)
         }
         spin_unlock(&dev->req_lock);
         link->out_ep->driver_data = NULL;
-        link->out = NULL;
+        link->out_ep->desc = NULL;
 
         /* finish forgetting about this USB link episode */
         dev->header_len = 0;
diff --git a/drivers/usb/gadget/u_ether.h b/drivers/usb/gadget/u_ether.h
index b56e1e7d423c..c966440ddd70 100644
--- a/drivers/usb/gadget/u_ether.h
+++ b/drivers/usb/gadget/u_ether.h
@@ -52,10 +52,6 @@ struct gether {
         struct usb_ep                   *in_ep;
         struct usb_ep                   *out_ep;
 
-        /* descriptors match device speed at gether_connect() time */
-        struct usb_endpoint_descriptor  *in;
-        struct usb_endpoint_descriptor  *out;
-
         bool                            is_zlp_ok;
 
         u16                             cdc_filter;
diff --git a/drivers/usb/gadget/u_serial.c b/drivers/usb/gadget/u_serial.c
index 40f7716b31fc..a8aa46962d81 100644
--- a/drivers/usb/gadget/u_serial.c
+++ b/drivers/usb/gadget/u_serial.c
@@ -1247,12 +1247,12 @@ int gserial_connect(struct gserial *gser, u8 port_num)
         port = ports[port_num].port;
 
         /* activate the endpoints */
-        status = usb_ep_enable(gser->in, gser->in_desc);
+        status = usb_ep_enable(gser->in);
         if (status < 0)
                 return status;
         gser->in->driver_data = port;
 
-        status = usb_ep_enable(gser->out, gser->out_desc);
+        status = usb_ep_enable(gser->out);
         if (status < 0)
                 goto fail_out;
         gser->out->driver_data = port;
diff --git a/drivers/usb/gadget/u_serial.h b/drivers/usb/gadget/u_serial.h
index 300f0ed9475d..9b0fe6450fbf 100644
--- a/drivers/usb/gadget/u_serial.h
+++ b/drivers/usb/gadget/u_serial.h
@@ -35,8 +35,6 @@ struct gserial {
 
         struct usb_ep                   *in;
         struct usb_ep                   *out;
-        struct usb_endpoint_descriptor  *in_desc;
-        struct usb_endpoint_descriptor  *out_desc;
 
         /* REVISIT avoid this CDC-ACM support harder ... */
         struct usb_cdc_line_coding port_line_coding;    /* 9600-8-N-1 etc */
diff --git a/include/linux/usb/gadget.h b/include/linux/usb/gadget.h
index 18979cfb6d66..fe50912585f8 100644
--- a/include/linux/usb/gadget.h
+++ b/include/linux/usb/gadget.h
@@ -132,8 +132,9 @@ struct usb_ep_ops {
  * @maxpacket:The maximum packet size used on this endpoint.  The initial
  *      value can sometimes be reduced (hardware allowing), according to
  *      the endpoint descriptor used to configure the endpoint.
- * @driver_data:for use by the gadget driver.  all other fields are
- *      read-only to gadget drivers.
+ * @driver_data:for use by the gadget driver.
+ * @desc: endpoint descriptor.  This pointer is set before the endpoint is
+ *      enabled and remains valid until the endpoint is disabled.
  *
  * the bus controller driver lists all the general purpose endpoints in
  * gadget->ep_list.  the control endpoint (gadget->ep0) is not in that list,
@@ -146,6 +147,7 @@ struct usb_ep {
         const struct usb_ep_ops *ops;
         struct list_head        ep_list;
         unsigned                maxpacket:16;
+        const struct usb_endpoint_descriptor    *desc;
 };
 
 /*-------------------------------------------------------------------------*/
@@ -154,11 +156,8 @@ struct usb_ep {
  * usb_ep_enable - configure endpoint, making it usable
  * @ep:the endpoint being configured.  may not be the endpoint named "ep0".
  *      drivers discover endpoints through the ep_list of a usb_gadget.
- * @desc:descriptor for desired behavior.  caller guarantees this pointer
- *      remains valid until the endpoint is disabled; the data byte order
- *      is little-endian (usb-standard).
  *
- * when configurations are set, or when interface settings change, the driver
+ * When configurations are set, or when interface settings change, the driver
  * will enable or disable the relevant endpoints.  while it is enabled, an
  * endpoint may be used for i/o until the driver receives a disconnect() from
  * the host or until the endpoint is disabled.
@@ -173,10 +172,9 @@ struct usb_ep {
  *
  * returns zero, or a negative error code.
  */
-static inline int usb_ep_enable(struct usb_ep *ep,
-                                const struct usb_endpoint_descriptor *desc)
+static inline int usb_ep_enable(struct usb_ep *ep)
 {
-        return ep->ops->enable(ep, desc);
+        return ep->ops->enable(ep, ep->desc);
 }
 
 /**