int usb_assign_descriptors(struct usb_function *f,
                struct usb_descriptor_header **fs,
                struct usb_descriptor_header **hs,
-               struct usb_descriptor_header **ss)
+               struct usb_descriptor_header **ss,
+               struct usb_descriptor_header **ssp)
 {
        struct usb_gadget *g = f->config->cdev->gadget;
 
 
        acm_ss_out_desc.bEndpointAddress = acm_fs_out_desc.bEndpointAddress;
 
        status = usb_assign_descriptors(f, acm_fs_function, acm_hs_function,
-                       acm_ss_function);
+                       acm_ss_function, NULL);
        if (status)
                goto fail;
 
 
                fs_ecm_notify_desc.bEndpointAddress;
 
        status = usb_assign_descriptors(f, ecm_fs_function, ecm_hs_function,
-                       ecm_ss_function);
+                       ecm_ss_function, NULL);
        if (status)
                goto fail;
 
 
        eem_ss_out_desc.bEndpointAddress = eem_fs_out_desc.bEndpointAddress;
 
        status = usb_assign_descriptors(f, eem_fs_function, eem_hs_function,
-                       eem_ss_function);
+                       eem_ss_function, NULL);
        if (status)
                goto fail;
 
 
                hidg_fs_out_ep_desc.bEndpointAddress;
 
        status = usb_assign_descriptors(f, hidg_fs_descriptors,
-                       hidg_hs_descriptors, NULL);
+                       hidg_hs_descriptors, NULL, NULL);
        if (status)
                goto fail;
 
 
        ss_loop_sink_desc.bEndpointAddress = fs_loop_sink_desc.bEndpointAddress;
 
        ret = usb_assign_descriptors(f, fs_loopback_descs, hs_loopback_descs,
-                       ss_loopback_descs);
+                       ss_loopback_descs, NULL);
        if (ret)
                return ret;
 
 
        fsg_ss_bulk_out_comp_desc.bMaxBurst = max_burst;
 
        ret = usb_assign_descriptors(f, fsg_fs_function, fsg_hs_function,
-                       fsg_ss_function);
+                       fsg_ss_function, NULL);
        if (ret)
                goto autoconf_fail;
 
 
                fs_ncm_notify_desc.bEndpointAddress;
 
        status = usb_assign_descriptors(f, ncm_fs_function, ncm_hs_function,
-                       NULL);
+                       NULL, NULL);
        if (status)
                goto fail;
 
 
        obex_hs_ep_out_desc.bEndpointAddress =
                obex_fs_ep_out_desc.bEndpointAddress;
 
-       status = usb_assign_descriptors(f, fs_function, hs_function, NULL);
+       status = usb_assign_descriptors(f, fs_function, hs_function, NULL,
+                                       NULL);
        if (status)
                goto fail;
 
 
 
        /* Do not try to bind Phonet twice... */
        status = usb_assign_descriptors(f, fs_pn_function, hs_pn_function,
-                       NULL);
+                       NULL, NULL);
        if (status)
                goto err;
 
 
        ss_ep_out_desc.bEndpointAddress = fs_ep_out_desc.bEndpointAddress;
 
        ret = usb_assign_descriptors(f, fs_printer_function,
-                       hs_printer_function, ss_printer_function);
+                       hs_printer_function, ss_printer_function, NULL);
        if (ret)
                return ret;
 
 
        ss_notify_desc.bEndpointAddress = fs_notify_desc.bEndpointAddress;
 
        status = usb_assign_descriptors(f, eth_fs_function, eth_hs_function,
-                       eth_ss_function);
+                       eth_ss_function, NULL);
        if (status)
                goto fail;
 
 
        gser_ss_out_desc.bEndpointAddress = gser_fs_out_desc.bEndpointAddress;
 
        status = usb_assign_descriptors(f, gser_fs_function, gser_hs_function,
-                       gser_ss_function);
+                       gser_ss_function, NULL);
        if (status)
                goto fail;
        dev_dbg(&cdev->gadget->dev, "generic ttyGS%d: %s speed IN/%s OUT/%s\n",
 
        ss_iso_sink_desc.bEndpointAddress = fs_iso_sink_desc.bEndpointAddress;
 
        ret = usb_assign_descriptors(f, fs_source_sink_descs,
-                       hs_source_sink_descs, ss_source_sink_descs);
+                       hs_source_sink_descs, ss_source_sink_descs, NULL);
        if (ret)
                return ret;
 
 
                fs_subset_out_desc.bEndpointAddress;
 
        status = usb_assign_descriptors(f, fs_eth_function, hs_eth_function,
-                       ss_eth_function);
+                       ss_eth_function, NULL);
        if (status)
                goto fail;
 
 
        uasp_fs_cmd_desc.bEndpointAddress = uasp_ss_cmd_desc.bEndpointAddress;
 
        ret = usb_assign_descriptors(f, uasp_fs_function_desc,
-                       uasp_hs_function_desc, uasp_ss_function_desc);
+                       uasp_hs_function_desc, uasp_ss_function_desc, NULL);
        if (ret)
                goto ep_fail;
 
 
        status = -ENOMEM;
 
        /* copy descriptors, and track endpoint copies */
-       status = usb_assign_descriptors(f, f_audio_desc, f_audio_desc, NULL);
+       status = usb_assign_descriptors(f, f_audio_desc, f_audio_desc, NULL,
+                                       NULL);
        if (status)
                goto fail;
        return 0;
 
        hs_epout_desc.bEndpointAddress = fs_epout_desc.bEndpointAddress;
        hs_epin_desc.bEndpointAddress = fs_epin_desc.bEndpointAddress;
 
-       ret = usb_assign_descriptors(fn, fs_audio_desc, hs_audio_desc, NULL);
+       ret = usb_assign_descriptors(fn, fs_audio_desc, hs_audio_desc, NULL,
+                                    NULL);
        if (ret)
                goto err;
 
 
 int usb_assign_descriptors(struct usb_function *f,
                struct usb_descriptor_header **fs,
                struct usb_descriptor_header **hs,
-               struct usb_descriptor_header **ss);
+               struct usb_descriptor_header **ss,
+               struct usb_descriptor_header **ssp);
 void usb_free_all_descriptors(struct usb_function *f);
 
 struct usb_descriptor_header *usb_otg_descriptor_alloc(