Quelle  webcam.c

// SPDX-License-Identifier: GPL-2.0+
/*
 * webcam.c -- USB webcam gadget driver
 *
 * Copyright (C) 2009-2010
 *     Laurent Pinchart (laurent.pinchart@ideasonboard.com)
 */

#include <linux/kernel.h>
#include <linux/device.h>
#include <linux/module.h>
#include <linux/usb/video.h>

#include "u_uvc.h"
#include "uvc_configfs.h"

USB_GADGET_COMPOSITE_OPTIONS();

/*-------------------------------------------------------------------------*/

/* module parameters specific to the Video streaming endpoint */
static unsigned int streaming_interval = 1;
module_param(streaming_interval, uint, S_IRUGO|S_IWUSR);
MODULE_PARM_DESC(streaming_interval, "1 - 16");

static unsigned int streaming_maxpacket = 1024;
module_param(streaming_maxpacket, uint, S_IRUGO|S_IWUSR);
MODULE_PARM_DESC(streaming_maxpacket, "1 - 1023 (FS), 1 - 3072 (hs/ss)");

static unsigned int streaming_maxburst;
module_param(streaming_maxburst, uint, S_IRUGO|S_IWUSR);
MODULE_PARM_DESC(streaming_maxburst, "0 - 15 (ss only)");

/* --------------------------------------------------------------------------
 * Device descriptor
 */

#define WEBCAM_VENDOR_ID  0x1d6b /* Linux Foundation */
#define WEBCAM_PRODUCT_ID  0x0102 /* Webcam A/V gadget */
#define WEBCAM_DEVICE_BCD  0x0010 /* 0.10 */

static char webcam_vendor_label[] = "Linux Foundation";
static char webcam_product_label[] = "Webcam gadget";
static char webcam_config_label[] = "Video";

/* string IDs are assigned dynamically */

#define STRING_DESCRIPTION_IDX  USB_GADGET_FIRST_AVAIL_IDX

static struct usb_string webcam_strings[] = {
 [USB_GADGET_MANUFACTURER_IDX].s = webcam_vendor_label,
 [USB_GADGET_PRODUCT_IDX].s = webcam_product_label,
 [USB_GADGET_SERIAL_IDX].s = "",
 [STRING_DESCRIPTION_IDX].s = webcam_config_label,
 {  }
};

static struct usb_gadget_strings webcam_stringtab = {
 .language = 0x0409, /* en-us */
 .strings = webcam_strings,
};

static struct usb_gadget_strings *webcam_device_strings[] = {
 &webcam_stringtab,
 NULL,
};

static struct usb_function_instance *fi_uvc;
static struct usb_function *f_uvc;

static struct usb_device_descriptor webcam_device_descriptor = {
 .bLength  = USB_DT_DEVICE_SIZE,
 .bDescriptorType = USB_DT_DEVICE,
 /* .bcdUSB = DYNAMIC */
 .bDeviceClass  = USB_CLASS_MISC,
 .bDeviceSubClass = 0x02,
 .bDeviceProtocol = 0x01,
 .bMaxPacketSize0 = 0, /* dynamic */
 .idVendor  = cpu_to_le16(WEBCAM_VENDOR_ID),
 .idProduct  = cpu_to_le16(WEBCAM_PRODUCT_ID),
 .bcdDevice  = cpu_to_le16(WEBCAM_DEVICE_BCD),
 .iManufacturer  = 0, /* dynamic */
 .iProduct  = 0, /* dynamic */
 .iSerialNumber  = 0, /* dynamic */
 .bNumConfigurations = 0, /* dynamic */
};

static const struct UVC_HEADER_DESCRIPTOR(1) uvc_control_header = {
 .bLength  = UVC_DT_HEADER_SIZE(1),
 .bDescriptorType = USB_DT_CS_INTERFACE,
 .bDescriptorSubType = UVC_VC_HEADER,
 .bcdUVC   = cpu_to_le16(0x0110),
 .wTotalLength  = 0, /* dynamic */
 .dwClockFrequency = cpu_to_le32(48000000),
 .bInCollection  = 0, /* dynamic */
 .baInterfaceNr[0] = 0, /* dynamic */
};

