projects / deliverable / linux.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
Merge branch 'master' of git://git.kernel.org/pub/scm/linux/kernel/git/linville/wirel...
[deliverable/linux.git] / drivers / usb / gadget / f_uvc.c
CommitLineData
cdda479f
LP		 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.
cdda479f
LP		 11 */
12
13#include <linux/kernel.h>
14#include <linux/device.h>
15#include <linux/errno.h>
16#include <linux/fs.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>
24
25#include <media/v4l2-dev.h>
26#include <media/v4l2-event.h>
27
28#include "uvc.h"
29
5d9955f8 30unsigned int uvc_gadget_trace_param;
cdda479f 31
fbcaba0e
BS		 32/*-------------------------------------------------------------------------*/
33
34/* module parameters specific to the Video streaming endpoint */
35static unsigned streaming_interval = 1;
36module_param(streaming_interval, uint, S_IRUGO|S_IWUSR);
37MODULE_PARM_DESC(streaming_interval, "1 - 16");
38
39static unsigned streaming_maxpacket = 1024;
40module_param(streaming_maxpacket, uint, S_IRUGO|S_IWUSR);
41MODULE_PARM_DESC(streaming_maxpacket, "0 - 1023 (fs), 0 - 1024 (hs/ss)");
42
43static unsigned streaming_mult;
44module_param(streaming_mult, uint, S_IRUGO|S_IWUSR);
45MODULE_PARM_DESC(streaming_mult, "0 - 2 (hs/ss only)");
46
47static unsigned streaming_maxburst;
48module_param(streaming_maxburst, uint, S_IRUGO|S_IWUSR);
49MODULE_PARM_DESC(streaming_maxburst, "0 - 15 (ss only)");
50
cdda479f
LP		 51/* --------------------------------------------------------------------------
52 * Function descriptors
53 */
54
55/* string IDs are assigned dynamically */
56
57#define UVC_STRING_ASSOCIATION_IDX 0
58#define UVC_STRING_CONTROL_IDX 1
59#define UVC_STRING_STREAMING_IDX 2
60
61static 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",
65 { }
66};
67
68static struct usb_gadget_strings uvc_stringtab = {
69 .language = 0x0409, /* en-us */
70 .strings = uvc_en_us_strings,
71};
72
73static struct usb_gadget_strings *uvc_function_strings[] = {
74 &uvc_stringtab,
75 NULL,
76};
77
78#define UVC_INTF_VIDEO_CONTROL 0
79#define UVC_INTF_VIDEO_STREAMING 1
80
57976636
BS		 81#define STATUS_BYTECOUNT 16 /* 16 bytes status */
82
cdda479f 83static struct usb_interface_assoc_descriptor uvc_iad __initdata = {
bbafc0cb 84 .bLength = sizeof(uvc_iad),
cdda479f
LP		 85 .bDescriptorType = USB_DT_INTERFACE_ASSOCIATION,
86 .bFirstInterface = 0,
87 .bInterfaceCount = 2,
88 .bFunctionClass = USB_CLASS_VIDEO,
bbafc0cb 89 .bFunctionSubClass = UVC_SC_VIDEO_INTERFACE_COLLECTION,
cdda479f
LP		 90 .bFunctionProtocol = 0x00,
91 .iFunction = 0,
92};
93
94static 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,
99 .bNumEndpoints = 1,
100 .bInterfaceClass = USB_CLASS_VIDEO,
bbafc0cb 101 .bInterfaceSubClass = UVC_SC_VIDEOCONTROL,
cdda479f
LP		 102 .bInterfaceProtocol = 0x00,
103 .iInterface = 0,
104};
105
fbcaba0e 106static struct usb_endpoint_descriptor uvc_fs_control_ep __initdata = {
cdda479f
LP		 107 .bLength = USB_DT_ENDPOINT_SIZE,
108 .bDescriptorType = USB_DT_ENDPOINT,
109 .bEndpointAddress = USB_DIR_IN,
110 .bmAttributes = USB_ENDPOINT_XFER_INT,
57976636 111 .wMaxPacketSize = cpu_to_le16(STATUS_BYTECOUNT),
cdda479f
LP		 112 .bInterval = 8,
113};
114
115static 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,
57976636 119 .wMaxTransferSize = cpu_to_le16(STATUS_BYTECOUNT),
cdda479f
LP		 120};
121
122static 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,
127 .bNumEndpoints = 0,
128 .bInterfaceClass = USB_CLASS_VIDEO,
bbafc0cb 129 .bInterfaceSubClass = UVC_SC_VIDEOSTREAMING,
cdda479f
LP		 130 .bInterfaceProtocol = 0x00,
131 .iInterface = 0,
132};
133
134static 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,
139 .bNumEndpoints = 1,
140 .bInterfaceClass = USB_CLASS_VIDEO,
bbafc0cb 141 .bInterfaceSubClass = UVC_SC_VIDEOSTREAMING,
cdda479f
LP		 142 .bInterfaceProtocol = 0x00,
143 .iInterface = 0,
144};
145
fbcaba0e 146static struct usb_endpoint_descriptor uvc_fs_streaming_ep = {
cdda479f
LP		 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),
152 .bInterval = 1,
153};
154
fbcaba0e
BS		 155static 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),
161 .bInterval = 1,
162};
163
164/* super speed support */
165static struct usb_endpoint_descriptor uvc_ss_control_ep __initdata = {
166 .bLength = USB_DT_ENDPOINT_SIZE,
167 .bDescriptorType = USB_DT_ENDPOINT,
168
169 .bEndpointAddress = USB_DIR_IN,
170 .bmAttributes = USB_ENDPOINT_XFER_INT,
171 .wMaxPacketSize = cpu_to_le16(STATUS_BYTECOUNT),
172 .bInterval = 8,
173};
174
175static 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,
178
179 /* the following 3 values can be tweaked if necessary */
180 /* .bMaxBurst = 0, */
181 /* .bmAttributes = 0, */
182 .wBytesPerInterval = cpu_to_le16(STATUS_BYTECOUNT),
183};
184
185static struct usb_endpoint_descriptor uvc_ss_streaming_ep __initdata = {
186 .bLength = USB_DT_ENDPOINT_SIZE,
187 .bDescriptorType = USB_DT_ENDPOINT,
188
189 .bEndpointAddress = USB_DIR_IN,
190 .bmAttributes = USB_ENDPOINT_XFER_ISOC,
191 .wMaxPacketSize = cpu_to_le16(1024),
192 .bInterval = 4,
193};
194
195static struct usb_ss_ep_comp_descriptor uvc_ss_streaming_comp = {
196 .bLength = sizeof uvc_ss_streaming_comp,
197 .bDescriptorType = USB_DT_SS_ENDPOINT_COMP,
198
199 /* the following 3 values can be tweaked if necessary */
200 .bMaxBurst = 0,
201 .bmAttributes = 0,
202 .wBytesPerInterval = cpu_to_le16(1024),
203};
204
cdda479f
LP		 205static const struct usb_descriptor_header * const uvc_fs_streaming[] = {
206 (struct usb_descriptor_header *) &uvc_streaming_intf_alt1,
fbcaba0e 207 (struct usb_descriptor_header *) &uvc_fs_streaming_ep,
cdda479f
LP		 208 NULL,
209};
210
211static const struct usb_descriptor_header * const uvc_hs_streaming[] = {
212 (struct usb_descriptor_header *) &uvc_streaming_intf_alt1,
fbcaba0e
BS		 213 (struct usb_descriptor_header *) &uvc_hs_streaming_ep,
214 NULL,
215};
216
217static 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,
cdda479f
LP		 221 NULL,
222};
223
224/* --------------------------------------------------------------------------
225 * Control requests
226 */
227
228static void
229uvc_function_ep0_complete(struct usb_ep *ep, struct usb_request *req)
230{
231 struct uvc_device *uvc = req->context;
232 struct v4l2_event v4l2_event;
233 struct uvc_event *uvc_event = (void *)&v4l2_event.u.data;
234
235 if (uvc->event_setup_out) {
236 uvc->event_setup_out = 0;
237
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);
243 }
244}
245
246static int
247uvc_function_setup(struct usb_function *f, const struct usb_ctrlrequest *ctrl)
248{
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;
252
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));
256 */
257
258 if ((ctrl->bRequestType & USB_TYPE_MASK) != USB_TYPE_CLASS) {
259 INFO(f->config->cdev, "invalid request type\n");
260 return -EINVAL;
261 }
262
263 /* Stall too big requests. */
264 if (le16_to_cpu(ctrl->wLength) > UVC_MAX_REQUEST_SIZE)
265 return -EINVAL;
266
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);
271
272 return 0;
273}
274
275static int
276uvc_function_get_alt(struct usb_function *f, unsigned interface)
277{
278 struct uvc_device *uvc = to_uvc(f);
279
280 INFO(f->config->cdev, "uvc_function_get_alt(%u)\n", interface);
281
282 if (interface == uvc->control_intf)
283 return 0;
284 else if (interface != uvc->streaming_intf)
285 return -EINVAL;
286 else
287 return uvc->state == UVC_STATE_STREAMING ? 1 : 0;
288}
289
290static int
291uvc_function_set_alt(struct usb_function *f, unsigned interface, unsigned alt)
292{
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;
fbcaba0e 296 int ret;
cdda479f
LP		 297
298 INFO(f->config->cdev, "uvc_function_set_alt(%u, %u)\n", interface, alt);
299
300 if (interface == uvc->control_intf) {
301 if (alt)
302 return -EINVAL;
303
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);
309
310 uvc->state = UVC_STATE_CONNECTED;
311 }
312
313 return 0;
314 }
315
316 if (interface != uvc->streaming_intf)
317 return -EINVAL;
318
319 /* TODO
320 if (usb_endpoint_xfer_bulk(&uvc->desc.vs_ep))
321 return alt ? -EINVAL : 0;
322 */
323
324 switch (alt) {
325 case 0:
326 if (uvc->state != UVC_STATE_STREAMING)
327 return 0;
328
329 if (uvc->video.ep)
330 usb_ep_disable(uvc->video.ep);
331
332 memset(&v4l2_event, 0, sizeof(v4l2_event));
333 v4l2_event.type = UVC_EVENT_STREAMOFF;
334 v4l2_event_queue(uvc->vdev, &v4l2_event);
335
336 uvc->state = UVC_STATE_CONNECTED;
337 break;
338
339 case 1:
340 if (uvc->state != UVC_STATE_CONNECTED)
341 return 0;
342
72c973dd 343 if (uvc->video.ep) {
fbcaba0e
BS		 344 ret = config_ep_by_speed(f->config->cdev->gadget,
345 &(uvc->func), uvc->video.ep);
346 if (ret)
347 return ret;
72c973dd
TB		 348 usb_ep_enable(uvc->video.ep);
349 }
cdda479f
LP		 350
351 memset(&v4l2_event, 0, sizeof(v4l2_event));
352 v4l2_event.type = UVC_EVENT_STREAMON;
353 v4l2_event_queue(uvc->vdev, &v4l2_event);
354
355 uvc->state = UVC_STATE_STREAMING;
356 break;
357
358 default:
359 return -EINVAL;
360 }
361
362 return 0;
363}
364
365static void
366uvc_function_disable(struct usb_function *f)
367{
368 struct uvc_device *uvc = to_uvc(f);
369 struct v4l2_event v4l2_event;
370
371 INFO(f->config->cdev, "uvc_function_disable\n");
372
373 memset(&v4l2_event, 0, sizeof(v4l2_event));
374 v4l2_event.type = UVC_EVENT_DISCONNECT;
375 v4l2_event_queue(uvc->vdev, &v4l2_event);
376
377 uvc->state = UVC_STATE_DISCONNECTED;
378}
379
380/* --------------------------------------------------------------------------
381 * Connection / disconnection
382 */
383
384void
385uvc_function_connect(struct uvc_device *uvc)
386{
387 struct usb_composite_dev *cdev = uvc->func.config->cdev;
388 int ret;
389
390 if ((ret = usb_function_activate(&uvc->func)) < 0)
391 INFO(cdev, "UVC connect failed with %d\n", ret);
392}
393
394void
395uvc_function_disconnect(struct uvc_device *uvc)
396{
397 struct usb_composite_dev *cdev = uvc->func.config->cdev;
398 int ret;
399
400 if ((ret = usb_function_deactivate(&uvc->func)) < 0)
401 INFO(cdev, "UVC disconnect failed with %d\n", ret);
402}
403
404/* --------------------------------------------------------------------------
405 * USB probe and disconnect
406 */
407
408static int
409uvc_register_video(struct uvc_device *uvc)
410{
411 struct usb_composite_dev *cdev = uvc->func.config->cdev;
412 struct video_device *video;
413
414 /* TODO reference counting. */
415 video = video_device_alloc();
416 if (video == NULL)
417 return -ENOMEM;
418
419 video->parent = &cdev->gadget->dev;
cdda479f
LP		 420 video->fops = &uvc_v4l2_fops;
421 video->release = video_device_release;
422 strncpy(video->name, cdev->gadget->name, sizeof(video->name));
423
424 uvc->vdev = video;
425 video_set_drvdata(video, uvc);
426
427 return video_register_device(video, VFL_TYPE_GRABBER, -1);
428}
429
430#define UVC_COPY_DESCRIPTOR(mem, dst, desc) \
431 do { \
432 memcpy(mem, desc, (desc)->bLength); \
433 *(dst)++ = mem; \
434 mem += (desc)->bLength; \
435 } while (0);
436
437#define UVC_COPY_DESCRIPTORS(mem, dst, src) \
438 do { \
439 const struct usb_descriptor_header * const *__src; \
440 for (__src = src; *__src; ++__src) { \
441 memcpy(mem, *__src, (*__src)->bLength); \
442 *dst++ = mem; \
443 mem += (*__src)->bLength; \
444 } \
445 } while (0)
446
447static struct usb_descriptor_header ** __init
448uvc_copy_descriptors(struct uvc_device *uvc, enum usb_device_speed speed)
449{
450 struct uvc_input_header_descriptor *uvc_streaming_header;
451 struct uvc_header_descriptor *uvc_control_header;
fbcaba0e 452 const struct uvc_descriptor_header * const *uvc_control_desc;
cdda479f
LP		 453 const struct uvc_descriptor_header * const *uvc_streaming_cls;
454 const struct usb_descriptor_header * const *uvc_streaming_std;
455 const struct usb_descriptor_header * const *src;
fbcaba0e 456 static struct usb_endpoint_descriptor *uvc_control_ep;
cdda479f
LP		 457 struct usb_descriptor_header **dst;
458 struct usb_descriptor_header **hdr;
459 unsigned int control_size;
460 unsigned int streaming_size;
461 unsigned int n_desc;
462 unsigned int bytes;
463 void *mem;
464
fbcaba0e
BS		 465 switch (speed) {
466 case USB_SPEED_SUPER:
467 uvc_control_desc = uvc->desc.ss_control;
468 uvc_streaming_cls = uvc->desc.ss_streaming;
469 uvc_streaming_std = uvc_ss_streaming;
470 uvc_control_ep = &uvc_ss_control_ep;
471 break;
472
473 case USB_SPEED_HIGH:
474 uvc_control_desc = uvc->desc.fs_control;
475 uvc_streaming_cls = uvc->desc.hs_streaming;
476 uvc_streaming_std = uvc_hs_streaming;
477 uvc_control_ep = &uvc_fs_control_ep;
478 break;
479
480 case USB_SPEED_FULL:
481 default:
482 uvc_control_desc = uvc->desc.fs_control;
483 uvc_streaming_cls = uvc->desc.fs_streaming;
484 uvc_streaming_std = uvc_fs_streaming;
485 uvc_control_ep = &uvc_fs_control_ep;
486 break;
487 }
cdda479f
LP		 488
489 /* Descriptors layout
490 *
491 * uvc_iad
492 * uvc_control_intf
493 * Class-specific UVC control descriptors
494 * uvc_control_ep
495 * uvc_control_cs_ep
496 * uvc_streaming_intf_alt0
497 * Class-specific UVC streaming descriptors
498 * uvc_{fs|hs}_streaming
499 */
500
501 /* Count descriptors and compute their size. */
502 control_size = 0;
503 streaming_size = 0;
504 bytes = uvc_iad.bLength + uvc_control_intf.bLength
fbcaba0e 505 + uvc_control_ep->bLength + uvc_control_cs_ep.bLength
cdda479f 506 + uvc_streaming_intf_alt0.bLength;
cdda479f 507
fbcaba0e
BS		 508 if (speed == USB_SPEED_SUPER) {
509 bytes += uvc_ss_control_comp.bLength;
510 n_desc = 6;
511 } else {
512 n_desc = 5;
513 }
514
515 for (src = (const struct usb_descriptor_header **)uvc_control_desc;
516 *src; ++src) {
cdda479f
LP		 517 control_size += (*src)->bLength;
518 bytes += (*src)->bLength;
519 n_desc++;
520 }
fbcaba0e
BS		 521 for (src = (const struct usb_descriptor_header **)uvc_streaming_cls;
522 *src; ++src) {
cdda479f
LP		 523 streaming_size += (*src)->bLength;
524 bytes += (*src)->bLength;
525 n_desc++;
526 }
527 for (src = uvc_streaming_std; *src; ++src) {
528 bytes += (*src)->bLength;
529 n_desc++;
530 }
531
532 mem = kmalloc((n_desc + 1) * sizeof(*src) + bytes, GFP_KERNEL);
533 if (mem == NULL)
534 return NULL;
535
536 hdr = mem;
537 dst = mem;
538 mem += (n_desc + 1) * sizeof(*src);
539
540 /* Copy the descriptors. */
541 UVC_COPY_DESCRIPTOR(mem, dst, &uvc_iad);
542 UVC_COPY_DESCRIPTOR(mem, dst, &uvc_control_intf);
543
544 uvc_control_header = mem;
545 UVC_COPY_DESCRIPTORS(mem, dst,
fbcaba0e 546 (const struct usb_descriptor_header **)uvc_control_desc);
cdda479f
LP		 547 uvc_control_header->wTotalLength = cpu_to_le16(control_size);
548 uvc_control_header->bInCollection = 1;
549 uvc_control_header->baInterfaceNr[0] = uvc->streaming_intf;
550
fbcaba0e
BS		 551 UVC_COPY_DESCRIPTOR(mem, dst, uvc_control_ep);
552 if (speed == USB_SPEED_SUPER)
553 UVC_COPY_DESCRIPTOR(mem, dst, &uvc_ss_control_comp);
554
cdda479f
LP		 555 UVC_COPY_DESCRIPTOR(mem, dst, &uvc_control_cs_ep);
556 UVC_COPY_DESCRIPTOR(mem, dst, &uvc_streaming_intf_alt0);
557
558 uvc_streaming_header = mem;
559 UVC_COPY_DESCRIPTORS(mem, dst,
560 (const struct usb_descriptor_header**)uvc_streaming_cls);
561 uvc_streaming_header->wTotalLength = cpu_to_le16(streaming_size);
fbcaba0e
BS		 562 uvc_streaming_header->bEndpointAddress =
563 uvc_fs_streaming_ep.bEndpointAddress;
cdda479f
LP		 564
565 UVC_COPY_DESCRIPTORS(mem, dst, uvc_streaming_std);
566
567 *dst = NULL;
568 return hdr;
569}
570
571static void
572uvc_function_unbind(struct usb_configuration *c, struct usb_function *f)
573{
574 struct usb_composite_dev *cdev = c->cdev;
575 struct uvc_device *uvc = to_uvc(f);
576
577 INFO(cdev, "uvc_function_unbind\n");
578
0f9df939
SAS		 579 video_unregister_device(uvc->vdev);
580 uvc->control_ep->driver_data = NULL;
581 uvc->video.ep->driver_data = NULL;
cdda479f 582
1616e99d 583 uvc_en_us_strings[UVC_STRING_ASSOCIATION_IDX].id = 0;
0f9df939
SAS		 584 usb_ep_free_request(cdev->gadget->ep0, uvc->control_req);
585 kfree(uvc->control_buf);
cdda479f 586
10287bae 587 usb_free_all_descriptors(f);
cdda479f
LP		 588
589 kfree(uvc);
590}
591
592static int __init
593uvc_function_bind(struct usb_configuration *c, struct usb_function *f)
594{
595 struct usb_composite_dev *cdev = c->cdev;
596 struct uvc_device *uvc = to_uvc(f);
597 struct usb_ep *ep;
598 int ret = -EINVAL;
599
600 INFO(cdev, "uvc_function_bind\n");
601
fbcaba0e
BS		 602 /* sanity check the streaming endpoint module parameters */
603 if (streaming_interval < 1)
604 streaming_interval = 1;
605 if (streaming_interval > 16)
606 streaming_interval = 16;
607 if (streaming_mult > 2)
608 streaming_mult = 2;
609 if (streaming_maxburst > 15)
610 streaming_maxburst = 15;
611
612 /*
613 * fill in the FS video streaming specific descriptors from the
614 * module parameters
615 */
616 uvc_fs_streaming_ep.wMaxPacketSize = streaming_maxpacket > 1023 ?
617 1023 : streaming_maxpacket;
618 uvc_fs_streaming_ep.bInterval = streaming_interval;
619
cdda479f 620 /* Allocate endpoints. */
fbcaba0e 621 ep = usb_ep_autoconfig(cdev->gadget, &uvc_fs_control_ep);
cdda479f
LP		 622 if (!ep) {
623 INFO(cdev, "Unable to allocate control EP\n");
624 goto error;
625 }
626 uvc->control_ep = ep;
627 ep->driver_data = uvc;
628
fbcaba0e 629 ep = usb_ep_autoconfig(cdev->gadget, &uvc_fs_streaming_ep);
cdda479f
LP		 630 if (!ep) {
631 INFO(cdev, "Unable to allocate streaming EP\n");
632 goto error;
633 }
634 uvc->video.ep = ep;
635 ep->driver_data = uvc;
636
637 /* Allocate interface IDs. */
638 if ((ret = usb_interface_id(c, f)) < 0)
639 goto error;
640 uvc_iad.bFirstInterface = ret;
641 uvc_control_intf.bInterfaceNumber = ret;
642 uvc->control_intf = ret;
643
644 if ((ret = usb_interface_id(c, f)) < 0)
645 goto error;
646 uvc_streaming_intf_alt0.bInterfaceNumber = ret;
647 uvc_streaming_intf_alt1.bInterfaceNumber = ret;
648 uvc->streaming_intf = ret;
649
fbcaba0e
BS		 650 /* sanity check the streaming endpoint module parameters */
651 if (streaming_maxpacket > 1024)
652 streaming_maxpacket = 1024;
10287bae
SAS		 653 /*
654 * Fill in the HS descriptors from the module parameters for the Video
655 * Streaming endpoint.
656 * NOTE: We assume that the user knows what they are doing and won't
657 * give parameters that their UDC doesn't support.
658 */
659 uvc_hs_streaming_ep.wMaxPacketSize = streaming_maxpacket;
660 uvc_hs_streaming_ep.wMaxPacketSize |= streaming_mult << 11;
661 uvc_hs_streaming_ep.bInterval = streaming_interval;
662 uvc_hs_streaming_ep.bEndpointAddress =
663 uvc_fs_streaming_ep.bEndpointAddress;
fbcaba0e 664
10287bae
SAS		 665 /*
666 * Fill in the SS descriptors from the module parameters for the Video
667 * Streaming endpoint.
668 * NOTE: We assume that the user knows what they are doing and won't
669 * give parameters that their UDC doesn't support.
670 */
671 uvc_ss_streaming_ep.wMaxPacketSize = streaming_maxpacket;
672 uvc_ss_streaming_ep.bInterval = streaming_interval;
673 uvc_ss_streaming_comp.bmAttributes = streaming_mult;
674 uvc_ss_streaming_comp.bMaxBurst = streaming_maxburst;
675 uvc_ss_streaming_comp.wBytesPerInterval =
676 streaming_maxpacket * (streaming_mult + 1) *
677 (streaming_maxburst + 1);
678 uvc_ss_streaming_ep.bEndpointAddress =
679 uvc_fs_streaming_ep.bEndpointAddress;
fbcaba0e 680
10287bae
SAS		 681 /* Copy descriptors */
682 f->fs_descriptors = uvc_copy_descriptors(uvc, USB_SPEED_FULL);
683 if (gadget_is_dualspeed(cdev->gadget))
684 f->hs_descriptors = uvc_copy_descriptors(uvc, USB_SPEED_HIGH);
685 if (gadget_is_superspeed(c->cdev->gadget))
fbcaba0e 686 f->ss_descriptors = uvc_copy_descriptors(uvc, USB_SPEED_SUPER);
cdda479f
LP		 687
688 /* Preallocate control endpoint request. */
689 uvc->control_req = usb_ep_alloc_request(cdev->gadget->ep0, GFP_KERNEL);
690 uvc->control_buf = kmalloc(UVC_MAX_REQUEST_SIZE, GFP_KERNEL);
691 if (uvc->control_req == NULL || uvc->control_buf == NULL) {
692 ret = -ENOMEM;
693 goto error;
694 }
695
696 uvc->control_req->buf = uvc->control_buf;
697 uvc->control_req->complete = uvc_function_ep0_complete;
698 uvc->control_req->context = uvc;
699
700 /* Avoid letting this gadget enumerate until the userspace server is
701 * active.
702 */
703 if ((ret = usb_function_deactivate(f)) < 0)
704 goto error;
705
706 /* Initialise video. */
707 ret = uvc_video_init(&uvc->video);
708 if (ret < 0)
709 goto error;
710
711 /* Register a V4L2 device. */
712 ret = uvc_register_video(uvc);
713 if (ret < 0) {
714 printk(KERN_INFO "Unable to register video device\n");
715 goto error;
716 }
717
718 return 0;
719
720error:
0f9df939
SAS		 721 if (uvc->vdev)
722 video_device_release(uvc->vdev);
723
724 if (uvc->control_ep)
725 uvc->control_ep->driver_data = NULL;
726 if (uvc->video.ep)
727 uvc->video.ep->driver_data = NULL;
728
729 if (uvc->control_req) {
730 usb_ep_free_request(cdev->gadget->ep0, uvc->control_req);
731 kfree(uvc->control_buf);
732 }
733
10287bae 734 usb_free_all_descriptors(f);
cdda479f
LP		 735 return ret;
736}
737
738/* --------------------------------------------------------------------------
739 * USB gadget function
740 */
741
742/**
743 * uvc_bind_config - add a UVC function to a configuration
744 * @c: the configuration to support the UVC instance
745 * Context: single threaded during gadget setup
746 *
747 * Returns zero on success, else negative errno.
748 *
749 * Caller must have called @uvc_setup(). Caller is also responsible for
750 * calling @uvc_cleanup() before module unload.
751 */
752int __init
753uvc_bind_config(struct usb_configuration *c,
fbcaba0e
BS		 754 const struct uvc_descriptor_header * const *fs_control,
755 const struct uvc_descriptor_header * const *ss_control,
cdda479f 756 const struct uvc_descriptor_header * const *fs_streaming,
fbcaba0e
BS		 757 const struct uvc_descriptor_header * const *hs_streaming,
758 const struct uvc_descriptor_header * const *ss_streaming)
cdda479f
LP		 759{
760 struct uvc_device *uvc;
761 int ret = 0;
762
763 /* TODO Check if the USB device controller supports the required
764 * features.
765 */
766 if (!gadget_is_dualspeed(c->cdev->gadget))
767 return -EINVAL;
768
769 uvc = kzalloc(sizeof(*uvc), GFP_KERNEL);
770 if (uvc == NULL)
771 return -ENOMEM;
772
773 uvc->state = UVC_STATE_DISCONNECTED;
774
775 /* Validate the descriptors. */
fbcaba0e
BS		 776 if (fs_control == NULL || fs_control[0] == NULL ||
777 fs_control[0]->bDescriptorSubType != UVC_VC_HEADER)
778 goto error;
779
780 if (ss_control == NULL || ss_control[0] == NULL ||
781 ss_control[0]->bDescriptorSubType != UVC_VC_HEADER)
cdda479f
LP		 782 goto error;
783
784 if (fs_streaming == NULL || fs_streaming[0] == NULL ||
fbcaba0e 785 fs_streaming[0]->bDescriptorSubType != UVC_VS_INPUT_HEADER)
cdda479f
LP		 786 goto error;
787
788 if (hs_streaming == NULL || hs_streaming[0] == NULL ||
fbcaba0e
BS		 789 hs_streaming[0]->bDescriptorSubType != UVC_VS_INPUT_HEADER)
790 goto error;
791
792 if (ss_streaming == NULL || ss_streaming[0] == NULL ||
793 ss_streaming[0]->bDescriptorSubType != UVC_VS_INPUT_HEADER)
cdda479f
LP		 794 goto error;
795
fbcaba0e
BS		 796 uvc->desc.fs_control = fs_control;
797 uvc->desc.ss_control = ss_control;
cdda479f
LP		 798 uvc->desc.fs_streaming = fs_streaming;
799 uvc->desc.hs_streaming = hs_streaming;
fbcaba0e 800 uvc->desc.ss_streaming = ss_streaming;
cdda479f 801
1616e99d 802 /* Allocate string descriptor numbers. */
3de6e63f 803 if (uvc_en_us_strings[UVC_STRING_ASSOCIATION_IDX].id == 0) {
1616e99d
SAS		 804 ret = usb_string_ids_tab(c->cdev, uvc_en_us_strings);
805 if (ret)
3de6e63f 806 goto error;
1616e99d
SAS		 807 uvc_iad.iFunction =
808 uvc_en_us_strings[UVC_STRING_ASSOCIATION_IDX].id;
809 uvc_control_intf.iInterface =
810 uvc_en_us_strings[UVC_STRING_CONTROL_IDX].id;
811 ret = uvc_en_us_strings[UVC_STRING_STREAMING_IDX].id;
3de6e63f
BS		 812 uvc_streaming_intf_alt0.iInterface = ret;
813 uvc_streaming_intf_alt1.iInterface = ret;
814 }
cdda479f
LP		 815
816 /* Register the function. */
817 uvc->func.name = "uvc";
818 uvc->func.strings = uvc_function_strings;
819 uvc->func.bind = uvc_function_bind;
820 uvc->func.unbind = uvc_function_unbind;
821 uvc->func.get_alt = uvc_function_get_alt;
822 uvc->func.set_alt = uvc_function_set_alt;
823 uvc->func.disable = uvc_function_disable;
824 uvc->func.setup = uvc_function_setup;
825
826 ret = usb_add_function(c, &uvc->func);
827 if (ret)
828 kfree(uvc);
829
28f75f4d 830 return ret;
cdda479f
LP		 831
832error:
833 kfree(uvc);
834 return ret;
835}
836
5d9955f8 837module_param_named(trace, uvc_gadget_trace_param, uint, S_IRUGO|S_IWUSR);
cdda479f
LP		 838MODULE_PARM_DESC(trace, "Trace level bitmask");
839
Linux kernel - Deliverables
This page took 0.312 seconds and 5 git commands to generate.