usb: gadget: f_uvc: convert f_uvc to new function interface

Use the new function registration interface. It is required
in order to integrate configfs support.

Signed-off-by: Andrzej Pietrasiewicz <andrzej.p@samsung.com>
Tested-by: Michael Grzeschik <m.grzeschik@pengutronix.de>
[Updated copyright years]
Signed-off-by: Laurent Pinchart <laurent.pinchart@ideasonboard.com>
Acked-by: Andrzej Pietrasiewicz <andrzej.p@samsung.com>
Signed-off-by: Felipe Balbi <balbi@ti.com>

5 files changed, 219 insertions, 30 deletions

diff --git a/drivers/usb/gadget/Kconfig b/drivers/usb/gadget/Kconfig
index 68302aa604be..c4880fc0d86e 100644
--- a/drivers/usb/gadget/Kconfig
+++ b/drivers/usb/gadget/Kconfig
@@ -187,6 +187,9 @@ config USB_F_UAC1
 config USB_F_UAC2
         tristate
 
+config USB_F_UVC
+        tristate
+
 choice
         tristate "USB Gadget Drivers"
         default USB_ETH
diff --git a/drivers/usb/gadget/function/Makefile b/drivers/usb/gadget/function/Makefile
index a49fdf7b59e1..90701aa5a826 100644
--- a/drivers/usb/gadget/function/Makefile
+++ b/drivers/usb/gadget/function/Makefile
@@ -36,3 +36,5 @@ usb_f_uac1-y			:= f_uac1.o u_uac1.o
 obj-$(CONFIG_USB_F_UAC1)        += usb_f_uac1.o
 usb_f_uac2-y                    := f_uac2.o
 obj-$(CONFIG_USB_F_UAC2)        += usb_f_uac2.o
+usb_f_uvc-y                     := f_uvc.o uvc_queue.o uvc_v4l2.o uvc_video.o
+obj-$(CONFIG_USB_F_UVC)         += usb_f_uvc.o
diff --git a/drivers/usb/gadget/function/f_uvc.c b/drivers/usb/gadget/function/f_uvc.c
index 825080d271a7..fe50a9b4fa8f 100644
--- a/drivers/usb/gadget/function/f_uvc.c
+++ b/drivers/usb/gadget/function/f_uvc.c
@@ -11,6 +11,7 @@
  */
 
 #include <linux/kernel.h>
+#include <linux/module.h>
 #include <linux/device.h>
 #include <linux/errno.h>
 #include <linux/fs.h>
@@ -29,11 +30,14 @@
 #include "uvc.h"
 #include "uvc_v4l2.h"
 #include "uvc_video.h"
+#include "u_uvc.h"
 
 unsigned int uvc_gadget_trace_param;
+#ifdef USBF_UVC_INCLUDED
 static unsigned int streaming_interval;
 static unsigned int streaming_maxpacket;
 static unsigned int streaming_maxburst;
+#endif
 
 /* --------------------------------------------------------------------------
  * Function descriptors
@@ -65,7 +69,7 @@ static struct usb_gadget_strings *uvc_function_strings[] = {
 
 #define UVC_STATUS_MAX_PACKET_SIZE              16      /* 16 bytes status */
 
