?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
x86/PCI: use host bridge _CRS info on ASUS M2V-MX SE
[linux-btrfs-devel.git] / drivers / usb / gadget / f_uvc.c
blob7a8b9aa4aea5468e8ce92b0d2f8184d409509721
1 /*
2 * uvc_gadget.c -- USB Video Class Gadget driver
3 *
4 * Copyright (C) 2009-2010
5 * Laurent Pinchart (laurent.pinchart@ideasonboard.com)
6 *
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.
11 *
12 */
13
14 #include <linux/kernel.h>
15 #include <linux/device.h>
16 #include <linux/errno.h>
17 #include <linux/fs.h>
18 #include <linux/list.h>
19 #include <linux/mutex.h>
20 #include <linux/usb/ch9.h>
21 #include <linux/usb/gadget.h>
22 #include <linux/usb/video.h>
23 #include <linux/vmalloc.h>
24 #include <linux/wait.h>
25
26 #include <media/v4l2-dev.h>
27 #include <media/v4l2-event.h>
28
29 #include "uvc.h"
30
31 unsigned int uvc_gadget_trace_param;
32
33 /* --------------------------------------------------------------------------
34 * Function descriptors
35 */
36
37 /* string IDs are assigned dynamically */
38
39 #define UVC_STRING_ASSOCIATION_IDX 0
40 #define UVC_STRING_CONTROL_IDX 1
41 #define UVC_STRING_STREAMING_IDX 2
42
43 static struct usb_string uvc_en_us_strings[] = {
44 [UVC_STRING_ASSOCIATION_IDX].s = "UVC Camera",
45 [UVC_STRING_CONTROL_IDX].s = "Video Control",
46 [UVC_STRING_STREAMING_IDX].s = "Video Streaming",
47 { }
48 };
49
50 static struct usb_gadget_strings uvc_stringtab = {
51 .language = 0x0409, /* en-us */
52 .strings = uvc_en_us_strings,
53 };
54
55 static struct usb_gadget_strings *uvc_function_strings[] = {
56 &uvc_stringtab,
57 NULL,
58 };
59
60 #define UVC_INTF_VIDEO_CONTROL 0
61 #define UVC_INTF_VIDEO_STREAMING 1
62
63 static struct usb_interface_assoc_descriptor uvc_iad __initdata = {
64 .bLength = sizeof(uvc_iad),
65 .bDescriptorType = USB_DT_INTERFACE_ASSOCIATION,
66 .bFirstInterface = 0,
67 .bInterfaceCount = 2,
68 .bFunctionClass = USB_CLASS_VIDEO,
69 .bFunctionSubClass = UVC_SC_VIDEO_INTERFACE_COLLECTION,
70 .bFunctionProtocol = 0x00,
71 .iFunction = 0,
72 };
73
74 static struct usb_interface_descriptor uvc_control_intf __initdata = {
75 .bLength = USB_DT_INTERFACE_SIZE,
76 .bDescriptorType = USB_DT_INTERFACE,
77 .bInterfaceNumber = UVC_INTF_VIDEO_CONTROL,
78 .bAlternateSetting = 0,
79 .bNumEndpoints = 1,
80 .bInterfaceClass = USB_CLASS_VIDEO,
81 .bInterfaceSubClass = UVC_SC_VIDEOCONTROL,
82 .bInterfaceProtocol = 0x00,
83 .iInterface = 0,
84 };
85
86 static struct usb_endpoint_descriptor uvc_control_ep __initdata = {
87 .bLength = USB_DT_ENDPOINT_SIZE,
88 .bDescriptorType = USB_DT_ENDPOINT,
89 .bEndpointAddress = USB_DIR_IN,
90 .bmAttributes = USB_ENDPOINT_XFER_INT,
91 .wMaxPacketSize = cpu_to_le16(16),
92 .bInterval = 8,
93 };
94
95 static struct uvc_control_endpoint_descriptor uvc_control_cs_ep __initdata = {
96 .bLength = UVC_DT_CONTROL_ENDPOINT_SIZE,
97 .bDescriptorType = USB_DT_CS_ENDPOINT,
98 .bDescriptorSubType = UVC_EP_INTERRUPT,
99 .wMaxTransferSize = cpu_to_le16(16),
100 };
101
102 static struct usb_interface_descriptor uvc_streaming_intf_alt0 __initdata = {
103 .bLength = USB_DT_INTERFACE_SIZE,
104 .bDescriptorType = USB_DT_INTERFACE,
105 .bInterfaceNumber = UVC_INTF_VIDEO_STREAMING,
106 .bAlternateSetting = 0,
107 .bNumEndpoints = 0,
108 .bInterfaceClass = USB_CLASS_VIDEO,
109 .bInterfaceSubClass = UVC_SC_VIDEOSTREAMING,
110 .bInterfaceProtocol = 0x00,
111 .iInterface = 0,
112 };
113
114 static struct usb_interface_descriptor uvc_streaming_intf_alt1 __initdata = {
115 .bLength = USB_DT_INTERFACE_SIZE,
116 .bDescriptorType = USB_DT_INTERFACE,
117 .bInterfaceNumber = UVC_INTF_VIDEO_STREAMING,
118 .bAlternateSetting = 1,
119 .bNumEndpoints = 1,
120 .bInterfaceClass = USB_CLASS_VIDEO,
121 .bInterfaceSubClass = UVC_SC_VIDEOSTREAMING,
122 .bInterfaceProtocol = 0x00,
123 .iInterface = 0,
124 };
125
126 static struct usb_endpoint_descriptor uvc_streaming_ep = {
127 .bLength = USB_DT_ENDPOINT_SIZE,
128 .bDescriptorType = USB_DT_ENDPOINT,
129 .bEndpointAddress = USB_DIR_IN,
130 .bmAttributes = USB_ENDPOINT_XFER_ISOC,
131 .wMaxPacketSize = cpu_to_le16(512),
132 .bInterval = 1,
133 };
134
135 static const struct usb_descriptor_header * const uvc_fs_streaming[] = {
136 (struct usb_descriptor_header *) &uvc_streaming_intf_alt1,
137 (struct usb_descriptor_header *) &uvc_streaming_ep,
138 NULL,
139 };
140
141 static const struct usb_descriptor_header * const uvc_hs_streaming[] = {
142 (struct usb_descriptor_header *) &uvc_streaming_intf_alt1,
143 (struct usb_descriptor_header *) &uvc_streaming_ep,
144 NULL,
145 };
146
147 /* --------------------------------------------------------------------------
148 * Control requests
149 */
150
151 static void
152 uvc_function_ep0_complete(struct usb_ep *ep, struct usb_request *req)
153 {
154 struct uvc_device *uvc = req->context;
155 struct v4l2_event v4l2_event;
156 struct uvc_event *uvc_event = (void *)&v4l2_event.u.data;
157
158 if (uvc->event_setup_out) {
159 uvc->event_setup_out = 0;
160
161 memset(&v4l2_event, 0, sizeof(v4l2_event));
162 v4l2_event.type = UVC_EVENT_DATA;
163 uvc_event->data.length = req->actual;
164 memcpy(&uvc_event->data.data, req->buf, req->actual);
165 v4l2_event_queue(uvc->vdev, &v4l2_event);
166 }
167 }
168
169 static int
170 uvc_function_setup(struct usb_function *f, const struct usb_ctrlrequest *ctrl)
171 {
172 struct uvc_device *uvc = to_uvc(f);
173 struct v4l2_event v4l2_event;
174 struct uvc_event *uvc_event = (void *)&v4l2_event.u.data;
175
176 /* printk(KERN_INFO "setup request %02x %02x value %04x index %04x %04x\n",
177 * ctrl->bRequestType, ctrl->bRequest, le16_to_cpu(ctrl->wValue),
178 * le16_to_cpu(ctrl->wIndex), le16_to_cpu(ctrl->wLength));
179 */
180
181 if ((ctrl->bRequestType & USB_TYPE_MASK) != USB_TYPE_CLASS) {
182 INFO(f->config->cdev, "invalid request type\n");
183 return -EINVAL;
184 }
185
186 /* Stall too big requests. */
187 if (le16_to_cpu(ctrl->wLength) > UVC_MAX_REQUEST_SIZE)
188 return -EINVAL;
189
190 memset(&v4l2_event, 0, sizeof(v4l2_event));
191 v4l2_event.type = UVC_EVENT_SETUP;
192 memcpy(&uvc_event->req, ctrl, sizeof(uvc_event->req));
193 v4l2_event_queue(uvc->vdev, &v4l2_event);
194
195 return 0;
196 }
197
198 static int
199 uvc_function_get_alt(struct usb_function *f, unsigned interface)
200 {
201 struct uvc_device *uvc = to_uvc(f);
202
203 INFO(f->config->cdev, "uvc_function_get_alt(%u)\n", interface);
204
205 if (interface == uvc->control_intf)
206 return 0;
207 else if (interface != uvc->streaming_intf)
208 return -EINVAL;
209 else
210 return uvc->state == UVC_STATE_STREAMING ? 1 : 0;
211 }
212
213 static int
214 uvc_function_set_alt(struct usb_function *f, unsigned interface, unsigned alt)
215 {
216 struct uvc_device *uvc = to_uvc(f);
217 struct v4l2_event v4l2_event;
218 struct uvc_event *uvc_event = (void *)&v4l2_event.u.data;
219
220 INFO(f->config->cdev, "uvc_function_set_alt(%u, %u)\n", interface, alt);
221
222 if (interface == uvc->control_intf) {
223 if (alt)
224 return -EINVAL;
225
226 if (uvc->state == UVC_STATE_DISCONNECTED) {
227 memset(&v4l2_event, 0, sizeof(v4l2_event));
228 v4l2_event.type = UVC_EVENT_CONNECT;
229 uvc_event->speed = f->config->cdev->gadget->speed;
230 v4l2_event_queue(uvc->vdev, &v4l2_event);
231
232 uvc->state = UVC_STATE_CONNECTED;
233 }
234
235 return 0;
236 }
237
238 if (interface != uvc->streaming_intf)
239 return -EINVAL;
240
241 /* TODO
242 if (usb_endpoint_xfer_bulk(&uvc->desc.vs_ep))
243 return alt ? -EINVAL : 0;
244 */
245
246 switch (alt) {
247 case 0:
248 if (uvc->state != UVC_STATE_STREAMING)
249 return 0;
250
251 if (uvc->video.ep)
252 usb_ep_disable(uvc->video.ep);
253
254 memset(&v4l2_event, 0, sizeof(v4l2_event));
255 v4l2_event.type = UVC_EVENT_STREAMOFF;
256 v4l2_event_queue(uvc->vdev, &v4l2_event);
257
258 uvc->state = UVC_STATE_CONNECTED;
259 break;
260
261 case 1:
262 if (uvc->state != UVC_STATE_CONNECTED)
263 return 0;
264
265 if (uvc->video.ep) {
266 uvc->video.ep->desc = &uvc_streaming_ep;
267 usb_ep_enable(uvc->video.ep);
268 }
269
270 memset(&v4l2_event, 0, sizeof(v4l2_event));
271 v4l2_event.type = UVC_EVENT_STREAMON;
272 v4l2_event_queue(uvc->vdev, &v4l2_event);
273
274 uvc->state = UVC_STATE_STREAMING;
275 break;
276
277 default:
278 return -EINVAL;
279 }
280
281 return 0;
282 }
283
284 static void
285 uvc_function_disable(struct usb_function *f)
286 {
287 struct uvc_device *uvc = to_uvc(f);
288 struct v4l2_event v4l2_event;
289
290 INFO(f->config->cdev, "uvc_function_disable\n");
291
292 memset(&v4l2_event, 0, sizeof(v4l2_event));
293 v4l2_event.type = UVC_EVENT_DISCONNECT;
294 v4l2_event_queue(uvc->vdev, &v4l2_event);
295
296 uvc->state = UVC_STATE_DISCONNECTED;
297 }
298
299 /* --------------------------------------------------------------------------
300 * Connection / disconnection
301 */
302
303 void
304 uvc_function_connect(struct uvc_device *uvc)
305 {
306 struct usb_composite_dev *cdev = uvc->func.config->cdev;
307 int ret;
308
309 if ((ret = usb_function_activate(&uvc->func)) < 0)
310 INFO(cdev, "UVC connect failed with %d\n", ret);
311 }
312
313 void
314 uvc_function_disconnect(struct uvc_device *uvc)
315 {
316 struct usb_composite_dev *cdev = uvc->func.config->cdev;
317 int ret;
318
319 if ((ret = usb_function_deactivate(&uvc->func)) < 0)
320 INFO(cdev, "UVC disconnect failed with %d\n", ret);
321 }
322
323 /* --------------------------------------------------------------------------
324 * USB probe and disconnect
325 */
326
327 static int
328 uvc_register_video(struct uvc_device *uvc)
329 {
330 struct usb_composite_dev *cdev = uvc->func.config->cdev;
331 struct video_device *video;
332
333 /* TODO reference counting. */
334 video = video_device_alloc();
335 if (video == NULL)
336 return -ENOMEM;
337
338 video->parent = &cdev->gadget->dev;
339 video->minor = -1;
340 video->fops = &uvc_v4l2_fops;
341 video->release = video_device_release;
342 strncpy(video->name, cdev->gadget->name, sizeof(video->name));
343
344 uvc->vdev = video;
345 video_set_drvdata(video, uvc);
346
347 return video_register_device(video, VFL_TYPE_GRABBER, -1);
348 }
349
350 #define UVC_COPY_DESCRIPTOR(mem, dst, desc) \
351 do { \
352 memcpy(mem, desc, (desc)->bLength); \
353 *(dst)++ = mem; \
354 mem += (desc)->bLength; \
355 } while (0);
356
357 #define UVC_COPY_DESCRIPTORS(mem, dst, src) \
358 do { \
359 const struct usb_descriptor_header * const *__src; \
360 for (__src = src; *__src; ++__src) { \
361 memcpy(mem, *__src, (*__src)->bLength); \
362 *dst++ = mem; \
363 mem += (*__src)->bLength; \
364 } \
365 } while (0)
366
367 static struct usb_descriptor_header ** __init
368 uvc_copy_descriptors(struct uvc_device *uvc, enum usb_device_speed speed)
369 {
370 struct uvc_input_header_descriptor *uvc_streaming_header;
371 struct uvc_header_descriptor *uvc_control_header;
372 const struct uvc_descriptor_header * const *uvc_streaming_cls;
373 const struct usb_descriptor_header * const *uvc_streaming_std;
374 const struct usb_descriptor_header * const *src;
375 struct usb_descriptor_header **dst;
376 struct usb_descriptor_header **hdr;
377 unsigned int control_size;
378 unsigned int streaming_size;
379 unsigned int n_desc;
380 unsigned int bytes;
381 void *mem;
382
383 uvc_streaming_cls = (speed == USB_SPEED_FULL)
384 ? uvc->desc.fs_streaming : uvc->desc.hs_streaming;
385 uvc_streaming_std = (speed == USB_SPEED_FULL)
386 ? uvc_fs_streaming : uvc_hs_streaming;
387
388 /* Descriptors layout
389 *
390 * uvc_iad
391 * uvc_control_intf
392 * Class-specific UVC control descriptors
393 * uvc_control_ep
394 * uvc_control_cs_ep
395 * uvc_streaming_intf_alt0
396 * Class-specific UVC streaming descriptors
397 * uvc_{fs|hs}_streaming
398 */
399
400 /* Count descriptors and compute their size. */
401 control_size = 0;
402 streaming_size = 0;
403 bytes = uvc_iad.bLength + uvc_control_intf.bLength
404 + uvc_control_ep.bLength + uvc_control_cs_ep.bLength
405 + uvc_streaming_intf_alt0.bLength;
406 n_desc = 5;
407
408 for (src = (const struct usb_descriptor_header**)uvc->desc.control; *src; ++src) {
409 control_size += (*src)->bLength;
410 bytes += (*src)->bLength;
411 n_desc++;
412 }
413 for (src = (const struct usb_descriptor_header**)uvc_streaming_cls; *src; ++src) {
414 streaming_size += (*src)->bLength;
415 bytes += (*src)->bLength;
416 n_desc++;
417 }
418 for (src = uvc_streaming_std; *src; ++src) {
419 bytes += (*src)->bLength;
420 n_desc++;
421 }
422
423 mem = kmalloc((n_desc + 1) * sizeof(*src) + bytes, GFP_KERNEL);
424 if (mem == NULL)
425 return NULL;
426
427 hdr = mem;
428 dst = mem;
429 mem += (n_desc + 1) * sizeof(*src);
430
431 /* Copy the descriptors. */
432 UVC_COPY_DESCRIPTOR(mem, dst, &uvc_iad);
433 UVC_COPY_DESCRIPTOR(mem, dst, &uvc_control_intf);
434
435 uvc_control_header = mem;
436 UVC_COPY_DESCRIPTORS(mem, dst,
437 (const struct usb_descriptor_header**)uvc->desc.control);
438 uvc_control_header->wTotalLength = cpu_to_le16(control_size);
439 uvc_control_header->bInCollection = 1;
440 uvc_control_header->baInterfaceNr[0] = uvc->streaming_intf;
441
442 UVC_COPY_DESCRIPTOR(mem, dst, &uvc_control_ep);
443 UVC_COPY_DESCRIPTOR(mem, dst, &uvc_control_cs_ep);
444 UVC_COPY_DESCRIPTOR(mem, dst, &uvc_streaming_intf_alt0);
445
446 uvc_streaming_header = mem;
447 UVC_COPY_DESCRIPTORS(mem, dst,
448 (const struct usb_descriptor_header**)uvc_streaming_cls);
449 uvc_streaming_header->wTotalLength = cpu_to_le16(streaming_size);
450 uvc_streaming_header->bEndpointAddress = uvc_streaming_ep.bEndpointAddress;
451
452 UVC_COPY_DESCRIPTORS(mem, dst, uvc_streaming_std);
453
454 *dst = NULL;
455 return hdr;
456 }
457
458 static void
459 uvc_function_unbind(struct usb_configuration *c, struct usb_function *f)
460 {
461 struct usb_composite_dev *cdev = c->cdev;
462 struct uvc_device *uvc = to_uvc(f);
463
464 INFO(cdev, "uvc_function_unbind\n");
465
466 if (uvc->vdev) {
467 if (uvc->vdev->minor == -1)
468 video_device_release(uvc->vdev);
469 else
470 video_unregister_device(uvc->vdev);
471 uvc->vdev = NULL;
472 }
473
474 if (uvc->control_ep)
475 uvc->control_ep->driver_data = NULL;
476 if (uvc->video.ep)
477 uvc->video.ep->driver_data = NULL;
478
479 if (uvc->control_req) {
480 usb_ep_free_request(cdev->gadget->ep0, uvc->control_req);
481 kfree(uvc->control_buf);
482 }
483
484 kfree(f->descriptors);
485 kfree(f->hs_descriptors);
486
487 kfree(uvc);
488 }
489
490 static int __init
491 uvc_function_bind(struct usb_configuration *c, struct usb_function *f)
492 {
493 struct usb_composite_dev *cdev = c->cdev;
494 struct uvc_device *uvc = to_uvc(f);
495 struct usb_ep *ep;
496 int ret = -EINVAL;
497
498 INFO(cdev, "uvc_function_bind\n");
499
500 /* Allocate endpoints. */
501 ep = usb_ep_autoconfig(cdev->gadget, &uvc_control_ep);
502 if (!ep) {
503 INFO(cdev, "Unable to allocate control EP\n");
504 goto error;
505 }
506 uvc->control_ep = ep;
507 ep->driver_data = uvc;
508
509 ep = usb_ep_autoconfig(cdev->gadget, &uvc_streaming_ep);
510 if (!ep) {
511 INFO(cdev, "Unable to allocate streaming EP\n");
512 goto error;
513 }
514 uvc->video.ep = ep;
515 ep->driver_data = uvc;
516
517 /* Allocate interface IDs. */
518 if ((ret = usb_interface_id(c, f)) < 0)
519 goto error;
520 uvc_iad.bFirstInterface = ret;
521 uvc_control_intf.bInterfaceNumber = ret;
522 uvc->control_intf = ret;
523
524 if ((ret = usb_interface_id(c, f)) < 0)
525 goto error;
526 uvc_streaming_intf_alt0.bInterfaceNumber = ret;
527 uvc_streaming_intf_alt1.bInterfaceNumber = ret;
528 uvc->streaming_intf = ret;
529
530 /* Copy descriptors. */
531 f->descriptors = uvc_copy_descriptors(uvc, USB_SPEED_FULL);
532 f->hs_descriptors = uvc_copy_descriptors(uvc, USB_SPEED_HIGH);
533
534 /* Preallocate control endpoint request. */
535 uvc->control_req = usb_ep_alloc_request(cdev->gadget->ep0, GFP_KERNEL);
536 uvc->control_buf = kmalloc(UVC_MAX_REQUEST_SIZE, GFP_KERNEL);
537 if (uvc->control_req == NULL || uvc->control_buf == NULL) {
538 ret = -ENOMEM;
539 goto error;
540 }
541
542 uvc->control_req->buf = uvc->control_buf;
543 uvc->control_req->complete = uvc_function_ep0_complete;
544 uvc->control_req->context = uvc;
545
546 /* Avoid letting this gadget enumerate until the userspace server is
547 * active.
548 */
549 if ((ret = usb_function_deactivate(f)) < 0)
550 goto error;
551
552 /* Initialise video. */
553 ret = uvc_video_init(&uvc->video);
554 if (ret < 0)
555 goto error;
556
557 /* Register a V4L2 device. */
558 ret = uvc_register_video(uvc);
559 if (ret < 0) {
560 printk(KERN_INFO "Unable to register video device\n");
561 goto error;
562 }
563
564 return 0;
565
566 error:
567 uvc_function_unbind(c, f);
568 return ret;
569 }
570
571 /* --------------------------------------------------------------------------
572 * USB gadget function
573 */
574
575 /**
576 * uvc_bind_config - add a UVC function to a configuration
577 * @c: the configuration to support the UVC instance
578 * Context: single threaded during gadget setup
579 *
580 * Returns zero on success, else negative errno.
581 *
582 * Caller must have called @uvc_setup(). Caller is also responsible for
583 * calling @uvc_cleanup() before module unload.
584 */
585 int __init
586 uvc_bind_config(struct usb_configuration *c,
587 const struct uvc_descriptor_header * const *control,
588 const struct uvc_descriptor_header * const *fs_streaming,
589 const struct uvc_descriptor_header * const *hs_streaming)
590 {
591 struct uvc_device *uvc;
592 int ret = 0;
593
594 /* TODO Check if the USB device controller supports the required
595 * features.
596 */
597 if (!gadget_is_dualspeed(c->cdev->gadget))
598 return -EINVAL;
599
600 uvc = kzalloc(sizeof(*uvc), GFP_KERNEL);
601 if (uvc == NULL)
602 return -ENOMEM;
603
604 uvc->state = UVC_STATE_DISCONNECTED;
605
606 /* Validate the descriptors. */
607 if (control == NULL || control[0] == NULL ||
608 control[0]->bDescriptorSubType != UVC_VC_HEADER)
609 goto error;
610
611 if (fs_streaming == NULL || fs_streaming[0] == NULL ||
612 fs_streaming[0]->bDescriptorSubType != UVC_VS_INPUT_HEADER)
613 goto error;
614
615 if (hs_streaming == NULL || hs_streaming[0] == NULL ||
616 hs_streaming[0]->bDescriptorSubType != UVC_VS_INPUT_HEADER)
617 goto error;
618
619 uvc->desc.control = control;
620 uvc->desc.fs_streaming = fs_streaming;
621 uvc->desc.hs_streaming = hs_streaming;
622
623 /* Allocate string descriptor numbers. */
624 if ((ret = usb_string_id(c->cdev)) < 0)
625 goto error;
626 uvc_en_us_strings[UVC_STRING_ASSOCIATION_IDX].id = ret;
627 uvc_iad.iFunction = ret;
628
629 if ((ret = usb_string_id(c->cdev)) < 0)
630 goto error;
631 uvc_en_us_strings[UVC_STRING_CONTROL_IDX].id = ret;
632 uvc_control_intf.iInterface = ret;
633
634 if ((ret = usb_string_id(c->cdev)) < 0)
635 goto error;
636 uvc_en_us_strings[UVC_STRING_STREAMING_IDX].id = ret;
637 uvc_streaming_intf_alt0.iInterface = ret;
638 uvc_streaming_intf_alt1.iInterface = ret;
639
640 /* Register the function. */
641 uvc->func.name = "uvc";
642 uvc->func.strings = uvc_function_strings;
643 uvc->func.bind = uvc_function_bind;
644 uvc->func.unbind = uvc_function_unbind;
645 uvc->func.get_alt = uvc_function_get_alt;
646 uvc->func.set_alt = uvc_function_set_alt;
647 uvc->func.disable = uvc_function_disable;
648 uvc->func.setup = uvc_function_setup;
649
650 ret = usb_add_function(c, &uvc->func);
651 if (ret)
652 kfree(uvc);
653
654 return ret;
655
656 error:
657 kfree(uvc);
658 return ret;
659 }
660
661 module_param_named(trace, uvc_gadget_trace_param, uint, S_IRUGO|S_IWUSR);
662 MODULE_PARM_DESC(trace, "Trace level bitmask");
663
Linux Btrfs Development