static const struct uvc_camera_terminal_descriptor uvc_camera_terminal = {
 .bLength  = UVC_DT_CAMERA_TERMINAL_SIZE(3),
 .bDescriptorType = USB_DT_CS_INTERFACE,
 .bDescriptorSubType = UVC_VC_INPUT_TERMINAL,
 .bTerminalID  = 1,
 .wTerminalType  = cpu_to_le16(0x0201),
 .bAssocTerminal  = 0,
 .iTerminal  = 0,
 .wObjectiveFocalLengthMin = cpu_to_le16(0),
 .wObjectiveFocalLengthMax = cpu_to_le16(0),
 .wOcularFocalLength  = cpu_to_le16(0),
 .bControlSize  = 3,
 .bmControls[0]  = 2,
 .bmControls[1]  = 0,
 .bmControls[2]  = 0,
};

static const struct uvc_processing_unit_descriptor uvc_processing = {
 .bLength  = UVC_DT_PROCESSING_UNIT_SIZE(2),
 .bDescriptorType = USB_DT_CS_INTERFACE,
 .bDescriptorSubType = UVC_VC_PROCESSING_UNIT,
 .bUnitID  = 2,
 .bSourceID  = 1,
 .wMaxMultiplier  = cpu_to_le16(16*1024),
 .bControlSize  = 2,
 .bmControls[0]  = 1,
 .bmControls[1]  = 0,
 .iProcessing  = 0,
 .bmVideoStandards = 0,
};

static const struct uvc_output_terminal_descriptor uvc_output_terminal = {
 .bLength  = UVC_DT_OUTPUT_TERMINAL_SIZE,
 .bDescriptorType = USB_DT_CS_INTERFACE,
 .bDescriptorSubType = UVC_VC_OUTPUT_TERMINAL,
 .bTerminalID  = 3,
 .wTerminalType  = cpu_to_le16(0x0101),
 .bAssocTerminal  = 0,
 .bSourceID  = 2,
 .iTerminal  = 0,
};

DECLARE_UVC_INPUT_HEADER_DESCRIPTOR(1, 2);

static const struct UVC_INPUT_HEADER_DESCRIPTOR(1, 2) uvc_input_header = {
 .bLength  = UVC_DT_INPUT_HEADER_SIZE(1, 2),
 .bDescriptorType = USB_DT_CS_INTERFACE,
 .bDescriptorSubType = UVC_VS_INPUT_HEADER,
 .bNumFormats  = 2,
 .wTotalLength  = 0, /* dynamic */
 .bEndpointAddress = 0, /* dynamic */
 .bmInfo   = 0,
 .bTerminalLink  = 3,
 .bStillCaptureMethod = 0,
 .bTriggerSupport = 0,
 .bTriggerUsage  = 0,
 .bControlSize  = 1,
 .bmaControls[0][0] = 0,
 .bmaControls[1][0] = 4,
};

static const struct uvcg_color_matching uvcg_color_matching = {
 .desc = {
  .bLength  = UVC_DT_COLOR_MATCHING_SIZE,
  .bDescriptorType = USB_DT_CS_INTERFACE,
  .bDescriptorSubType = UVC_VS_COLORFORMAT,
  .bColorPrimaries = 1,
  .bTransferCharacteristics = 1,
  .bMatrixCoefficients = 4,
 },
};

static struct uvcg_uncompressed uvcg_format_yuv = {
 .fmt = {
  .type   = UVCG_UNCOMPRESSED,
  /* add to .frames and fill .num_frames at runtime */
  .color_matching  = (struct uvcg_color_matching *)&uvcg_color_matching,
 },
 .desc = {
  .bLength  = UVC_DT_FORMAT_UNCOMPRESSED_SIZE,
  .bDescriptorType = USB_DT_CS_INTERFACE,
  .bDescriptorSubType = UVC_VS_FORMAT_UNCOMPRESSED,
  .bFormatIndex  = 1,
  .bNumFrameDescriptors = 2,
  .guidFormat  = {
   'Y',  'U',  'Y',  '2', 0x00, 0x00, 0x10, 0x00,
    0x80, 0x00, 0x00, 0xaa, 0x00, 0x38, 0x9b, 0x71
  },
  .bBitsPerPixel  = 16,
  .bDefaultFrameIndex = 1,
  .bAspectRatioX  = 0,
  .bAspectRatioY  = 0,
  .bmInterlaceFlags = 0,
  .bCopyProtect  = 0,
 },
};

static struct uvcg_format_ptr uvcg_format_ptr_yuv = {
 .fmt = &uvcg_format_yuv.fmt,
};

