1 files changed, 128 insertions, 8 deletions

diff --git a/drivers/usb/gadget/function/f_uvc.c b/drivers/usb/gadget/function/f_uvc.c
index 945b3bd2ca98..76891adfba7a 100644
--- a/drivers/usb/gadget/function/f_uvc.c
+++ b/drivers/usb/gadget/function/f_uvc.c
@@ -27,10 +27,11 @@
 #include <media/v4l2-dev.h>
 #include <media/v4l2-event.h>
 
+#include "u_uvc.h"
 #include "uvc.h"
+#include "uvc_configfs.h"
 #include "uvc_v4l2.h"
 #include "uvc_video.h"
-#include "u_uvc.h"
 
 unsigned int uvc_gadget_trace_param;
 
@@ -509,6 +510,9 @@ uvc_copy_descriptors(struct uvc_device *uvc, enum usb_device_speed speed)
                 break;
         }
 
+        if (!uvc_control_desc || !uvc_streaming_cls)
+                return ERR_PTR(-ENODEV);
+
         /* Descriptors layout
          *
          * uvc_iad
@@ -605,7 +609,7 @@ uvc_function_bind(struct usb_configuration *c, struct usb_function *f)
 
         INFO(cdev, "uvc_function_bind\n");
 
-        opts = to_f_uvc_opts(f->fi);
+        opts = fi_to_f_uvc_opts(f->fi);
         /* Sanity check the streaming endpoint module parameters.
          */
         opts->streaming_interval = clamp(opts->streaming_interval, 1U, 16U);
@@ -700,10 +704,27 @@ uvc_function_bind(struct usb_configuration *c, struct usb_function *f)
 
         /* Copy descriptors */
         f->fs_descriptors = uvc_copy_descriptors(uvc, USB_SPEED_FULL);
-        if (gadget_is_dualspeed(cdev->gadget))
+        if (IS_ERR(f->fs_descriptors)) {
+                ret = PTR_ERR(f->fs_descriptors);
+                f->fs_descriptors = NULL;
+                goto error;
+        }
+        if (gadget_is_dualspeed(cdev->gadget)) {
                 f->hs_descriptors = uvc_copy_descriptors(uvc, USB_SPEED_HIGH);
-        if (gadget_is_superspeed(c->cdev->gadget))
+                if (IS_ERR(f->hs_descriptors)) {
+                        ret = PTR_ERR(f->hs_descriptors);
+                        f->hs_descriptors = NULL;
+                        goto error;
+                }
+        }
+        if (gadget_is_superspeed(c->cdev->gadget)) {
                 f->ss_descriptors = uvc_copy_descriptors(uvc, USB_SPEED_SUPER);
+                if (IS_ERR(f->ss_descriptors)) {
+                        ret = PTR_ERR(f->ss_descriptors);
+                        f->ss_descriptors = NULL;
+                        goto error;
+                }
+        }
 
         /* Preallocate control endpoint request. */
         uvc->control_req = usb_ep_alloc_request(cdev->gadget->ep0, GFP_KERNEL);
