usb: gadget: add usb_endpoint_descriptor to struct usb_ep

Change usb_ep_enable() prototype to use endpoint
descriptor from usb_ep.

This optimization spares the FDs from saving the
endpoint chosen descriptor. This optimization is
not full though. To fully exploit this change, one
needs to update all the UDCs as well since in the
current implementation each of them saves the
endpoint descriptor in it's internal (and extended)
endpoint structure.

Signed-off-by: Tatyana Brokhman <tlinder@codeaurora.org>
Signed-off-by: Felipe Balbi <balbi@ti.com>
Signed-off-by: Greg Kroah-Hartman <gregkh@suse.de>

diff --git a/drivers/usb/gadget/dbgp.c b/drivers/usb/gadget/dbgp.c
index dbe92ee88477efc456857a70b2241881c00d7038..052209e89271da9692aa0f63464073f8274e385a 100644 (file)
--- 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 bd6226cbae86fa4b1b201ef8ac88df3942d9858f..d04b4a68220da1d2fd1010773d30e6530ff3545f 100644 (file)
--- 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 8ee330a2ab58249192bcfe03b137392615400db0..02a02700b51d73b1891cb6fe2480158ef89f4799 100644 (file)
--- 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 544257a89ed2ee065fec4b7cb9d743a125457cb8..7c996f271ccb7a4348b7cad95f6ec171d4218088 100644 (file)
--- 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 b3c304290150028cfafca5e9f192862617971ea8..fea8e3b08b5f12408ca6a0fec9fbfa585ee676a5 100644 (file)
--- 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 19fffccc370d3af1e368b5ccd8a98b844c89fa1d..c161a9aaeb7ecc16cb77b9d8e85eb1dcd4b62e1b 100644 (file)
--- 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 598e7e2ab80c666f1395f1db6c30aaa44f34d646..12879b6f787c353bebddce11be0c34aa27e0ec39 100644 (file)
--- 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 b37960f9e75312a106f5b8d969e3ba151072553f..34e3ccaf0884c6657534d05838d418a7fe14d419 100644 (file)
--- 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 efb58f9f5aa90db0fc933301ca10e7008a1295cb..4eee43412121b06ab617124c84a9d7c86ee003eb 100644 (file)
--- 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 86902a60bcdb12c529fda3fc8c66d2789a1c9e99..06daa1bc9ffd9300599c0dbc73a19f5d89ba1422 100644 (file)
--- 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 8f8c64371475c28565e15406894080cf5f10cd07..a6dbda090ca56c58fcd4f4896da9b3b6e493c825 100644 (file)
--- 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 5e1495097ec3bf8ad892c0b653e869c2faed5ab9..dc63f161a10a9e5973d1481fc932d6a14e83c01c 100644 (file)
--- 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 fa12ec8364effe80622eab438102731c5c4215c8..4646254a892423e7e4c020448cec90b88e9c3113 100644 (file)
--- 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 490b00b01a7d68774263c4d84c89b7775eb4acad..a9ce6261d1567285307efd94f5f4459682b7357e 100644 (file)
--- 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 e403a534dd5530f2d485808680f4329b13276dc3..0ffddd33a55c306f2f9d78c26ccd469637b26b3a 100644 (file)
--- 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 8675ca415329ce535ab97e44251884c19c83ed33..aecaed1724aa167ac1a45f6464f9fb6a1f033a22 100644 (file)
--- 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 be446b7e7eaa263d2543552c74ee4e1210591111..df74d0311910bddb967185215481743844cec281 100644 (file)
--- 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 83bee30cdb9439d4a92c4af7d61a3ff9b34a2610..738591a64bb4525bf45f1f7848dffa5dcb905913 100644 (file)
--- 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 47b86b99d449bd3b9117732c3f5b5862773e4ec4..4f40f1467438ba7b1022bdbc5bf625711aef0809 100644 (file)
--- 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 a56876aaf76cdc1dfbec0a331f70739a2a27b04f..a9a455692397e9ed3db8892195efcce925ba626c 100644 (file)
--- 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 271ef94668e719867d12c00a9ce9c1681c825f23..00e5f19c75bac72fda8a1a624ef914f793b916a7 100644 (file)
--- 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 2ac1d21473253f73cdaea0b05b4b81fe027c61f1..b91363e88db741bcc6378ed6eb40d7698ad23b10 100644 (file)
--- 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 b56e1e7d423c0ff531b3f1a594312a293f1db18a..c966440ddd703d97f23f7638c4b5330d821757ff 100644 (file)
--- 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 40f7716b31fcc78244c6db8f36569ddd0cd824cc..a8aa46962d81dba4a3c48bc0b5b1b50df39408ce 100644 (file)
--- 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 300f0ed9475d9799f2f5a5dcc51686ab76211452..9b0fe6450fbfaf88d27d130918d2a73aff53ffd1 100644 (file)
--- 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 18979cfb6d6621ca0c6073652276c820877695e4..fe50912585f8251af455cd8d9cd86c808f1262d9 100644 (file)
--- 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);
 }
 
 /**