DECLARE_UVC_FRAME_UNCOMPRESSED(1);
DECLARE_UVC_FRAME_UNCOMPRESSED(3);

#define UVCG_WIDTH_360P   640
#define UVCG_HEIGHT_360P  360
#define UVCG_MIN_BITRATE_360P  18432000
#define UVCG_MAX_BITRATE_360P  55296000
#define UVCG_MAX_VIDEO_FB_SZ_360P 460800
#define UVCG_FRM_INTERV_0_360P  666666
#define UVCG_FRM_INTERV_1_360P  1000000
#define UVCG_FRM_INTERV_2_360P  5000000
#define UVCG_DEFAULT_FRM_INTERV_360P UVCG_FRM_INTERV_0_360P

static const struct UVC_FRAME_UNCOMPRESSED(3) uvc_frame_yuv_360p = {
 .bLength  = UVC_DT_FRAME_UNCOMPRESSED_SIZE(3),
 .bDescriptorType = USB_DT_CS_INTERFACE,
 .bDescriptorSubType = UVC_VS_FRAME_UNCOMPRESSED,
 .bFrameIndex  = 1,
 .bmCapabilities  = 0,
 .wWidth   = cpu_to_le16(UVCG_WIDTH_360P),
 .wHeight  = cpu_to_le16(UVCG_HEIGHT_360P),
 .dwMinBitRate  = cpu_to_le32(UVCG_MIN_BITRATE_360P),
 .dwMaxBitRate  = cpu_to_le32(UVCG_MAX_BITRATE_360P),
 .dwMaxVideoFrameBufferSize = cpu_to_le32(UVCG_MAX_VIDEO_FB_SZ_360P),
 .dwDefaultFrameInterval = cpu_to_le32(UVCG_DEFAULT_FRM_INTERV_360P),
 .bFrameIntervalType = 3,
 .dwFrameInterval[0] = cpu_to_le32(UVCG_FRM_INTERV_0_360P),
 .dwFrameInterval[1] = cpu_to_le32(UVCG_FRM_INTERV_1_360P),
 .dwFrameInterval[2] = cpu_to_le32(UVCG_FRM_INTERV_2_360P),
};

static u32 uvcg_frame_yuv_360p_dw_frame_interval[] = {
 [0] = UVCG_FRM_INTERV_0_360P,
 [1] = UVCG_FRM_INTERV_1_360P,
 [2] = UVCG_FRM_INTERV_2_360P,
};

static const struct uvcg_frame uvcg_frame_yuv_360p = {
 .fmt_type  = UVCG_UNCOMPRESSED,
 .frame = {
  .b_length   = UVC_DT_FRAME_UNCOMPRESSED_SIZE(3),
  .b_descriptor_type  = USB_DT_CS_INTERFACE,
  .b_descriptor_subtype  = UVC_VS_FRAME_UNCOMPRESSED,
  .b_frame_index   = 1,
  .bm_capabilities  = 0,
  .w_width   = UVCG_WIDTH_360P,
  .w_height   = UVCG_HEIGHT_360P,
  .dw_min_bit_rate  = UVCG_MIN_BITRATE_360P,
  .dw_max_bit_rate  = UVCG_MAX_BITRATE_360P,
  .dw_max_video_frame_buffer_size = UVCG_MAX_VIDEO_FB_SZ_360P,
  .dw_default_frame_interval = UVCG_DEFAULT_FRM_INTERV_360P,
  .b_frame_interval_type  = 3,
 },
 .dw_frame_interval = uvcg_frame_yuv_360p_dw_frame_interval,
};

static struct uvcg_frame_ptr uvcg_frame_ptr_yuv_360p = {
 .frm = (struct uvcg_frame *)&uvcg_frame_yuv_360p,
};
#define UVCG_WIDTH_720P   1280
#define UVCG_HEIGHT_720P  720
#define UVCG_MIN_BITRATE_720P  29491200
#define UVCG_MAX_BITRATE_720P  29491200
#define UVCG_MAX_VIDEO_FB_SZ_720P 1843200
#define UVCG_FRM_INTERV_0_720P  5000000
#define UVCG_DEFAULT_FRM_INTERV_720P UVCG_FRM_INTERV_0_720P

