2 * uvc_gadget.c -- USB Video Class Gadget driver
4 * Copyright (C) 2009-2010
5 * Laurent Pinchart (laurent.pinchart@ideasonboard.com)
7 * This program is free software; you can redistribute it and/or modify
8 * it under the terms of the GNU General Public License as published by
9 * the Free Software Foundation; either version 2 of the License, or
10 * (at your option) any later version.
13 #include <linux/kernel.h>
14 #include <linux/device.h>
15 #include <linux/errno.h>
17 #include <linux/list.h>
18 #include <linux/mutex.h>
19 #include <linux/usb/ch9.h>
20 #include <linux/usb/gadget.h>
21 #include <linux/usb/video.h>
22 #include <linux/vmalloc.h>
23 #include <linux/wait.h>
25 #include <media/v4l2-dev.h>
26 #include <media/v4l2-event.h>
30 unsigned int uvc_gadget_trace_param;
32 /*-------------------------------------------------------------------------*/
34 /* module parameters specific to the Video streaming endpoint */
35 static unsigned streaming_interval = 1;
36 module_param(streaming_interval, uint, S_IRUGO|S_IWUSR);
37 MODULE_PARM_DESC(streaming_interval, "1 - 16");
39 static unsigned streaming_maxpacket = 1024;
40 module_param(streaming_maxpacket, uint, S_IRUGO|S_IWUSR);
41 MODULE_PARM_DESC(streaming_maxpacket, "0 - 1023 (fs), 0 - 1024 (hs/ss)");
43 static unsigned streaming_mult;
44 module_param(streaming_mult, uint, S_IRUGO|S_IWUSR);
45 MODULE_PARM_DESC(streaming_mult, "0 - 2 (hs/ss only)");
47 static unsigned streaming_maxburst;
48 module_param(streaming_maxburst, uint, S_IRUGO|S_IWUSR);
49 MODULE_PARM_DESC(streaming_maxburst, "0 - 15 (ss only)");
51 /* --------------------------------------------------------------------------
52 * Function descriptors
55 /* string IDs are assigned dynamically */
57 #define UVC_STRING_ASSOCIATION_IDX 0
58 #define UVC_STRING_CONTROL_IDX 1
59 #define UVC_STRING_STREAMING_IDX 2
61 static struct usb_string uvc_en_us_strings[] = {
62 [UVC_STRING_ASSOCIATION_IDX].s = "UVC Camera",
63 [UVC_STRING_CONTROL_IDX].s = "Video Control",
64 [UVC_STRING_STREAMING_IDX].s = "Video Streaming",
68 static struct usb_gadget_strings uvc_stringtab = {
69 .language = 0x0409, /* en-us */
70 .strings = uvc_en_us_strings,
73 static struct usb_gadget_strings *uvc_function_strings[] = {
78 #define UVC_INTF_VIDEO_CONTROL 0
79 #define UVC_INTF_VIDEO_STREAMING 1
81 #define STATUS_BYTECOUNT 16 /* 16 bytes status */
83 static struct usb_interface_assoc_descriptor uvc_iad __initdata = {
84 .bLength = sizeof(uvc_iad),
85 .bDescriptorType = USB_DT_INTERFACE_ASSOCIATION,
88 .bFunctionClass = USB_CLASS_VIDEO,
89 .bFunctionSubClass = UVC_SC_VIDEO_INTERFACE_COLLECTION,
90 .bFunctionProtocol = 0x00,
94 static struct usb_interface_descriptor uvc_control_intf __initdata = {
95 .bLength = USB_DT_INTERFACE_SIZE,
96 .bDescriptorType = USB_DT_INTERFACE,
97 .bInterfaceNumber = UVC_INTF_VIDEO_CONTROL,
98 .bAlternateSetting = 0,
100 .bInterfaceClass = USB_CLASS_VIDEO,
101 .bInterfaceSubClass = UVC_SC_VIDEOCONTROL,
102 .bInterfaceProtocol = 0x00,
106 static struct usb_endpoint_descriptor uvc_fs_control_ep __initdata = {
107 .bLength = USB_DT_ENDPOINT_SIZE,
108 .bDescriptorType = USB_DT_ENDPOINT,
109 .bEndpointAddress = USB_DIR_IN,
110 .bmAttributes = USB_ENDPOINT_XFER_INT,
111 .wMaxPacketSize = cpu_to_le16(STATUS_BYTECOUNT),
115 static struct uvc_control_endpoint_descriptor uvc_control_cs_ep __initdata = {
116 .bLength = UVC_DT_CONTROL_ENDPOINT_SIZE,
117 .bDescriptorType = USB_DT_CS_ENDPOINT,
118 .bDescriptorSubType = UVC_EP_INTERRUPT,
119 .wMaxTransferSize = cpu_to_le16(STATUS_BYTECOUNT),
122 static struct usb_interface_descriptor uvc_streaming_intf_alt0 __initdata = {
123 .bLength = USB_DT_INTERFACE_SIZE,
124 .bDescriptorType = USB_DT_INTERFACE,
125 .bInterfaceNumber = UVC_INTF_VIDEO_STREAMING,
126 .bAlternateSetting = 0,
128 .bInterfaceClass = USB_CLASS_VIDEO,
129 .bInterfaceSubClass = UVC_SC_VIDEOSTREAMING,
130 .bInterfaceProtocol = 0x00,
134 static struct usb_interface_descriptor uvc_streaming_intf_alt1 __initdata = {
135 .bLength = USB_DT_INTERFACE_SIZE,
136 .bDescriptorType = USB_DT_INTERFACE,
137 .bInterfaceNumber = UVC_INTF_VIDEO_STREAMING,
138 .bAlternateSetting = 1,
140 .bInterfaceClass = USB_CLASS_VIDEO,
141 .bInterfaceSubClass = UVC_SC_VIDEOSTREAMING,
142 .bInterfaceProtocol = 0x00,
146 static struct usb_endpoint_descriptor uvc_fs_streaming_ep = {
147 .bLength = USB_DT_ENDPOINT_SIZE,
148 .bDescriptorType = USB_DT_ENDPOINT,
149 .bEndpointAddress = USB_DIR_IN,
150 .bmAttributes = USB_ENDPOINT_XFER_ISOC,
151 .wMaxPacketSize = cpu_to_le16(512),
155 static struct usb_endpoint_descriptor uvc_hs_streaming_ep = {
156 .bLength = USB_DT_ENDPOINT_SIZE,
157 .bDescriptorType = USB_DT_ENDPOINT,
158 .bEndpointAddress = USB_DIR_IN,
159 .bmAttributes = USB_ENDPOINT_XFER_ISOC,
160 .wMaxPacketSize = cpu_to_le16(1024),
164 /* super speed support */
165 static struct usb_endpoint_descriptor uvc_ss_control_ep __initdata = {
166 .bLength = USB_DT_ENDPOINT_SIZE,
167 .bDescriptorType = USB_DT_ENDPOINT,
169 .bEndpointAddress = USB_DIR_IN,
170 .bmAttributes = USB_ENDPOINT_XFER_INT,
171 .wMaxPacketSize = cpu_to_le16(STATUS_BYTECOUNT),
175 static struct usb_ss_ep_comp_descriptor uvc_ss_control_comp __initdata = {
176 .bLength = sizeof uvc_ss_control_comp,
177 .bDescriptorType = USB_DT_SS_ENDPOINT_COMP,
179 /* the following 3 values can be tweaked if necessary */
180 /* .bMaxBurst = 0, */
181 /* .bmAttributes = 0, */
182 .wBytesPerInterval = cpu_to_le16(STATUS_BYTECOUNT),
185 static struct usb_endpoint_descriptor uvc_ss_streaming_ep __initdata = {
186 .bLength = USB_DT_ENDPOINT_SIZE,
187 .bDescriptorType = USB_DT_ENDPOINT,
189 .bEndpointAddress = USB_DIR_IN,
190 .bmAttributes = USB_ENDPOINT_XFER_ISOC,
191 .wMaxPacketSize = cpu_to_le16(1024),
195 static struct usb_ss_ep_comp_descriptor uvc_ss_streaming_comp = {
196 .bLength = sizeof uvc_ss_streaming_comp,
197 .bDescriptorType = USB_DT_SS_ENDPOINT_COMP,
199 /* the following 3 values can be tweaked if necessary */
202 .wBytesPerInterval = cpu_to_le16(1024),
205 static const struct usb_descriptor_header * const uvc_fs_streaming[] = {
206 (struct usb_descriptor_header *) &uvc_streaming_intf_alt1,
207 (struct usb_descriptor_header *) &uvc_fs_streaming_ep,
211 static const struct usb_descriptor_header * const uvc_hs_streaming[] = {
212 (struct usb_descriptor_header *) &uvc_streaming_intf_alt1,
213 (struct usb_descriptor_header *) &uvc_hs_streaming_ep,
217 static const struct usb_descriptor_header * const uvc_ss_streaming[] = {
218 (struct usb_descriptor_header *) &uvc_streaming_intf_alt1,
219 (struct usb_descriptor_header *) &uvc_ss_streaming_ep,
220 (struct usb_descriptor_header *) &uvc_ss_streaming_comp,
224 /* --------------------------------------------------------------------------
229 uvc_function_ep0_complete(struct usb_ep *ep, struct usb_request *req)
231 struct uvc_device *uvc = req->context;
232 struct v4l2_event v4l2_event;
233 struct uvc_event *uvc_event = (void *)&v4l2_event.u.data;
235 if (uvc->event_setup_out) {
236 uvc->event_setup_out = 0;
238 memset(&v4l2_event, 0, sizeof(v4l2_event));
239 v4l2_event.type = UVC_EVENT_DATA;
240 uvc_event->data.length = req->actual;
241 memcpy(&uvc_event->data.data, req->buf, req->actual);
242 v4l2_event_queue(uvc->vdev, &v4l2_event);
247 uvc_function_setup(struct usb_function *f, const struct usb_ctrlrequest *ctrl)
249 struct uvc_device *uvc = to_uvc(f);
250 struct v4l2_event v4l2_event;
251 struct uvc_event *uvc_event = (void *)&v4l2_event.u.data;
253 /* printk(KERN_INFO "setup request %02x %02x value %04x index %04x %04x\n",
254 * ctrl->bRequestType, ctrl->bRequest, le16_to_cpu(ctrl->wValue),
255 * le16_to_cpu(ctrl->wIndex), le16_to_cpu(ctrl->wLength));
258 if ((ctrl->bRequestType & USB_TYPE_MASK) != USB_TYPE_CLASS) {
259 INFO(f->config->cdev, "invalid request type\n");
263 /* Stall too big requests. */
264 if (le16_to_cpu(ctrl->wLength) > UVC_MAX_REQUEST_SIZE)
267 memset(&v4l2_event, 0, sizeof(v4l2_event));
268 v4l2_event.type = UVC_EVENT_SETUP;
269 memcpy(&uvc_event->req, ctrl, sizeof(uvc_event->req));
270 v4l2_event_queue(uvc->vdev, &v4l2_event);
276 uvc_function_get_alt(struct usb_function *f, unsigned interface)
278 struct uvc_device *uvc = to_uvc(f);
280 INFO(f->config->cdev, "uvc_function_get_alt(%u)\n", interface);
282 if (interface == uvc->control_intf)
284 else if (interface != uvc->streaming_intf)
287 return uvc->state == UVC_STATE_STREAMING ? 1 : 0;
291 uvc_function_set_alt(struct usb_function *f, unsigned interface, unsigned alt)
293 struct uvc_device *uvc = to_uvc(f);
294 struct v4l2_event v4l2_event;
295 struct uvc_event *uvc_event = (void *)&v4l2_event.u.data;
298 INFO(f->config->cdev, "uvc_function_set_alt(%u, %u)\n", interface, alt);
300 if (interface == uvc->control_intf) {
304 if (uvc->state == UVC_STATE_DISCONNECTED) {
305 memset(&v4l2_event, 0, sizeof(v4l2_event));
306 v4l2_event.type = UVC_EVENT_CONNECT;
307 uvc_event->speed = f->config->cdev->gadget->speed;
308 v4l2_event_queue(uvc->vdev, &v4l2_event);
310 uvc->state = UVC_STATE_CONNECTED;
316 if (interface != uvc->streaming_intf)
320 if (usb_endpoint_xfer_bulk(&uvc->desc.vs_ep))
321 return alt ? -EINVAL : 0;
326 if (uvc->state != UVC_STATE_STREAMING)
330 usb_ep_disable(uvc->video.ep);
332 memset(&v4l2_event, 0, sizeof(v4l2_event));
333 v4l2_event.type = UVC_EVENT_STREAMOFF;
334 v4l2_event_queue(uvc->vdev, &v4l2_event);
336 uvc->state = UVC_STATE_CONNECTED;
340 if (uvc->state != UVC_STATE_CONNECTED)
344 ret = config_ep_by_speed(f->config->cdev->gadget,
345 &(uvc->func), uvc->video.ep);
348 usb_ep_enable(uvc->video.ep);
351 memset(&v4l2_event, 0, sizeof(v4l2_event));
352 v4l2_event.type = UVC_EVENT_STREAMON;
353 v4l2_event_queue(uvc->vdev, &v4l2_event);
355 uvc->state = UVC_STATE_STREAMING;
366 uvc_function_disable(struct usb_function *f)
368 struct uvc_device *uvc = to_uvc(f);
369 struct v4l2_event v4l2_event;
371 INFO(f->config->cdev, "uvc_function_disable\n");
373 memset(&v4l2_event, 0, sizeof(v4l2_event));
374 v4l2_event.type = UVC_EVENT_DISCONNECT;
375 v4l2_event_queue(uvc->vdev, &v4l2_event);
377 uvc->state = UVC_STATE_DISCONNECTED;
380 /* --------------------------------------------------------------------------
381 * Connection / disconnection
385 uvc_function_connect(struct uvc_device *uvc)
387 struct usb_composite_dev *cdev = uvc->func.config->cdev;
390 if ((ret = usb_function_activate(&uvc->func)) < 0)
391 INFO(cdev, "UVC connect failed with %d\n", ret);
395 uvc_function_disconnect(struct uvc_device *uvc)
397 struct usb_composite_dev *cdev = uvc->func.config->cdev;
400 if ((ret = usb_function_deactivate(&uvc->func)) < 0)
401 INFO(cdev, "UVC disconnect failed with %d\n", ret);
404 /* --------------------------------------------------------------------------
405 * USB probe and disconnect
409 uvc_register_video(struct uvc_device *uvc)
411 struct usb_composite_dev *cdev = uvc->func.config->cdev;
412 struct video_device *video;
414 /* TODO reference counting. */
415 video = video_device_alloc();
419 video->parent = &cdev->gadget->dev;
421 video->fops = &uvc_v4l2_fops;
422 video->release = video_device_release;
423 strncpy(video->name, cdev->gadget->name, sizeof(video->name));
426 video_set_drvdata(video, uvc);
428 return video_register_device(video, VFL_TYPE_GRABBER, -1);
431 #define UVC_COPY_DESCRIPTOR(mem, dst, desc) \
433 memcpy(mem, desc, (desc)->bLength); \
435 mem += (desc)->bLength; \
438 #define UVC_COPY_DESCRIPTORS(mem, dst, src) \
440 const struct usb_descriptor_header * const *__src; \
441 for (__src = src; *__src; ++__src) { \
442 memcpy(mem, *__src, (*__src)->bLength); \
444 mem += (*__src)->bLength; \
448 static struct usb_descriptor_header ** __init
449 uvc_copy_descriptors(struct uvc_device *uvc, enum usb_device_speed speed)
451 struct uvc_input_header_descriptor *uvc_streaming_header;
452 struct uvc_header_descriptor *uvc_control_header;
453 const struct uvc_descriptor_header * const *uvc_control_desc;
454 const struct uvc_descriptor_header * const *uvc_streaming_cls;
455 const struct usb_descriptor_header * const *uvc_streaming_std;
456 const struct usb_descriptor_header * const *src;
457 static struct usb_endpoint_descriptor *uvc_control_ep;
458 struct usb_descriptor_header **dst;
459 struct usb_descriptor_header **hdr;
460 unsigned int control_size;
461 unsigned int streaming_size;
467 case USB_SPEED_SUPER:
468 uvc_control_desc = uvc->desc.ss_control;
469 uvc_streaming_cls = uvc->desc.ss_streaming;
470 uvc_streaming_std = uvc_ss_streaming;
471 uvc_control_ep = &uvc_ss_control_ep;
475 uvc_control_desc = uvc->desc.fs_control;
476 uvc_streaming_cls = uvc->desc.hs_streaming;
477 uvc_streaming_std = uvc_hs_streaming;
478 uvc_control_ep = &uvc_fs_control_ep;
483 uvc_control_desc = uvc->desc.fs_control;
484 uvc_streaming_cls = uvc->desc.fs_streaming;
485 uvc_streaming_std = uvc_fs_streaming;
486 uvc_control_ep = &uvc_fs_control_ep;
490 /* Descriptors layout
494 * Class-specific UVC control descriptors
497 * uvc_streaming_intf_alt0
498 * Class-specific UVC streaming descriptors
499 * uvc_{fs|hs}_streaming
502 /* Count descriptors and compute their size. */
505 bytes = uvc_iad.bLength + uvc_control_intf.bLength
506 + uvc_control_ep->bLength + uvc_control_cs_ep.bLength
507 + uvc_streaming_intf_alt0.bLength;
509 if (speed == USB_SPEED_SUPER) {
510 bytes += uvc_ss_control_comp.bLength;
516 for (src = (const struct usb_descriptor_header **)uvc_control_desc;
518 control_size += (*src)->bLength;
519 bytes += (*src)->bLength;
522 for (src = (const struct usb_descriptor_header **)uvc_streaming_cls;
524 streaming_size += (*src)->bLength;
525 bytes += (*src)->bLength;
528 for (src = uvc_streaming_std; *src; ++src) {
529 bytes += (*src)->bLength;
533 mem = kmalloc((n_desc + 1) * sizeof(*src) + bytes, GFP_KERNEL);
539 mem += (n_desc + 1) * sizeof(*src);
541 /* Copy the descriptors. */
542 UVC_COPY_DESCRIPTOR(mem, dst, &uvc_iad);
543 UVC_COPY_DESCRIPTOR(mem, dst, &uvc_control_intf);
545 uvc_control_header = mem;
546 UVC_COPY_DESCRIPTORS(mem, dst,
547 (const struct usb_descriptor_header **)uvc_control_desc);
548 uvc_control_header->wTotalLength = cpu_to_le16(control_size);
549 uvc_control_header->bInCollection = 1;
550 uvc_control_header->baInterfaceNr[0] = uvc->streaming_intf;
552 UVC_COPY_DESCRIPTOR(mem, dst, uvc_control_ep);
553 if (speed == USB_SPEED_SUPER)
554 UVC_COPY_DESCRIPTOR(mem, dst, &uvc_ss_control_comp);
556 UVC_COPY_DESCRIPTOR(mem, dst, &uvc_control_cs_ep);
557 UVC_COPY_DESCRIPTOR(mem, dst, &uvc_streaming_intf_alt0);
559 uvc_streaming_header = mem;
560 UVC_COPY_DESCRIPTORS(mem, dst,
561 (const struct usb_descriptor_header**)uvc_streaming_cls);
562 uvc_streaming_header->wTotalLength = cpu_to_le16(streaming_size);
563 uvc_streaming_header->bEndpointAddress =
564 uvc_fs_streaming_ep.bEndpointAddress;
566 UVC_COPY_DESCRIPTORS(mem, dst, uvc_streaming_std);
573 uvc_function_unbind(struct usb_configuration *c, struct usb_function *f)
575 struct usb_composite_dev *cdev = c->cdev;
576 struct uvc_device *uvc = to_uvc(f);
578 INFO(cdev, "uvc_function_unbind\n");
581 if (uvc->vdev->minor == -1)
582 video_device_release(uvc->vdev);
584 video_unregister_device(uvc->vdev);
589 uvc->control_ep->driver_data = NULL;
591 uvc->video.ep->driver_data = NULL;
593 if (uvc->control_req) {
594 usb_ep_free_request(cdev->gadget->ep0, uvc->control_req);
595 kfree(uvc->control_buf);
598 kfree(f->descriptors);
599 kfree(f->hs_descriptors);
600 kfree(f->ss_descriptors);
606 uvc_function_bind(struct usb_configuration *c, struct usb_function *f)
608 struct usb_composite_dev *cdev = c->cdev;
609 struct uvc_device *uvc = to_uvc(f);
613 INFO(cdev, "uvc_function_bind\n");
615 /* sanity check the streaming endpoint module parameters */
616 if (streaming_interval < 1)
617 streaming_interval = 1;
618 if (streaming_interval > 16)
619 streaming_interval = 16;
620 if (streaming_mult > 2)
622 if (streaming_maxburst > 15)
623 streaming_maxburst = 15;
626 * fill in the FS video streaming specific descriptors from the
629 uvc_fs_streaming_ep.wMaxPacketSize = streaming_maxpacket > 1023 ?
630 1023 : streaming_maxpacket;
631 uvc_fs_streaming_ep.bInterval = streaming_interval;
633 /* Allocate endpoints. */
634 ep = usb_ep_autoconfig(cdev->gadget, &uvc_fs_control_ep);
636 INFO(cdev, "Unable to allocate control EP\n");
639 uvc->control_ep = ep;
640 ep->driver_data = uvc;
642 ep = usb_ep_autoconfig(cdev->gadget, &uvc_fs_streaming_ep);
644 INFO(cdev, "Unable to allocate streaming EP\n");
648 ep->driver_data = uvc;
650 /* Allocate interface IDs. */
651 if ((ret = usb_interface_id(c, f)) < 0)
653 uvc_iad.bFirstInterface = ret;
654 uvc_control_intf.bInterfaceNumber = ret;
655 uvc->control_intf = ret;
657 if ((ret = usb_interface_id(c, f)) < 0)
659 uvc_streaming_intf_alt0.bInterfaceNumber = ret;
660 uvc_streaming_intf_alt1.bInterfaceNumber = ret;
661 uvc->streaming_intf = ret;
663 /* sanity check the streaming endpoint module parameters */
664 if (streaming_maxpacket > 1024)
665 streaming_maxpacket = 1024;
667 /* Copy descriptors for FS. */
668 f->descriptors = uvc_copy_descriptors(uvc, USB_SPEED_FULL);
670 /* support high speed hardware */
671 if (gadget_is_dualspeed(cdev->gadget)) {
673 * Fill in the HS descriptors from the module parameters for the
674 * Video Streaming endpoint.
675 * NOTE: We assume that the user knows what they are doing and
676 * won't give parameters that their UDC doesn't support.
678 uvc_hs_streaming_ep.wMaxPacketSize = streaming_maxpacket;
679 uvc_hs_streaming_ep.wMaxPacketSize |= streaming_mult << 11;
680 uvc_hs_streaming_ep.bInterval = streaming_interval;
681 uvc_hs_streaming_ep.bEndpointAddress =
682 uvc_fs_streaming_ep.bEndpointAddress;
684 /* Copy descriptors. */
685 f->hs_descriptors = uvc_copy_descriptors(uvc, USB_SPEED_HIGH);
688 /* support super speed hardware */
689 if (gadget_is_superspeed(c->cdev->gadget)) {
691 * Fill in the SS descriptors from the module parameters for the
692 * Video Streaming endpoint.
693 * NOTE: We assume that the user knows what they are doing and
694 * won't give parameters that their UDC doesn't support.
696 uvc_ss_streaming_ep.wMaxPacketSize = streaming_maxpacket;
697 uvc_ss_streaming_ep.bInterval = streaming_interval;
698 uvc_ss_streaming_comp.bmAttributes = streaming_mult;
699 uvc_ss_streaming_comp.bMaxBurst = streaming_maxburst;
700 uvc_ss_streaming_comp.wBytesPerInterval =
701 streaming_maxpacket * (streaming_mult + 1) *
702 (streaming_maxburst + 1);
703 uvc_ss_streaming_ep.bEndpointAddress =
704 uvc_fs_streaming_ep.bEndpointAddress;
706 /* Copy descriptors. */
707 f->ss_descriptors = uvc_copy_descriptors(uvc, USB_SPEED_SUPER);
710 /* Preallocate control endpoint request. */
711 uvc->control_req = usb_ep_alloc_request(cdev->gadget->ep0, GFP_KERNEL);
712 uvc->control_buf = kmalloc(UVC_MAX_REQUEST_SIZE, GFP_KERNEL);
713 if (uvc->control_req == NULL || uvc->control_buf == NULL) {
718 uvc->control_req->buf = uvc->control_buf;
719 uvc->control_req->complete = uvc_function_ep0_complete;
720 uvc->control_req->context = uvc;
722 /* Avoid letting this gadget enumerate until the userspace server is
725 if ((ret = usb_function_deactivate(f)) < 0)
728 /* Initialise video. */
729 ret = uvc_video_init(&uvc->video);
733 /* Register a V4L2 device. */
734 ret = uvc_register_video(uvc);
736 printk(KERN_INFO "Unable to register video device\n");
743 uvc_function_unbind(c, f);
747 /* --------------------------------------------------------------------------
748 * USB gadget function
752 * uvc_bind_config - add a UVC function to a configuration
753 * @c: the configuration to support the UVC instance
754 * Context: single threaded during gadget setup
756 * Returns zero on success, else negative errno.
758 * Caller must have called @uvc_setup(). Caller is also responsible for
759 * calling @uvc_cleanup() before module unload.
762 uvc_bind_config(struct usb_configuration *c,
763 const struct uvc_descriptor_header * const *fs_control,
764 const struct uvc_descriptor_header * const *ss_control,
765 const struct uvc_descriptor_header * const *fs_streaming,
766 const struct uvc_descriptor_header * const *hs_streaming,
767 const struct uvc_descriptor_header * const *ss_streaming)
769 struct uvc_device *uvc;
772 /* TODO Check if the USB device controller supports the required
775 if (!gadget_is_dualspeed(c->cdev->gadget))
778 uvc = kzalloc(sizeof(*uvc), GFP_KERNEL);
782 uvc->state = UVC_STATE_DISCONNECTED;
784 /* Validate the descriptors. */
785 if (fs_control == NULL || fs_control[0] == NULL ||
786 fs_control[0]->bDescriptorSubType != UVC_VC_HEADER)
789 if (ss_control == NULL || ss_control[0] == NULL ||
790 ss_control[0]->bDescriptorSubType != UVC_VC_HEADER)
793 if (fs_streaming == NULL || fs_streaming[0] == NULL ||
794 fs_streaming[0]->bDescriptorSubType != UVC_VS_INPUT_HEADER)
797 if (hs_streaming == NULL || hs_streaming[0] == NULL ||
798 hs_streaming[0]->bDescriptorSubType != UVC_VS_INPUT_HEADER)
801 if (ss_streaming == NULL || ss_streaming[0] == NULL ||
802 ss_streaming[0]->bDescriptorSubType != UVC_VS_INPUT_HEADER)
805 uvc->desc.fs_control = fs_control;
806 uvc->desc.ss_control = ss_control;
807 uvc->desc.fs_streaming = fs_streaming;
808 uvc->desc.hs_streaming = hs_streaming;
809 uvc->desc.ss_streaming = ss_streaming;
811 /* maybe allocate device-global string IDs, and patch descriptors */
812 if (uvc_en_us_strings[UVC_STRING_ASSOCIATION_IDX].id == 0) {
813 /* Allocate string descriptor numbers. */
814 ret = usb_string_id(c->cdev);
817 uvc_en_us_strings[UVC_STRING_ASSOCIATION_IDX].id = ret;
818 uvc_iad.iFunction = ret;
820 ret = usb_string_id(c->cdev);
823 uvc_en_us_strings[UVC_STRING_CONTROL_IDX].id = ret;
824 uvc_control_intf.iInterface = ret;
826 ret = usb_string_id(c->cdev);
829 uvc_en_us_strings[UVC_STRING_STREAMING_IDX].id = ret;
830 uvc_streaming_intf_alt0.iInterface = ret;
831 uvc_streaming_intf_alt1.iInterface = ret;
834 /* Register the function. */
835 uvc->func.name = "uvc";
836 uvc->func.strings = uvc_function_strings;
837 uvc->func.bind = uvc_function_bind;
838 uvc->func.unbind = uvc_function_unbind;
839 uvc->func.get_alt = uvc_function_get_alt;
840 uvc->func.set_alt = uvc_function_set_alt;
841 uvc->func.disable = uvc_function_disable;
842 uvc->func.setup = uvc_function_setup;
844 ret = usb_add_function(c, &uvc->func);
855 module_param_named(trace, uvc_gadget_trace_param, uint, S_IRUGO|S_IWUSR);
856 MODULE_PARM_DESC(trace, "Trace level bitmask");