-static struct usb_interface_assoc_descriptor uvc_iad __initdata = {
+static struct usb_interface_assoc_descriptor uvc_iad = {
         .bLength                = sizeof(uvc_iad),
         .bDescriptorType        = USB_DT_INTERFACE_ASSOCIATION,
         .bFirstInterface        = 0,
@@ -76,7 +80,7 @@ static struct usb_interface_assoc_descriptor uvc_iad __initdata = {
         .iFunction              = 0,
 };
 
-static struct usb_interface_descriptor uvc_control_intf __initdata = {
+static struct usb_interface_descriptor uvc_control_intf = {
         .bLength                = USB_DT_INTERFACE_SIZE,
         .bDescriptorType        = USB_DT_INTERFACE,
         .bInterfaceNumber       = UVC_INTF_VIDEO_CONTROL,
@@ -88,7 +92,7 @@ static struct usb_interface_descriptor uvc_control_intf __initdata = {
         .iInterface             = 0,
 };
 
-static struct usb_endpoint_descriptor uvc_control_ep __initdata = {
+static struct usb_endpoint_descriptor uvc_control_ep = {
         .bLength                = USB_DT_ENDPOINT_SIZE,
         .bDescriptorType        = USB_DT_ENDPOINT,
         .bEndpointAddress       = USB_DIR_IN,
@@ -97,7 +101,7 @@ static struct usb_endpoint_descriptor uvc_control_ep __initdata = {
         .bInterval              = 8,
 };
 
-static struct usb_ss_ep_comp_descriptor uvc_ss_control_comp __initdata = {
+static struct usb_ss_ep_comp_descriptor uvc_ss_control_comp = {
         .bLength                = sizeof(uvc_ss_control_comp),
         .bDescriptorType        = USB_DT_SS_ENDPOINT_COMP,
         /* The following 3 values can be tweaked if necessary. */
@@ -106,14 +110,14 @@ static struct usb_ss_ep_comp_descriptor uvc_ss_control_comp __initdata = {
         .wBytesPerInterval      = cpu_to_le16(UVC_STATUS_MAX_PACKET_SIZE),
 };
 
-static struct uvc_control_endpoint_descriptor uvc_control_cs_ep __initdata = {
+static struct uvc_control_endpoint_descriptor uvc_control_cs_ep = {
         .bLength                = UVC_DT_CONTROL_ENDPOINT_SIZE,
         .bDescriptorType        = USB_DT_CS_ENDPOINT,
         .bDescriptorSubType     = UVC_EP_INTERRUPT,
         .wMaxTransferSize       = cpu_to_le16(UVC_STATUS_MAX_PACKET_SIZE),
 };
 
-static struct usb_interface_descriptor uvc_streaming_intf_alt0 __initdata = {
+static struct usb_interface_descriptor uvc_streaming_intf_alt0 = {
         .bLength                = USB_DT_INTERFACE_SIZE,
         .bDescriptorType        = USB_DT_INTERFACE,
         .bInterfaceNumber       = UVC_INTF_VIDEO_STREAMING,
@@ -125,7 +129,7 @@ static struct usb_interface_descriptor uvc_streaming_intf_alt0 __initdata = {
         .iInterface             = 0,
 };
 
-static struct usb_interface_descriptor uvc_streaming_intf_alt1 __initdata = {
+static struct usb_interface_descriptor uvc_streaming_intf_alt1 = {
         .bLength                = USB_DT_INTERFACE_SIZE,
         .bDescriptorType        = USB_DT_INTERFACE,
         .bInterfaceNumber       = UVC_INTF_VIDEO_STREAMING,
@@ -137,7 +141,7 @@ static struct usb_interface_descriptor uvc_streaming_intf_alt1 __initdata = {
         .iInterface             = 0,
 };
 
-static struct usb_endpoint_descriptor uvc_fs_streaming_ep __initdata = {
+static struct usb_endpoint_descriptor uvc_fs_streaming_ep = {
         .bLength                = USB_DT_ENDPOINT_SIZE,
         .bDescriptorType        = USB_DT_ENDPOINT,
         .bEndpointAddress       = USB_DIR_IN,
@@ -148,7 +152,7 @@ static struct usb_endpoint_descriptor uvc_fs_streaming_ep __initdata = {
          */
 };
 
-static struct usb_endpoint_descriptor uvc_hs_streaming_ep __initdata = {
+static struct usb_endpoint_descriptor uvc_hs_streaming_ep = {
         .bLength                = USB_DT_ENDPOINT_SIZE,
         .bDescriptorType        = USB_DT_ENDPOINT,
         .bEndpointAddress       = USB_DIR_IN,
@@ -159,7 +163,7 @@ static struct usb_endpoint_descriptor uvc_hs_streaming_ep __initdata = {
          */
 };
 
-static struct usb_endpoint_descriptor uvc_ss_streaming_ep __initdata = {
+static struct usb_endpoint_descriptor uvc_ss_streaming_ep = {
         .bLength                = USB_DT_ENDPOINT_SIZE,
         .bDescriptorType        = USB_DT_ENDPOINT,
 
@@ -171,7 +175,7 @@ static struct usb_endpoint_descriptor uvc_ss_streaming_ep __initdata = {
          */
 };
 
-static struct usb_ss_ep_comp_descriptor uvc_ss_streaming_comp __initdata = {
+static struct usb_ss_ep_comp_descriptor uvc_ss_streaming_comp = {
         .bLength                = sizeof(uvc_ss_streaming_comp),
         .bDescriptorType        = USB_DT_SS_ENDPOINT_COMP,
         /* The bMaxBurst, bmAttributes and wBytesPerInterval values will be
@@ -198,6 +202,16 @@ static const struct usb_descriptor_header * const uvc_ss_streaming[] = {
         NULL,
 };
 
+#ifndef USBF_UVC_INCLUDED
+
+void uvc_set_trace_param(unsigned int trace)
+{
+        uvc_gadget_trace_param = trace;
+}
+EXPORT_SYMBOL(uvc_set_trace_param);
+
+#endif
+
 /* --------------------------------------------------------------------------
  * Control requests
  */
@@ -432,7 +446,7 @@ uvc_register_video(struct uvc_device *uvc)
                 } \
         } while (0)
 
-static struct usb_descriptor_header ** __init
+static struct usb_descriptor_header **
 uvc_copy_descriptors(struct uvc_device *uvc, enum usb_device_speed speed)
 {
         struct uvc_input_header_descriptor *uvc_streaming_header;
@@ -552,6 +566,7 @@ uvc_copy_descriptors(struct uvc_device *uvc, enum usb_device_speed speed)
         return hdr;
 }
 
+#ifdef USBF_UVC_INCLUDED
 static void
 uvc_function_unbind(struct usb_configuration *c, struct usb_function *f)
 {
@@ -573,8 +588,9 @@ uvc_function_unbind(struct usb_configuration *c, struct usb_function *f)
 
         kfree(uvc);
 }
+#endif
 
-static int __init
+static int
 uvc_function_bind(struct usb_configuration *c, struct usb_function *f)
 {
         struct usb_composite_dev *cdev = c->cdev;
@@ -582,10 +598,14 @@ uvc_function_bind(struct usb_configuration *c, struct usb_function *f)
         unsigned int max_packet_mult;
         unsigned int max_packet_size;
         struct usb_ep *ep;
+#ifndef USBF_UVC_INCLUDED
+        struct f_uvc_opts *opts;
+#endif
         int ret = -EINVAL;
 
         INFO(cdev, "uvc_function_bind\n");
 
+#ifdef USBF_UVC_INCLUDED
         /* Sanity check the streaming endpoint module parameters.
          */
         streaming_interval = clamp(streaming_interval, 1U, 16U);
@@ -622,6 +642,46 @@ uvc_function_bind(struct usb_configuration *c, struct usb_function *f)
         uvc_ss_streaming_comp.bMaxBurst = streaming_maxburst;
         uvc_ss_streaming_comp.wBytesPerInterval =
                 max_packet_size * max_packet_mult * streaming_maxburst;
+#else
+        opts = to_f_uvc_opts(f->fi);
+        /* Sanity check the streaming endpoint module parameters.
+         */
+        opts->streaming_interval = clamp(opts->streaming_interval, 1U, 16U);
+        opts->streaming_maxpacket = clamp(opts->streaming_maxpacket, 1U, 3072U);
+        opts->streaming_maxburst = min(opts->streaming_maxburst, 15U);
+
+        /* Fill in the FS/HS/SS Video Streaming specific descriptors from the
+         * module parameters.
+         *
+         * NOTE: We assume that the user knows what they are doing and won't
+         * give parameters that their UDC doesn't support.
+         */
+        if (opts->streaming_maxpacket <= 1024) {
+                max_packet_mult = 1;
+                max_packet_size = opts->streaming_maxpacket;
+        } else if (opts->streaming_maxpacket <= 2048) {
+                max_packet_mult = 2;
+                max_packet_size = opts->streaming_maxpacket / 2;
+        } else {
+                max_packet_mult = 3;
+                max_packet_size = opts->streaming_maxpacket / 3;
+        }
+
+        uvc_fs_streaming_ep.wMaxPacketSize =
+                min(opts->streaming_maxpacket, 1023U);
+        uvc_fs_streaming_ep.bInterval = opts->streaming_interval;
+
+        uvc_hs_streaming_ep.wMaxPacketSize = max_packet_size;
+        uvc_hs_streaming_ep.wMaxPacketSize |= ((max_packet_mult - 1) << 11);
+        uvc_hs_streaming_ep.bInterval = opts->streaming_interval;
+
+        uvc_ss_streaming_ep.wMaxPacketSize = max_packet_size;
+        uvc_ss_streaming_ep.bInterval = opts->streaming_interval;
+        uvc_ss_streaming_comp.bmAttributes = max_packet_mult - 1;
+        uvc_ss_streaming_comp.bMaxBurst = opts->streaming_maxburst;
+        uvc_ss_streaming_comp.wBytesPerInterval =
+                max_packet_size * max_packet_mult * opts->streaming_maxburst;
+#endif
 
         /* Allocate endpoints. */
         ep = usb_ep_autoconfig(cdev->gadget, &uvc_control_ep);
@@ -651,6 +711,23 @@ uvc_function_bind(struct usb_configuration *c, struct usb_function *f)
         uvc_hs_streaming_ep.bEndpointAddress = uvc->video.ep->address;
         uvc_ss_streaming_ep.bEndpointAddress = uvc->video.ep->address;
 
+        /* String descriptors are global, we only need to allocate string IDs
+         * for the first UVC function. UVC functions beyond the first (if any)
+         * will reuse the same IDs.
+         */
+        if (uvc_en_us_strings[UVC_STRING_CONTROL_IDX].id == 0) {
+                ret = usb_string_ids_tab(c->cdev, uvc_en_us_strings);
+                if (ret)
+                        goto error;
+                uvc_iad.iFunction =
+                        uvc_en_us_strings[UVC_STRING_CONTROL_IDX].id;
+                uvc_control_intf.iInterface =
+                        uvc_en_us_strings[UVC_STRING_CONTROL_IDX].id;
+                ret = uvc_en_us_strings[UVC_STRING_STREAMING_IDX].id;
+                uvc_streaming_intf_alt0.iInterface = ret;
+                uvc_streaming_intf_alt1.iInterface = ret;
+        }
+
         /* Allocate interface IDs. */
         if ((ret = usb_interface_id(c, f)) < 0)
                 goto error;
@@ -730,6 +807,7 @@ error:
  * USB gadget function
  */
 
+#ifdef USBF_UVC_INCLUDED
 /**
  * uvc_bind_config - add a UVC function to a configuration
  * @c: the configuration to support the UVC instance
@@ -796,23 +874,6 @@ uvc_bind_config(struct usb_configuration *c,
         uvc->desc.hs_streaming = hs_streaming;
         uvc->desc.ss_streaming = ss_streaming;
 
-        /* String descriptors are global, we only need to allocate string IDs
-         * for the first UVC function. UVC functions beyond the first (if any)
-         * will reuse the same IDs.
-         */
-        if (uvc_en_us_strings[UVC_STRING_CONTROL_IDX].id == 0) {
-                ret = usb_string_ids_tab(c->cdev, uvc_en_us_strings);
-                if (ret)
-                        goto error;
-                uvc_iad.iFunction =
-                        uvc_en_us_strings[UVC_STRING_CONTROL_IDX].id;
-                uvc_control_intf.iInterface =
-                        uvc_en_us_strings[UVC_STRING_CONTROL_IDX].id;
-                ret = uvc_en_us_strings[UVC_STRING_STREAMING_IDX].id;
-                uvc_streaming_intf_alt0.iInterface = ret;
-                uvc_streaming_intf_alt1.iInterface = ret;
-        }
-
         /* Register the function. */
         uvc->func.name = "uvc";
         uvc->func.strings = uvc_function_strings;
@@ -834,4 +895,87 @@ error:
         return ret;
 }
 
+#else
+
+static void uvc_free_inst(struct usb_function_instance *f)
+{
+        struct f_uvc_opts *opts = to_f_uvc_opts(f);
+
+        kfree(opts);
+}
+
+static struct usb_function_instance *uvc_alloc_inst(void)
+{
+        struct f_uvc_opts *opts;
+
+        opts = kzalloc(sizeof(*opts), GFP_KERNEL);
+        if (!opts)
+                return ERR_PTR(-ENOMEM);
+        opts->func_inst.free_func_inst = uvc_free_inst;
+
+        return &opts->func_inst;
+}
+
+static void uvc_free(struct usb_function *f)
+{
+        struct uvc_device *uvc = to_uvc(f);
+
+        kfree(uvc);
+}
+
+static void uvc_unbind(struct usb_configuration *c, struct usb_function *f)
+{
+        struct usb_composite_dev *cdev = c->cdev;
+        struct uvc_device *uvc = to_uvc(f);
+
+        INFO(cdev, "%s\n", __func__);
+
+        video_unregister_device(uvc->vdev);
+        v4l2_device_unregister(&uvc->v4l2_dev);
+        uvc->control_ep->driver_data = NULL;
+        uvc->video.ep->driver_data = NULL;
+
+        uvc_en_us_strings[UVC_STRING_CONTROL_IDX].id = 0;
+        usb_ep_free_request(cdev->gadget->ep0, uvc->control_req);
+        kfree(uvc->control_buf);
+
+        usb_free_all_descriptors(f);
+}
+
+struct usb_function *uvc_alloc(struct usb_function_instance *fi)
+{
+        struct uvc_device *uvc;
+        struct f_uvc_opts *opts;
+
+        uvc = kzalloc(sizeof(*uvc), GFP_KERNEL);
+        if (uvc == NULL)
+                return ERR_PTR(-ENOMEM);
+
+        uvc->state = UVC_STATE_DISCONNECTED;
+        opts = to_f_uvc_opts(fi);
+
+        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;
+
+        /* Register the function. */
+        uvc->func.name = "uvc";
+        uvc->func.strings = uvc_function_strings;
+        uvc->func.bind = uvc_function_bind;
+        uvc->func.unbind = uvc_unbind;
+        uvc->func.get_alt = uvc_function_get_alt;
+        uvc->func.set_alt = uvc_function_set_alt;
+        uvc->func.disable = uvc_function_disable;
+        uvc->func.setup = uvc_function_setup;
+        uvc->func.free_func = uvc_free;
+
+        return &uvc->func;
+}
+
+DECLARE_USB_FUNCTION_INIT(uvc, uvc_alloc_inst, uvc_alloc);
+MODULE_LICENSE("GPL");
+MODULE_AUTHOR("Laurent Pinchart");
 
+#endif
diff --git a/drivers/usb/gadget/function/u_uvc.h b/drivers/usb/gadget/function/u_uvc.h
new file mode 100644
index 000000000000..2a8dfdff0332
--- /dev/null
+++ b/drivers/usb/gadget/function/u_uvc.h
@@ -0,0 +1,39 @@
+/*
+ * u_uvc.h
+ *
+ * Utility definitions for the uvc function
+ *
+ * Copyright (c) 2013-2014 Samsung Electronics Co., Ltd.
+ *              http://www.samsung.com
+ *
+ * Author: Andrzej Pietrasiewicz <andrzej.p@samsung.com>
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License version 2 as
+ * published by the Free Software Foundation.
+ */
+
+#ifndef U_UVC_H
+#define U_UVC_H
+
+#include <linux/usb/composite.h>
+
+#define to_f_uvc_opts(f)        container_of(f, struct f_uvc_opts, func_inst)
+
+struct f_uvc_opts {
+        struct usb_function_instance                    func_inst;
+        unsigned int                                    uvc_gadget_trace_param;
+        unsigned int                                    streaming_interval;
+        unsigned int                                    streaming_maxpacket;
+        unsigned int                                    streaming_maxburst;
+        const struct uvc_descriptor_header * const      *fs_control;
+        const struct uvc_descriptor_header * const      *ss_control;
+        const struct uvc_descriptor_header * const      *fs_streaming;
+        const struct uvc_descriptor_header * const      *hs_streaming;
+        const struct uvc_descriptor_header * const      *ss_streaming;
+};
+
+void uvc_set_trace_param(unsigned int trace);
+
+#endif /* U_UVC_H */
+
diff --git a/drivers/usb/gadget/legacy/webcam.c b/drivers/usb/gadget/legacy/webcam.c
index 5d02849b1f67..50d27dbdbfa9 100644
--- a/drivers/usb/gadget/legacy/webcam.c
+++ b/drivers/usb/gadget/legacy/webcam.c
@@ -22,6 +22,7 @@
  * the runtime footprint, and giving us at least some parts of what
  * a "gcc --combine ... part1.c part2.c part3.c ... " build would.
  */
+#define USBF_UVC_INCLUDED
 #include "f_uvc.c"
 
 USB_GADGET_COMPOSITE_OPTIONS();