static const struct UVC_FRAME_UNCOMPRESSED(1) uvc_frame_yuv_720p = {
 .bLength  = UVC_DT_FRAME_UNCOMPRESSED_SIZE(1),
 .bDescriptorType = USB_DT_CS_INTERFACE,
 .bDescriptorSubType = UVC_VS_FRAME_UNCOMPRESSED,
 .bFrameIndex  = 2,
 .bmCapabilities  = 0,
 .wWidth   = cpu_to_le16(UVCG_WIDTH_720P),
 .wHeight  = cpu_to_le16(UVCG_HEIGHT_720P),
 .dwMinBitRate  = cpu_to_le32(UVCG_MIN_BITRATE_720P),
 .dwMaxBitRate  = cpu_to_le32(UVCG_MAX_BITRATE_720P),
 .dwMaxVideoFrameBufferSize = cpu_to_le32(UVCG_MAX_VIDEO_FB_SZ_720P),
 .dwDefaultFrameInterval = cpu_to_le32(UVCG_DEFAULT_FRM_INTERV_720P),
 .bFrameIntervalType = 1,
 .dwFrameInterval[0] = cpu_to_le32(UVCG_FRM_INTERV_0_720P),
};

static u32 uvcg_frame_yuv_720p_dw_frame_interval[] = {
 [0] = UVCG_FRM_INTERV_0_720P,
};

static const struct uvcg_frame uvcg_frame_yuv_720p = {
 .fmt_type  = UVCG_UNCOMPRESSED,
 .frame = {
  .b_length   = UVC_DT_FRAME_UNCOMPRESSED_SIZE(1),
  .b_descriptor_type  = USB_DT_CS_INTERFACE,
  .b_descriptor_subtype  = UVC_VS_FRAME_UNCOMPRESSED,
  .b_frame_index   = 2,
  .bm_capabilities  = 0,
  .w_width   = UVCG_WIDTH_720P,
  .w_height   = UVCG_HEIGHT_720P,
  .dw_min_bit_rate  = UVCG_MIN_BITRATE_720P,
  .dw_max_bit_rate  = UVCG_MAX_BITRATE_720P,
  .dw_max_video_frame_buffer_size = UVCG_MAX_VIDEO_FB_SZ_720P,
  .dw_default_frame_interval = UVCG_DEFAULT_FRM_INTERV_720P,
  .b_frame_interval_type  = 1,
 },
 .dw_frame_interval = uvcg_frame_yuv_720p_dw_frame_interval,
};

static struct uvcg_frame_ptr uvcg_frame_ptr_yuv_720p = {
 .frm = (struct uvcg_frame *)&uvcg_frame_yuv_720p,
};

static struct uvcg_mjpeg uvcg_format_mjpeg = {
 .fmt = {
  .type   = UVCG_MJPEG,
  /* add to .frames and fill .num_frames at runtime */
  .color_matching  = (struct uvcg_color_matching *)&uvcg_color_matching,
 },
 .desc = {
  .bLength  = UVC_DT_FORMAT_MJPEG_SIZE,
  .bDescriptorType = USB_DT_CS_INTERFACE,
  .bDescriptorSubType = UVC_VS_FORMAT_MJPEG,
  .bFormatIndex  = 2,
  .bNumFrameDescriptors = 2,
  .bmFlags  = 0,
  .bDefaultFrameIndex = 1,
  .bAspectRatioX  = 0,
  .bAspectRatioY  = 0,
  .bmInterlaceFlags = 0,
  .bCopyProtect  = 0,
 },
};

static struct uvcg_format_ptr uvcg_format_ptr_mjpeg = {
 .fmt = &uvcg_format_mjpeg.fmt,
};

DECLARE_UVC_FRAME_MJPEG(1);
DECLARE_UVC_FRAME_MJPEG(3);

