1
2
3
4
5
6
7
8
9
10
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
31unsigned int uvc_gadget_trace_param;
32
33
34
35
36
37
38
39#define UVC_STRING_ASSOCIATION_IDX 0
40#define UVC_STRING_CONTROL_IDX 1
41#define UVC_STRING_STREAMING_IDX 2
42
43static 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
50static struct usb_gadget_strings uvc_stringtab = {
51 .language = 0x0409,
52 .strings = uvc_en_us_strings,
53};
54
55static 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
63static 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
74static 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
86static 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
95static 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
102static 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
114static 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
126static 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
135static 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
141static 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
149
150
151static void
152uvc_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
169static int
170uvc_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
177
178
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
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
198static int
199uvc_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
213static int
214uvc_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
242
243
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 usb_ep_enable(uvc->video.ep, &uvc_streaming_ep);
267
268 memset(&v4l2_event, 0, sizeof(v4l2_event));
269 v4l2_event.type = UVC_EVENT_STREAMON;
270 v4l2_event_queue(uvc->vdev, &v4l2_event);
271
272 uvc->state = UVC_STATE_STREAMING;
273 break;
274
275 default:
276 return -EINVAL;
277 }
278
279 return 0;
280}
281
282static void
283uvc_function_disable(struct usb_function *f)
284{
285 struct uvc_device *uvc = to_uvc(f);
286 struct v4l2_event v4l2_event;
287
288 INFO(f->config->cdev, "uvc_function_disable\n");
289
290 memset(&v4l2_event, 0, sizeof(v4l2_event));
291 v4l2_event.type = UVC_EVENT_DISCONNECT;
292 v4l2_event_queue(uvc->vdev, &v4l2_event);
293
294 uvc->state = UVC_STATE_DISCONNECTED;
295}
296
297
298
299
300
301void
302uvc_function_connect(struct uvc_device *uvc)
303{
304 struct usb_composite_dev *cdev = uvc->func.config->cdev;
305 int ret;
306
307 if ((ret = usb_function_activate(&uvc->func)) < 0)
308 INFO(cdev, "UVC connect failed with %d\n", ret);
309}
310
311void
312uvc_function_disconnect(struct uvc_device *uvc)
313{
314 struct usb_composite_dev *cdev = uvc->func.config->cdev;
315 int ret;
316
317 if ((ret = usb_function_deactivate(&uvc->func)) < 0)
318 INFO(cdev, "UVC disconnect failed with %d\n", ret);
319}
320
321
322
323
324
325static int
326uvc_register_video(struct uvc_device *uvc)
327{
328 struct usb_composite_dev *cdev = uvc->func.config->cdev;
329 struct video_device *video;
330
331
332 video = video_device_alloc();
333 if (video == NULL)
334 return -ENOMEM;
335
336 video->parent = &cdev->gadget->dev;
337 video->minor = -1;
338 video->fops = &uvc_v4l2_fops;
339 video->release = video_device_release;
340 strncpy(video->name, cdev->gadget->name, sizeof(video->name));
341
342 uvc->vdev = video;
343 video_set_drvdata(video, uvc);
344
345 return video_register_device(video, VFL_TYPE_GRABBER, -1);
346}
347
348#define UVC_COPY_DESCRIPTOR(mem, dst, desc) \
349 do { \
350 memcpy(mem, desc, (desc)->bLength); \
351 *(dst)++ = mem; \
352 mem += (desc)->bLength; \
353 } while (0);
354
355#define UVC_COPY_DESCRIPTORS(mem, dst, src) \
356 do { \
357 const struct usb_descriptor_header * const *__src; \
358 for (__src = src; *__src; ++__src) { \
359 memcpy(mem, *__src, (*__src)->bLength); \
360 *dst++ = mem; \
361 mem += (*__src)->bLength; \
362 } \
363 } while (0)
364
365static struct usb_descriptor_header ** __init
366uvc_copy_descriptors(struct uvc_device *uvc, enum usb_device_speed speed)
367{
368 struct uvc_input_header_descriptor *uvc_streaming_header;
369 struct uvc_header_descriptor *uvc_control_header;
370 const struct uvc_descriptor_header * const *uvc_streaming_cls;
371 const struct usb_descriptor_header * const *uvc_streaming_std;
372 const struct usb_descriptor_header * const *src;
373 struct usb_descriptor_header **dst;
374 struct usb_descriptor_header **hdr;
375 unsigned int control_size;
376 unsigned int streaming_size;
377 unsigned int n_desc;
378 unsigned int bytes;
379 void *mem;
380
381 uvc_streaming_cls = (speed == USB_SPEED_FULL)
382 ? uvc->desc.fs_streaming : uvc->desc.hs_streaming;
383 uvc_streaming_std = (speed == USB_SPEED_FULL)
384 ? uvc_fs_streaming : uvc_hs_streaming;
385
386
387
388
389
390
391
392
393
394
395
396
397
398
399 control_size = 0;
400 streaming_size = 0;
401 bytes = uvc_iad.bLength + uvc_control_intf.bLength
402 + uvc_control_ep.bLength + uvc_control_cs_ep.bLength
403 + uvc_streaming_intf_alt0.bLength;
404 n_desc = 5;
405
406 for (src = (const struct usb_descriptor_header**)uvc->desc.control; *src; ++src) {
407 control_size += (*src)->bLength;
408 bytes += (*src)->bLength;
409 n_desc++;
410 }
411 for (src = (const struct usb_descriptor_header**)uvc_streaming_cls; *src; ++src) {
412 streaming_size += (*src)->bLength;
413 bytes += (*src)->bLength;
414 n_desc++;
415 }
416 for (src = uvc_streaming_std; *src; ++src) {
417 bytes += (*src)->bLength;
418 n_desc++;
419 }
420
421 mem = kmalloc((n_desc + 1) * sizeof(*src) + bytes, GFP_KERNEL);
422 if (mem == NULL)
423 return NULL;
424
425 hdr = mem;
426 dst = mem;
427 mem += (n_desc + 1) * sizeof(*src);
428
429
430 UVC_COPY_DESCRIPTOR(mem, dst, &uvc_iad);
431 UVC_COPY_DESCRIPTOR(mem, dst, &uvc_control_intf);
432
433 uvc_control_header = mem;
434 UVC_COPY_DESCRIPTORS(mem, dst,
435 (const struct usb_descriptor_header**)uvc->desc.control);
436 uvc_control_header->wTotalLength = cpu_to_le16(control_size);
437 uvc_control_header->bInCollection = 1;
438 uvc_control_header->baInterfaceNr[0] = uvc->streaming_intf;
439
440 UVC_COPY_DESCRIPTOR(mem, dst, &uvc_control_ep);
441 UVC_COPY_DESCRIPTOR(mem, dst, &uvc_control_cs_ep);
442 UVC_COPY_DESCRIPTOR(mem, dst, &uvc_streaming_intf_alt0);
443
444 uvc_streaming_header = mem;
445 UVC_COPY_DESCRIPTORS(mem, dst,
446 (const struct usb_descriptor_header**)uvc_streaming_cls);
447 uvc_streaming_header->wTotalLength = cpu_to_le16(streaming_size);
448 uvc_streaming_header->bEndpointAddress = uvc_streaming_ep.bEndpointAddress;
449
450 UVC_COPY_DESCRIPTORS(mem, dst, uvc_streaming_std);
451
452 *dst = NULL;
453 return hdr;
454}
455
456static void
457uvc_function_unbind(struct usb_configuration *c, struct usb_function *f)
458{
459 struct usb_composite_dev *cdev = c->cdev;
460 struct uvc_device *uvc = to_uvc(f);
461
462 INFO(cdev, "uvc_function_unbind\n");
463
464 if (uvc->vdev) {
465 if (uvc->vdev->minor == -1)
466 video_device_release(uvc->vdev);
467 else
468 video_unregister_device(uvc->vdev);
469 uvc->vdev = NULL;
470 }
471
472 if (uvc->control_ep)
473 uvc->control_ep->driver_data = NULL;
474 if (uvc->video.ep)
475 uvc->video.ep->driver_data = NULL;
476
477 if (uvc->control_req) {
478 usb_ep_free_request(cdev->gadget->ep0, uvc->control_req);
479 kfree(uvc->control_buf);
480 }
481
482 kfree(f->descriptors);
483 kfree(f->hs_descriptors);
484
485 kfree(uvc);
486}
487
488static int __init
489uvc_function_bind(struct usb_configuration *c, struct usb_function *f)
490{
491 struct usb_composite_dev *cdev = c->cdev;
492 struct uvc_device *uvc = to_uvc(f);
493 struct usb_ep *ep;
494 int ret = -EINVAL;
495
496 INFO(cdev, "uvc_function_bind\n");
497
498
499 ep = usb_ep_autoconfig(cdev->gadget, &uvc_control_ep);
500 if (!ep) {
501 INFO(cdev, "Unable to allocate control EP\n");
502 goto error;
503 }
504 uvc->control_ep = ep;
505 ep->driver_data = uvc;
506
507 ep = usb_ep_autoconfig(cdev->gadget, &uvc_streaming_ep);
508 if (!ep) {
509 INFO(cdev, "Unable to allocate streaming EP\n");
510 goto error;
511 }
512 uvc->video.ep = ep;
513 ep->driver_data = uvc;
514
515
516 if ((ret = usb_interface_id(c, f)) < 0)
517 goto error;
518 uvc_iad.bFirstInterface = ret;
519 uvc_control_intf.bInterfaceNumber = ret;
520 uvc->control_intf = ret;
521
522 if ((ret = usb_interface_id(c, f)) < 0)
523 goto error;
524 uvc_streaming_intf_alt0.bInterfaceNumber = ret;
525 uvc_streaming_intf_alt1.bInterfaceNumber = ret;
526 uvc->streaming_intf = ret;
527
528
529 f->descriptors = uvc_copy_descriptors(uvc, USB_SPEED_FULL);
530 f->hs_descriptors = uvc_copy_descriptors(uvc, USB_SPEED_HIGH);
531
532
533 uvc->control_req = usb_ep_alloc_request(cdev->gadget->ep0, GFP_KERNEL);
534 uvc->control_buf = kmalloc(UVC_MAX_REQUEST_SIZE, GFP_KERNEL);
535 if (uvc->control_req == NULL || uvc->control_buf == NULL) {
536 ret = -ENOMEM;
537 goto error;
538 }
539
540 uvc->control_req->buf = uvc->control_buf;
541 uvc->control_req->complete = uvc_function_ep0_complete;
542 uvc->control_req->context = uvc;
543
544
545
546
547 if ((ret = usb_function_deactivate(f)) < 0)
548 goto error;
549
550
551 ret = uvc_video_init(&uvc->video);
552 if (ret < 0)
553 goto error;
554
555
556 ret = uvc_register_video(uvc);
557 if (ret < 0) {
558 printk(KERN_INFO "Unable to register video device\n");
559 goto error;
560 }
561
562 return 0;
563
564error:
565 uvc_function_unbind(c, f);
566 return ret;
567}
568
569
570
571
572
573
574
575
576
577
578
579
580
581
582
583int __init
584uvc_bind_config(struct usb_configuration *c,
585 const struct uvc_descriptor_header * const *control,
586 const struct uvc_descriptor_header * const *fs_streaming,
587 const struct uvc_descriptor_header * const *hs_streaming)
588{
589 struct uvc_device *uvc;
590 int ret = 0;
591
592
593
594
595 if (!gadget_is_dualspeed(c->cdev->gadget))
596 return -EINVAL;
597
598 uvc = kzalloc(sizeof(*uvc), GFP_KERNEL);
599 if (uvc == NULL)
600 return -ENOMEM;
601
602 uvc->state = UVC_STATE_DISCONNECTED;
603
604
605 if (control == NULL || control[0] == NULL ||
606 control[0]->bDescriptorSubType != UVC_VC_HEADER)
607 goto error;
608
609 if (fs_streaming == NULL || fs_streaming[0] == NULL ||
610 fs_streaming[0]->bDescriptorSubType != UVC_VS_INPUT_HEADER)
611 goto error;
612
613 if (hs_streaming == NULL || hs_streaming[0] == NULL ||
614 hs_streaming[0]->bDescriptorSubType != UVC_VS_INPUT_HEADER)
615 goto error;
616
617 uvc->desc.control = control;
618 uvc->desc.fs_streaming = fs_streaming;
619 uvc->desc.hs_streaming = hs_streaming;
620
621
622 if ((ret = usb_string_id(c->cdev)) < 0)
623 goto error;
624 uvc_en_us_strings[UVC_STRING_ASSOCIATION_IDX].id = ret;
625 uvc_iad.iFunction = ret;
626
627 if ((ret = usb_string_id(c->cdev)) < 0)
628 goto error;
629 uvc_en_us_strings[UVC_STRING_CONTROL_IDX].id = ret;
630 uvc_control_intf.iInterface = ret;
631
632 if ((ret = usb_string_id(c->cdev)) < 0)
633 goto error;
634 uvc_en_us_strings[UVC_STRING_STREAMING_IDX].id = ret;
635 uvc_streaming_intf_alt0.iInterface = ret;
636 uvc_streaming_intf_alt1.iInterface = ret;
637
638
639 uvc->func.name = "uvc";
640 uvc->func.strings = uvc_function_strings;
641 uvc->func.bind = uvc_function_bind;
642 uvc->func.unbind = uvc_function_unbind;
643 uvc->func.get_alt = uvc_function_get_alt;
644 uvc->func.set_alt = uvc_function_set_alt;
645 uvc->func.disable = uvc_function_disable;
646 uvc->func.setup = uvc_function_setup;
647
648 ret = usb_add_function(c, &uvc->func);
649 if (ret)
650 kfree(uvc);
651
652 return 0;
653
654error:
655 kfree(uvc);
656 return ret;
657}
658
659module_param_named(trace, uvc_gadget_trace_param, uint, S_IRUGO|S_IWUSR);
660MODULE_PARM_DESC(trace, "Trace level bitmask");
661
662