@@ -766,27 +787,106 @@ error:
 
 static void uvc_free_inst(struct usb_function_instance *f)
 {
-        struct f_uvc_opts *opts = to_f_uvc_opts(f);
+        struct f_uvc_opts *opts = fi_to_f_uvc_opts(f);
 
+        mutex_destroy(&opts->lock);
         kfree(opts);
 }
 
 static struct usb_function_instance *uvc_alloc_inst(void)
 {
         struct f_uvc_opts *opts;
+        struct uvc_camera_terminal_descriptor *cd;
+        struct uvc_processing_unit_descriptor *pd;
+        struct uvc_output_terminal_descriptor *od;
+        struct uvc_color_matching_descriptor *md;
+        struct uvc_descriptor_header **ctl_cls;
 
         opts = kzalloc(sizeof(*opts), GFP_KERNEL);
         if (!opts)
                 return ERR_PTR(-ENOMEM);
         opts->func_inst.free_func_inst = uvc_free_inst;
-
+        mutex_init(&opts->lock);
+
+        cd = &opts->uvc_camera_terminal;
+        cd->bLength                     = UVC_DT_CAMERA_TERMINAL_SIZE(3);
+        cd->bDescriptorType             = USB_DT_CS_INTERFACE;
+        cd->bDescriptorSubType          = UVC_VC_INPUT_TERMINAL;
+        cd->bTerminalID                 = 1;
+        cd->wTerminalType               = cpu_to_le16(0x0201);
+        cd->bAssocTerminal              = 0;
+        cd->iTerminal                   = 0;
+        cd->wObjectiveFocalLengthMin    = cpu_to_le16(0);
+        cd->wObjectiveFocalLengthMax    = cpu_to_le16(0);
+        cd->wOcularFocalLength          = cpu_to_le16(0);
+        cd->bControlSize                = 3;
+        cd->bmControls[0]               = 2;
+        cd->bmControls[1]               = 0;
+        cd->bmControls[2]               = 0;
+
+        pd = &opts->uvc_processing;
+        pd->bLength                     = UVC_DT_PROCESSING_UNIT_SIZE(2);
+        pd->bDescriptorType             = USB_DT_CS_INTERFACE;
+        pd->bDescriptorSubType          = UVC_VC_PROCESSING_UNIT;
+        pd->bUnitID                     = 2;
+        pd->bSourceID                   = 1;
+        pd->wMaxMultiplier              = cpu_to_le16(16*1024);
+        pd->bControlSize                = 2;
+        pd->bmControls[0]               = 1;
+        pd->bmControls[1]               = 0;
+        pd->iProcessing                 = 0;
+
+        od = &opts->uvc_output_terminal;
+        od->bLength                     = UVC_DT_OUTPUT_TERMINAL_SIZE;
+        od->bDescriptorType             = USB_DT_CS_INTERFACE;
+        od->bDescriptorSubType          = UVC_VC_OUTPUT_TERMINAL;
+        od->bTerminalID                 = 3;
+        od->wTerminalType               = cpu_to_le16(0x0101);
+        od->bAssocTerminal              = 0;
+        od->bSourceID                   = 2;
+        od->iTerminal                   = 0;
+
+        md = &opts->uvc_color_matching;
+        md->bLength                     = UVC_DT_COLOR_MATCHING_SIZE;
+        md->bDescriptorType             = USB_DT_CS_INTERFACE;
+        md->bDescriptorSubType          = UVC_VS_COLORFORMAT;
+        md->bColorPrimaries             = 1;
+        md->bTransferCharacteristics    = 1;
+        md->bMatrixCoefficients         = 4;
+
+        /* Prepare fs control class descriptors for configfs-based gadgets */
+        ctl_cls = opts->uvc_fs_control_cls;
+        ctl_cls[0] = NULL;      /* assigned elsewhere by configfs */
+        ctl_cls[1] = (struct uvc_descriptor_header *)cd;
+        ctl_cls[2] = (struct uvc_descriptor_header *)pd;
+        ctl_cls[3] = (struct uvc_descriptor_header *)od;
+        ctl_cls[4] = NULL;      /* NULL-terminate */
+        opts->fs_control =
+                (const struct uvc_descriptor_header * const *)ctl_cls;
+
+        /* Prepare hs control class descriptors for configfs-based gadgets */
+        ctl_cls = opts->uvc_ss_control_cls;
+        ctl_cls[0] = NULL;      /* assigned elsewhere by configfs */
+        ctl_cls[1] = (struct uvc_descriptor_header *)cd;
+        ctl_cls[2] = (struct uvc_descriptor_header *)pd;
+        ctl_cls[3] = (struct uvc_descriptor_header *)od;
+        ctl_cls[4] = NULL;      /* NULL-terminate */
+        opts->ss_control =
+                (const struct uvc_descriptor_header * const *)ctl_cls;
+
+        opts->streaming_interval = 1;
+        opts->streaming_maxpacket = 1024;
+
+        uvcg_attach_configfs(opts);
         return &opts->func_inst;
 }
 
 static void uvc_free(struct usb_function *f)
 {
         struct uvc_device *uvc = to_uvc(f);
-
+        struct f_uvc_opts *opts = container_of(f->fi, struct f_uvc_opts,
+                                               func_inst);
+        --opts->refcnt;
         kfree(uvc);
 }
 
@@ -812,19 +912,39 @@ static struct usb_function *uvc_alloc(struct usb_function_instance *fi)
 {
         struct uvc_device *uvc;
         struct f_uvc_opts *opts;
+        struct uvc_descriptor_header **strm_cls;
 
         uvc = kzalloc(sizeof(*uvc), GFP_KERNEL);
         if (uvc == NULL)
                 return ERR_PTR(-ENOMEM);
 
         uvc->state = UVC_STATE_DISCONNECTED;
-        opts = to_f_uvc_opts(fi);
+        opts = fi_to_f_uvc_opts(fi);
+
+        mutex_lock(&opts->lock);
+        if (opts->uvc_fs_streaming_cls) {
+                strm_cls = opts->uvc_fs_streaming_cls;
+                opts->fs_streaming =
+                        (const struct uvc_descriptor_header * const *)strm_cls;
+        }
+        if (opts->uvc_hs_streaming_cls) {
+                strm_cls = opts->uvc_hs_streaming_cls;
+                opts->hs_streaming =
+                        (const struct uvc_descriptor_header * const *)strm_cls;
+        }
+        if (opts->uvc_ss_streaming_cls) {
+                strm_cls = opts->uvc_ss_streaming_cls;
+                opts->ss_streaming =
+                        (const struct uvc_descriptor_header * const *)strm_cls;
+        }
 
         uvc->desc.fs_control = opts->fs_control;
         uvc->desc.ss_control = opts->ss_control;
         uvc->desc.fs_streaming = opts->fs_streaming;
         uvc->desc.hs_streaming = opts->hs_streaming;
         uvc->desc.ss_streaming = opts->ss_streaming;
+        ++opts->refcnt;
+        mutex_unlock(&opts->lock);
 
         /* Register the function. */
         uvc->func.name = "uvc";