static const struct UVC_FRAME_MJPEG(3) uvc_frame_mjpg_360p = {
 .bLength  = UVC_DT_FRAME_MJPEG_SIZE(3),
 .bDescriptorType = USB_DT_CS_INTERFACE,
 .bDescriptorSubType = UVC_VS_FRAME_MJPEG,
 .bFrameIndex  = 1,
 .bmCapabilities  = 0,
 .wWidth   = cpu_to_le16(UVCG_WIDTH_360P),
 .wHeight  = cpu_to_le16(UVCG_HEIGHT_360P),
 .dwMinBitRate  = cpu_to_le32(UVCG_MIN_BITRATE_360P),
 .dwMaxBitRate  = cpu_to_le32(UVCG_MAX_BITRATE_360P),
 .dwMaxVideoFrameBufferSize = cpu_to_le32(UVCG_MAX_VIDEO_FB_SZ_360P),
 .dwDefaultFrameInterval = cpu_to_le32(UVCG_DEFAULT_FRM_INTERV_360P),
 .bFrameIntervalType = 3,
 .dwFrameInterval[0] = cpu_to_le32(UVCG_FRM_INTERV_0_360P),
 .dwFrameInterval[1] = cpu_to_le32(UVCG_FRM_INTERV_1_360P),
 .dwFrameInterval[2] = cpu_to_le32(UVCG_FRM_INTERV_2_360P),
};

static u32 uvcg_frame_mjpeg_360p_dw_frame_interval[] = {
 [0] = UVCG_FRM_INTERV_0_360P,
 [1] = UVCG_FRM_INTERV_1_360P,
 [2] = UVCG_FRM_INTERV_2_360P,
};

static const struct uvcg_frame uvcg_frame_mjpeg_360p = {
 .fmt_type  = UVCG_MJPEG,
 .frame = {
  .b_length   = UVC_DT_FRAME_MJPEG_SIZE(3),
  .b_descriptor_type  = USB_DT_CS_INTERFACE,
  .b_descriptor_subtype  = UVC_VS_FRAME_MJPEG,
  .b_frame_index   = 1,
  .bm_capabilities  = 0,
  .w_width   = UVCG_WIDTH_360P,
  .w_height   = UVCG_HEIGHT_360P,
  .dw_min_bit_rate  = UVCG_MIN_BITRATE_360P,
  .dw_max_bit_rate  = UVCG_MAX_BITRATE_360P,
  .dw_max_video_frame_buffer_size = UVCG_MAX_VIDEO_FB_SZ_360P,
  .dw_default_frame_interval = UVCG_DEFAULT_FRM_INTERV_360P,
  .b_frame_interval_type  = 3,
 },
 .dw_frame_interval = uvcg_frame_mjpeg_360p_dw_frame_interval,
};

static struct uvcg_frame_ptr uvcg_frame_ptr_mjpeg_360p = {
 .frm = (struct uvcg_frame *)&uvcg_frame_mjpeg_360p,
};

static const struct UVC_FRAME_MJPEG(1) uvc_frame_mjpg_720p = {
 .bLength  = UVC_DT_FRAME_MJPEG_SIZE(1),
 .bDescriptorType = USB_DT_CS_INTERFACE,
 .bDescriptorSubType = UVC_VS_FRAME_MJPEG,
 .bFrameIndex  = 2,
 .bmCapabilities  = 0,
 .wWidth   = cpu_to_le16(UVCG_WIDTH_720P),
 .wHeight  = cpu_to_le16(UVCG_HEIGHT_720P),
 .dwMinBitRate  = cpu_to_le32(UVCG_MIN_BITRATE_720P),
 .dwMaxBitRate  = cpu_to_le32(UVCG_MAX_BITRATE_720P),
 .dwMaxVideoFrameBufferSize = cpu_to_le32(UVCG_MAX_VIDEO_FB_SZ_720P),
 .dwDefaultFrameInterval = cpu_to_le32(UVCG_DEFAULT_FRM_INTERV_720P),
 .bFrameIntervalType = 1,
 .dwFrameInterval[0] = cpu_to_le32(UVCG_FRM_INTERV_0_720P),
};

static u32 uvcg_frame_mjpeg_720p_dw_frame_interval[] = {
 [0] = UVCG_FRM_INTERV_0_720P,
};

static const struct uvcg_frame uvcg_frame_mjpeg_720p = {
 .fmt_type  = UVCG_MJPEG,
 .frame = {
  .b_length   = UVC_DT_FRAME_MJPEG_SIZE(1),
  .b_descriptor_type  = USB_DT_CS_INTERFACE,
  .b_descriptor_subtype  = UVC_VS_FRAME_MJPEG,
  .b_frame_index   = 2,
  .bm_capabilities  = 0,
  .w_width   = UVCG_WIDTH_720P,
  .w_height   = UVCG_HEIGHT_720P,
  .dw_min_bit_rate  = UVCG_MIN_BITRATE_720P,
  .dw_max_bit_rate  = UVCG_MAX_BITRATE_720P,
  .dw_max_video_frame_buffer_size = UVCG_MAX_VIDEO_FB_SZ_720P,
  .dw_default_frame_interval = UVCG_DEFAULT_FRM_INTERV_720P,
  .b_frame_interval_type  = 1,
 },
 .dw_frame_interval = uvcg_frame_mjpeg_720p_dw_frame_interval,
};

static struct uvcg_frame_ptr uvcg_frame_ptr_mjpeg_720p = {
 .frm = (struct uvcg_frame *)&uvcg_frame_mjpeg_720p,
};

static struct uvcg_streaming_header uvcg_streaming_header = {
};

static const struct uvc_descriptor_header * const uvc_fs_control_cls[] = {
 (const struct uvc_descriptor_header *) &uvc_control_header,
 (const struct uvc_descriptor_header *) &uvc_camera_terminal,
 (const struct uvc_descriptor_header *) &uvc_processing,
 (const struct uvc_descriptor_header *) &uvc_output_terminal,
 NULL,
};

static const struct uvc_descriptor_header * const uvc_ss_control_cls[] = {
 (const struct uvc_descriptor_header *) &uvc_control_header,
 (const struct uvc_descriptor_header *) &uvc_camera_terminal,
 (const struct uvc_descriptor_header *) &uvc_processing,
 (const struct uvc_descriptor_header *) &uvc_output_terminal,
 NULL,
};

static const struct uvc_descriptor_header * const uvc_fs_streaming_cls[] = {
 (const struct uvc_descriptor_header *) &uvc_input_header,
 (const struct uvc_descriptor_header *) &uvcg_format_yuv.desc,
 (const struct uvc_descriptor_header *) &uvc_frame_yuv_360p,
 (const struct uvc_descriptor_header *) &uvc_frame_yuv_720p,
 (const struct uvc_descriptor_header *) &uvcg_color_matching.desc,
 (const struct uvc_descriptor_header *) &uvcg_format_mjpeg.desc,
 (const struct uvc_descriptor_header *) &uvc_frame_mjpg_360p,
 (const struct uvc_descriptor_header *) &uvc_frame_mjpg_720p,
 (const struct uvc_descriptor_header *) &uvcg_color_matching.desc,
 NULL,
};

static const struct uvc_descriptor_header * const uvc_hs_streaming_cls[] = {
 (const struct uvc_descriptor_header *) &uvc_input_header,
 (const struct uvc_descriptor_header *) &uvcg_format_yuv.desc,
 (const struct uvc_descriptor_header *) &uvc_frame_yuv_360p,
 (const struct uvc_descriptor_header *) &uvc_frame_yuv_720p,
 (const struct uvc_descriptor_header *) &uvcg_color_matching.desc,
 (const struct uvc_descriptor_header *) &uvcg_format_mjpeg.desc,
 (const struct uvc_descriptor_header *) &uvc_frame_mjpg_360p,
 (const struct uvc_descriptor_header *) &uvc_frame_mjpg_720p,
 (const struct uvc_descriptor_header *) &uvcg_color_matching.desc,
 NULL,
};

static const struct uvc_descriptor_header * const uvc_ss_streaming_cls[] = {
 (const struct uvc_descriptor_header *) &uvc_input_header,
 (const struct uvc_descriptor_header *) &uvcg_format_yuv.desc,
 (const struct uvc_descriptor_header *) &uvc_frame_yuv_360p,
 (const struct uvc_descriptor_header *) &uvc_frame_yuv_720p,
 (const struct uvc_descriptor_header *) &uvcg_color_matching.desc,
 (const struct uvc_descriptor_header *) &uvcg_format_mjpeg.desc,
 (const struct uvc_descriptor_header *) &uvc_frame_mjpg_360p,
 (const struct uvc_descriptor_header *) &uvc_frame_mjpg_720p,
 (const struct uvc_descriptor_header *) &uvcg_color_matching.desc,
 NULL,
};

/* --------------------------------------------------------------------------
 * USB configuration
 */

static int
webcam_config_bind(struct usb_configuration *c)
{
 int status = 0;

 f_uvc = usb_get_function(fi_uvc);
 if (IS_ERR(f_uvc))
  return PTR_ERR(f_uvc);

 status = usb_add_function(c, f_uvc);
 if (status < 0)
  usb_put_function(f_uvc);

 return status;
}

static struct usb_configuration webcam_config_driver = {
 .label   = webcam_config_label,
 .bConfigurationValue = 1,
 .iConfiguration  = 0, /* dynamic */
 .bmAttributes  = USB_CONFIG_ATT_SELFPOWER,
 .MaxPower  = CONFIG_USB_GADGET_VBUS_DRAW,
};

static int
webcam_unbind(struct usb_composite_dev *cdev)
{
 if (!IS_ERR_OR_NULL(f_uvc))
  usb_put_function(f_uvc);
 if (!IS_ERR_OR_NULL(fi_uvc))
  usb_put_function_instance(fi_uvc);
 return 0;
}

static int
webcam_bind(struct usb_composite_dev *cdev)
{
 struct f_uvc_opts *uvc_opts;
 int ret;

 fi_uvc = usb_get_function_instance("uvc");
 if (IS_ERR(fi_uvc))
  return PTR_ERR(fi_uvc);

 uvc_opts = container_of(fi_uvc, struct f_uvc_opts, func_inst);

 uvc_opts->streaming_interval = streaming_interval;
 uvc_opts->streaming_maxpacket = streaming_maxpacket;
 uvc_opts->streaming_maxburst = streaming_maxburst;

 uvc_opts->fs_control = uvc_fs_control_cls;
 uvc_opts->ss_control = uvc_ss_control_cls;
 uvc_opts->fs_streaming = uvc_fs_streaming_cls;
 uvc_opts->hs_streaming = uvc_hs_streaming_cls;
 uvc_opts->ss_streaming = uvc_ss_streaming_cls;

 INIT_LIST_HEAD(&uvcg_format_yuv.fmt.frames);
 list_add_tail(&uvcg_frame_ptr_yuv_360p.entry, &uvcg_format_yuv.fmt.frames);
 list_add_tail(&uvcg_frame_ptr_yuv_720p.entry, &uvcg_format_yuv.fmt.frames);
 uvcg_format_yuv.fmt.num_frames = 2;

 INIT_LIST_HEAD(&uvcg_format_mjpeg.fmt.frames);
 list_add_tail(&uvcg_frame_ptr_mjpeg_360p.entry, &uvcg_format_mjpeg.fmt.frames);
 list_add_tail(&uvcg_frame_ptr_mjpeg_720p.entry, &uvcg_format_mjpeg.fmt.frames);
 uvcg_format_mjpeg.fmt.num_frames = 2;

 INIT_LIST_HEAD(&uvcg_streaming_header.formats);
 list_add_tail(&uvcg_format_ptr_yuv.entry, &uvcg_streaming_header.formats);
 list_add_tail(&uvcg_format_ptr_mjpeg.entry, &uvcg_streaming_header.formats);
 uvcg_streaming_header.num_fmt = 2;

 uvc_opts->header = &uvcg_streaming_header;

 /* Allocate string descriptor numbers ... note that string contents
 * can be overridden by the composite_dev glue.
 */
 ret = usb_string_ids_tab(cdev, webcam_strings);
 if (ret < 0)
  goto error;
 webcam_device_descriptor.iManufacturer =
  webcam_strings[USB_GADGET_MANUFACTURER_IDX].id;
 webcam_device_descriptor.iProduct =
  webcam_strings[USB_GADGET_PRODUCT_IDX].id;
 webcam_config_driver.iConfiguration =
  webcam_strings[STRING_DESCRIPTION_IDX].id;

 /* Register our configuration. */
 if ((ret = usb_add_config(cdev, &webcam_config_driver,
     webcam_config_bind)) < 0)
  goto error;

 usb_composite_overwrite_options(cdev, &coverwrite);
 INFO(cdev, "Webcam Video Gadget\n");
 return 0;

error:
 usb_put_function_instance(fi_uvc);
 return ret;
}

/* --------------------------------------------------------------------------
 * Driver
 */

static struct usb_composite_driver webcam_driver = {
 .name  = "g_webcam",
 .dev  = &webcam_device_descriptor,
 .strings = webcam_device_strings,
 .max_speed = USB_SPEED_SUPER,
 .bind  = webcam_bind,
 .unbind  = webcam_unbind,
};

module_usb_composite_driver(webcam_driver);

MODULE_AUTHOR("Laurent Pinchart");
MODULE_DESCRIPTION("Webcam Video Gadget");
MODULE_LICENSE("GPL");