1 // SPDX-License-Identifier: GPL-2.0-or-later
2 /*
3 * uvc_driver.c -- USB Video Class driver
4 *
5 * Copyright (C) 2005-2010
6 * Laurent Pinchart (laurent.pinchart@ideasonboard.com)
7 */
8
9 #include <linux/atomic.h>
10 #include <linux/kernel.h>
11 #include <linux/list.h>
12 #include <linux/module.h>
13 #include <linux/slab.h>
14 #include <linux/usb.h>
15 #include <linux/usb/quirks.h>
16 #include <linux/videodev2.h>
17 #include <linux/vmalloc.h>
18 #include <linux/wait.h>
19 #include <linux/version.h>
20 #include <asm/unaligned.h>
21
22 #include <media/v4l2-common.h>
23 #include <media/v4l2-ioctl.h>
24
25 #include "uvcvideo.h"
26
27 #define DRIVER_AUTHOR "Laurent Pinchart " \
28 "<laurent.pinchart@ideasonboard.com>"
29 #define DRIVER_DESC "USB Video Class driver"
30
31 unsigned int uvc_clock_param = CLOCK_MONOTONIC;
32 unsigned int uvc_hw_timestamps_param;
33 unsigned int uvc_no_drop_param;
34 static unsigned int uvc_quirks_param = -1;
35 unsigned int uvc_trace_param;
36 unsigned int uvc_timeout_param = UVC_CTRL_STREAMING_TIMEOUT;
37
38 /* ------------------------------------------------------------------------
39 * Video formats
40 */
41
42 static struct uvc_format_desc uvc_fmts[] = {
43 {
44 .name = "YUV 4:2:2 (YUYV)",
45 .guid = UVC_GUID_FORMAT_YUY2,
46 .fcc = V4L2_PIX_FMT_YUYV,
47 },
48 {
49 .name = "YUV 4:2:2 (YUYV)",
50 .guid = UVC_GUID_FORMAT_YUY2_ISIGHT,
51 .fcc = V4L2_PIX_FMT_YUYV,
52 },
53 {
54 .name = "YUV 4:2:0 (NV12)",
55 .guid = UVC_GUID_FORMAT_NV12,
56 .fcc = V4L2_PIX_FMT_NV12,
57 },
58 {
59 .name = "MJPEG",
60 .guid = UVC_GUID_FORMAT_MJPEG,
61 .fcc = V4L2_PIX_FMT_MJPEG,
62 },
63 {
64 .name = "YVU 4:2:0 (YV12)",
65 .guid = UVC_GUID_FORMAT_YV12,
66 .fcc = V4L2_PIX_FMT_YVU420,
67 },
68 {
69 .name = "YUV 4:2:0 (I420)",
70 .guid = UVC_GUID_FORMAT_I420,
71 .fcc = V4L2_PIX_FMT_YUV420,
72 },
73 {
74 .name = "YUV 4:2:0 (M420)",
75 .guid = UVC_GUID_FORMAT_M420,
76 .fcc = V4L2_PIX_FMT_M420,
77 },
78 {
79 .name = "YUV 4:2:2 (UYVY)",
80 .guid = UVC_GUID_FORMAT_UYVY,
81 .fcc = V4L2_PIX_FMT_UYVY,
82 },
83 {
84 .name = "Greyscale 8-bit (Y800)",
85 .guid = UVC_GUID_FORMAT_Y800,
86 .fcc = V4L2_PIX_FMT_GREY,
87 },
88 {
89 .name = "Greyscale 8-bit (Y8 )",
90 .guid = UVC_GUID_FORMAT_Y8,
91 .fcc = V4L2_PIX_FMT_GREY,
92 },
93 {
94 .name = "Greyscale 8-bit (D3DFMT_L8)",
95 .guid = UVC_GUID_FORMAT_D3DFMT_L8,
96 .fcc = V4L2_PIX_FMT_GREY,
97 },
98 {
99 .name = "IR 8-bit (L8_IR)",
100 .guid = UVC_GUID_FORMAT_KSMEDIA_L8_IR,
101 .fcc = V4L2_PIX_FMT_GREY,
102 },
103 {
104 .name = "Greyscale 10-bit (Y10 )",
105 .guid = UVC_GUID_FORMAT_Y10,
106 .fcc = V4L2_PIX_FMT_Y10,
107 },
108 {
109 .name = "Greyscale 12-bit (Y12 )",
110 .guid = UVC_GUID_FORMAT_Y12,
111 .fcc = V4L2_PIX_FMT_Y12,
112 },
113 {
114 .name = "Greyscale 16-bit (Y16 )",
115 .guid = UVC_GUID_FORMAT_Y16,
116 .fcc = V4L2_PIX_FMT_Y16,
117 },
118 {
119 .name = "BGGR Bayer (BY8 )",
120 .guid = UVC_GUID_FORMAT_BY8,
121 .fcc = V4L2_PIX_FMT_SBGGR8,
122 },
123 {
124 .name = "BGGR Bayer (BA81)",
125 .guid = UVC_GUID_FORMAT_BA81,
126 .fcc = V4L2_PIX_FMT_SBGGR8,
127 },
128 {
129 .name = "GBRG Bayer (GBRG)",
130 .guid = UVC_GUID_FORMAT_GBRG,
131 .fcc = V4L2_PIX_FMT_SGBRG8,
132 },
133 {
134 .name = "GRBG Bayer (GRBG)",
135 .guid = UVC_GUID_FORMAT_GRBG,
136 .fcc = V4L2_PIX_FMT_SGRBG8,
137 },
138 {
139 .name = "RGGB Bayer (RGGB)",
140 .guid = UVC_GUID_FORMAT_RGGB,
141 .fcc = V4L2_PIX_FMT_SRGGB8,
142 },
143 {
144 .name = "RGB565",
145 .guid = UVC_GUID_FORMAT_RGBP,
146 .fcc = V4L2_PIX_FMT_RGB565,
147 },
148 {
149 .name = "BGR 8:8:8 (BGR3)",
150 .guid = UVC_GUID_FORMAT_BGR3,
151 .fcc = V4L2_PIX_FMT_BGR24,
152 },
153 {
154 .name = "H.264",
155 .guid = UVC_GUID_FORMAT_H264,
156 .fcc = V4L2_PIX_FMT_H264,
157 },
158 {
159 .name = "H.265",
160 .guid = UVC_GUID_FORMAT_H265,
161 .fcc = V4L2_PIX_FMT_HEVC,
162 },
163 {
164 .name = "Greyscale 8 L/R (Y8I)",
165 .guid = UVC_GUID_FORMAT_Y8I,
166 .fcc = V4L2_PIX_FMT_Y8I,
167 },
168 {
169 .name = "Greyscale 12 L/R (Y12I)",
170 .guid = UVC_GUID_FORMAT_Y12I,
171 .fcc = V4L2_PIX_FMT_Y12I,
172 },
173 {
174 .name = "Depth data 16-bit (Z16)",
175 .guid = UVC_GUID_FORMAT_Z16,
176 .fcc = V4L2_PIX_FMT_Z16,
177 },
178 {
179 .name = "Bayer 10-bit (SRGGB10P)",
180 .guid = UVC_GUID_FORMAT_RW10,
181 .fcc = V4L2_PIX_FMT_SRGGB10P,
182 },
183 {
184 .name = "Bayer 16-bit (SBGGR16)",
185 .guid = UVC_GUID_FORMAT_BG16,
186 .fcc = V4L2_PIX_FMT_SBGGR16,
187 },
188 {
189 .name = "Bayer 16-bit (SGBRG16)",
190 .guid = UVC_GUID_FORMAT_GB16,
191 .fcc = V4L2_PIX_FMT_SGBRG16,
192 },
193 {
194 .name = "Bayer 16-bit (SRGGB16)",
195 .guid = UVC_GUID_FORMAT_RG16,
196 .fcc = V4L2_PIX_FMT_SRGGB16,
197 },
198 {
199 .name = "Bayer 16-bit (SGRBG16)",
200 .guid = UVC_GUID_FORMAT_GR16,
201 .fcc = V4L2_PIX_FMT_SGRBG16,
202 },
203 {
204 .name = "Depth data 16-bit (Z16)",
205 .guid = UVC_GUID_FORMAT_INVZ,
206 .fcc = V4L2_PIX_FMT_Z16,
207 },
208 {
209 .name = "Greyscale 10-bit (Y10 )",
210 .guid = UVC_GUID_FORMAT_INVI,
211 .fcc = V4L2_PIX_FMT_Y10,
212 },
213 {
214 .name = "IR:Depth 26-bit (INZI)",
215 .guid = UVC_GUID_FORMAT_INZI,
216 .fcc = V4L2_PIX_FMT_INZI,
217 },
218 {
219 .name = "4-bit Depth Confidence (Packed)",
220 .guid = UVC_GUID_FORMAT_CNF4,
221 .fcc = V4L2_PIX_FMT_CNF4,
222 },
223 {
224 .name = "HEVC",
225 .guid = UVC_GUID_FORMAT_HEVC,
226 .fcc = V4L2_PIX_FMT_HEVC,
227 },
228 };
229
230 /* ------------------------------------------------------------------------
231 * Utility functions
232 */
233
uvc_find_endpoint(struct usb_host_interface * alts,u8 epaddr)234 struct usb_host_endpoint *uvc_find_endpoint(struct usb_host_interface *alts,
235 u8 epaddr)
236 {
237 struct usb_host_endpoint *ep;
238 unsigned int i;
239
240 for (i = 0; i < alts->desc.bNumEndpoints; ++i) {
241 ep = &alts->endpoint[i];
242 if (ep->desc.bEndpointAddress == epaddr)
243 return ep;
244 }
245
246 return NULL;
247 }
248
uvc_format_by_guid(const u8 guid[16])249 static struct uvc_format_desc *uvc_format_by_guid(const u8 guid[16])
250 {
251 unsigned int len = ARRAY_SIZE(uvc_fmts);
252 unsigned int i;
253
254 for (i = 0; i < len; ++i) {
255 if (memcmp(guid, uvc_fmts[i].guid, 16) == 0)
256 return &uvc_fmts[i];
257 }
258
259 return NULL;
260 }
261
uvc_colorspace(const u8 primaries)262 static enum v4l2_colorspace uvc_colorspace(const u8 primaries)
263 {
264 static const enum v4l2_colorspace colorprimaries[] = {
265 V4L2_COLORSPACE_DEFAULT, /* Unspecified */
266 V4L2_COLORSPACE_SRGB,
267 V4L2_COLORSPACE_470_SYSTEM_M,
268 V4L2_COLORSPACE_470_SYSTEM_BG,
269 V4L2_COLORSPACE_SMPTE170M,
270 V4L2_COLORSPACE_SMPTE240M,
271 };
272
273 if (primaries < ARRAY_SIZE(colorprimaries))
274 return colorprimaries[primaries];
275
276 return V4L2_COLORSPACE_DEFAULT; /* Reserved */
277 }
278
uvc_xfer_func(const u8 transfer_characteristics)279 static enum v4l2_xfer_func uvc_xfer_func(const u8 transfer_characteristics)
280 {
281 /*
282 * V4L2 does not currently have definitions for all possible values of
283 * UVC transfer characteristics. If v4l2_xfer_func is extended with new
284 * values, the mapping below should be updated.
285 *
286 * Substitutions are taken from the mapping given for
287 * V4L2_XFER_FUNC_DEFAULT documented in videodev2.h.
288 */
289 static const enum v4l2_xfer_func xfer_funcs[] = {
290 V4L2_XFER_FUNC_DEFAULT, /* Unspecified */
291 V4L2_XFER_FUNC_709,
292 V4L2_XFER_FUNC_709, /* Substitution for BT.470-2 M */
293 V4L2_XFER_FUNC_709, /* Substitution for BT.470-2 B, G */
294 V4L2_XFER_FUNC_709, /* Substitution for SMPTE 170M */
295 V4L2_XFER_FUNC_SMPTE240M,
296 V4L2_XFER_FUNC_NONE,
297 V4L2_XFER_FUNC_SRGB,
298 };
299
300 if (transfer_characteristics < ARRAY_SIZE(xfer_funcs))
301 return xfer_funcs[transfer_characteristics];
302
303 return V4L2_XFER_FUNC_DEFAULT; /* Reserved */
304 }
305
uvc_ycbcr_enc(const u8 matrix_coefficients)306 static enum v4l2_ycbcr_encoding uvc_ycbcr_enc(const u8 matrix_coefficients)
307 {
308 /*
309 * V4L2 does not currently have definitions for all possible values of
310 * UVC matrix coefficients. If v4l2_ycbcr_encoding is extended with new
311 * values, the mapping below should be updated.
312 *
313 * Substitutions are taken from the mapping given for
314 * V4L2_YCBCR_ENC_DEFAULT documented in videodev2.h.
315 *
316 * FCC is assumed to be close enough to 601.
317 */
318 static const enum v4l2_ycbcr_encoding ycbcr_encs[] = {
319 V4L2_YCBCR_ENC_DEFAULT, /* Unspecified */
320 V4L2_YCBCR_ENC_709,
321 V4L2_YCBCR_ENC_601, /* Substitution for FCC */
322 V4L2_YCBCR_ENC_601, /* Substitution for BT.470-2 B, G */
323 V4L2_YCBCR_ENC_601,
324 V4L2_YCBCR_ENC_SMPTE240M,
325 };
326
327 if (matrix_coefficients < ARRAY_SIZE(ycbcr_encs))
328 return ycbcr_encs[matrix_coefficients];
329
330 return V4L2_YCBCR_ENC_DEFAULT; /* Reserved */
331 }
332
333 /* Simplify a fraction using a simple continued fraction decomposition. The
334 * idea here is to convert fractions such as 333333/10000000 to 1/30 using
335 * 32 bit arithmetic only. The algorithm is not perfect and relies upon two
336 * arbitrary parameters to remove non-significative terms from the simple
337 * continued fraction decomposition. Using 8 and 333 for n_terms and threshold
338 * respectively seems to give nice results.
339 */
uvc_simplify_fraction(u32 * numerator,u32 * denominator,unsigned int n_terms,unsigned int threshold)340 void uvc_simplify_fraction(u32 *numerator, u32 *denominator,
341 unsigned int n_terms, unsigned int threshold)
342 {
343 u32 *an;
344 u32 x, y, r;
345 unsigned int i, n;
346
347 an = kmalloc_array(n_terms, sizeof(*an), GFP_KERNEL);
348 if (an == NULL)
349 return;
350
351 /* Convert the fraction to a simple continued fraction. See
352 * https://mathforum.org/dr.math/faq/faq.fractions.html
353 * Stop if the current term is bigger than or equal to the given
354 * threshold.
355 */
356 x = *numerator;
357 y = *denominator;
358
359 for (n = 0; n < n_terms && y != 0; ++n) {
360 an[n] = x / y;
361 if (an[n] >= threshold) {
362 if (n < 2)
363 n++;
364 break;
365 }
366
367 r = x - an[n] * y;
368 x = y;
369 y = r;
370 }
371
372 /* Expand the simple continued fraction back to an integer fraction. */
373 x = 0;
374 y = 1;
375
376 for (i = n; i > 0; --i) {
377 r = y;
378 y = an[i-1] * y + x;
379 x = r;
380 }
381
382 *numerator = y;
383 *denominator = x;
384 kfree(an);
385 }
386
387 /* Convert a fraction to a frame interval in 100ns multiples. The idea here is
388 * to compute numerator / denominator * 10000000 using 32 bit fixed point
389 * arithmetic only.
390 */
uvc_fraction_to_interval(u32 numerator,u32 denominator)391 u32 uvc_fraction_to_interval(u32 numerator, u32 denominator)
392 {
393 u32 multiplier;
394
395 /* Saturate the result if the operation would overflow. */
396 if (denominator == 0 ||
397 numerator/denominator >= ((u32)-1)/10000000)
398 return (u32)-1;
399
400 /* Divide both the denominator and the multiplier by two until
401 * numerator * multiplier doesn't overflow. If anyone knows a better
402 * algorithm please let me know.
403 */
404 multiplier = 10000000;
405 while (numerator > ((u32)-1)/multiplier) {
406 multiplier /= 2;
407 denominator /= 2;
408 }
409
410 return denominator ? numerator * multiplier / denominator : 0;
411 }
412
413 /* ------------------------------------------------------------------------
414 * Terminal and unit management
415 */
416
uvc_entity_by_id(struct uvc_device * dev,int id)417 struct uvc_entity *uvc_entity_by_id(struct uvc_device *dev, int id)
418 {
419 struct uvc_entity *entity;
420
421 list_for_each_entry(entity, &dev->entities, list) {
422 if (entity->id == id)
423 return entity;
424 }
425
426 return NULL;
427 }
428
uvc_entity_by_reference(struct uvc_device * dev,int id,struct uvc_entity * entity)429 static struct uvc_entity *uvc_entity_by_reference(struct uvc_device *dev,
430 int id, struct uvc_entity *entity)
431 {
432 unsigned int i;
433
434 if (entity == NULL)
435 entity = list_entry(&dev->entities, struct uvc_entity, list);
436
437 list_for_each_entry_continue(entity, &dev->entities, list) {
438 for (i = 0; i < entity->bNrInPins; ++i)
439 if (entity->baSourceID[i] == id)
440 return entity;
441 }
442
443 return NULL;
444 }
445
uvc_stream_by_id(struct uvc_device * dev,int id)446 static struct uvc_streaming *uvc_stream_by_id(struct uvc_device *dev, int id)
447 {
448 struct uvc_streaming *stream;
449
450 list_for_each_entry(stream, &dev->streams, list) {
451 if (stream->header.bTerminalLink == id)
452 return stream;
453 }
454
455 return NULL;
456 }
457
458 /* ------------------------------------------------------------------------
459 * Streaming Object Management
460 */
461
uvc_stream_delete(struct uvc_streaming * stream)462 static void uvc_stream_delete(struct uvc_streaming *stream)
463 {
464 if (stream->async_wq)
465 destroy_workqueue(stream->async_wq);
466
467 mutex_destroy(&stream->mutex);
468
469 usb_put_intf(stream->intf);
470
471 kfree(stream->format);
472 kfree(stream->header.bmaControls);
473 kfree(stream);
474 }
475
uvc_stream_new(struct uvc_device * dev,struct usb_interface * intf)476 static struct uvc_streaming *uvc_stream_new(struct uvc_device *dev,
477 struct usb_interface *intf)
478 {
479 struct uvc_streaming *stream;
480
481 stream = kzalloc(sizeof(*stream), GFP_KERNEL);
482 if (stream == NULL)
483 return NULL;
484
485 mutex_init(&stream->mutex);
486
487 stream->dev = dev;
488 stream->intf = usb_get_intf(intf);
489 stream->intfnum = intf->cur_altsetting->desc.bInterfaceNumber;
490
491 /* Allocate a stream specific work queue for asynchronous tasks. */
492 stream->async_wq = alloc_workqueue("uvcvideo", WQ_UNBOUND | WQ_HIGHPRI,
493 0);
494 if (!stream->async_wq) {
495 uvc_stream_delete(stream);
496 return NULL;
497 }
498
499 return stream;
500 }
501
502 /* ------------------------------------------------------------------------
503 * Descriptors parsing
504 */
505
uvc_parse_format(struct uvc_device * dev,struct uvc_streaming * streaming,struct uvc_format * format,u32 ** intervals,unsigned char * buffer,int buflen)506 static int uvc_parse_format(struct uvc_device *dev,
507 struct uvc_streaming *streaming, struct uvc_format *format,
508 u32 **intervals, unsigned char *buffer, int buflen)
509 {
510 struct usb_interface *intf = streaming->intf;
511 struct usb_host_interface *alts = intf->cur_altsetting;
512 struct uvc_format_desc *fmtdesc;
513 struct uvc_frame *frame;
514 const unsigned char *start = buffer;
515 unsigned int width_multiplier = 1;
516 unsigned int interval;
517 unsigned int i, n;
518 u8 ftype;
519
520 format->type = buffer[2];
521 format->index = buffer[3];
522
523 switch (buffer[2]) {
524 case UVC_VS_FORMAT_UNCOMPRESSED:
525 case UVC_VS_FORMAT_FRAME_BASED:
526 n = buffer[2] == UVC_VS_FORMAT_UNCOMPRESSED ? 27 : 28;
527 if (buflen < n) {
528 uvc_trace(UVC_TRACE_DESCR, "device %d videostreaming "
529 "interface %d FORMAT error\n",
530 dev->udev->devnum,
531 alts->desc.bInterfaceNumber);
532 return -EINVAL;
533 }
534
535 /* Find the format descriptor from its GUID. */
536 fmtdesc = uvc_format_by_guid(&buffer[5]);
537
538 if (fmtdesc != NULL) {
539 strscpy(format->name, fmtdesc->name,
540 sizeof(format->name));
541 format->fcc = fmtdesc->fcc;
542 } else {
543 uvc_printk(KERN_INFO, "Unknown video format %pUl\n",
544 &buffer[5]);
545 snprintf(format->name, sizeof(format->name), "%pUl\n",
546 &buffer[5]);
547 format->fcc = 0;
548 }
549
550 format->bpp = buffer[21];
551
552 /* Some devices report a format that doesn't match what they
553 * really send.
554 */
555 if (dev->quirks & UVC_QUIRK_FORCE_Y8) {
556 if (format->fcc == V4L2_PIX_FMT_YUYV) {
557 strscpy(format->name, "Greyscale 8-bit (Y8 )",
558 sizeof(format->name));
559 format->fcc = V4L2_PIX_FMT_GREY;
560 format->bpp = 8;
561 width_multiplier = 2;
562 }
563 }
564
565 /* Some devices report bpp that doesn't match the format. */
566 if (dev->quirks & UVC_QUIRK_FORCE_BPP) {
567 const struct v4l2_format_info *info =
568 v4l2_format_info(format->fcc);
569
570 if (info) {
571 unsigned int div = info->hdiv * info->vdiv;
572
573 n = info->bpp[0] * div;
574 for (i = 1; i < info->comp_planes; i++)
575 n += info->bpp[i];
576
577 format->bpp = DIV_ROUND_UP(8 * n, div);
578 }
579 }
580
581 if (buffer[2] == UVC_VS_FORMAT_UNCOMPRESSED) {
582 ftype = UVC_VS_FRAME_UNCOMPRESSED;
583 } else {
584 ftype = UVC_VS_FRAME_FRAME_BASED;
585 if (buffer[27])
586 format->flags = UVC_FMT_FLAG_COMPRESSED;
587 }
588 break;
589
590 case UVC_VS_FORMAT_MJPEG:
591 if (buflen < 11) {
592 uvc_trace(UVC_TRACE_DESCR, "device %d videostreaming "
593 "interface %d FORMAT error\n",
594 dev->udev->devnum,
595 alts->desc.bInterfaceNumber);
596 return -EINVAL;
597 }
598
599 strscpy(format->name, "MJPEG", sizeof(format->name));
600 format->fcc = V4L2_PIX_FMT_MJPEG;
601 format->flags = UVC_FMT_FLAG_COMPRESSED;
602 format->bpp = 0;
603 ftype = UVC_VS_FRAME_MJPEG;
604 break;
605
606 case UVC_VS_FORMAT_DV:
607 if (buflen < 9) {
608 uvc_trace(UVC_TRACE_DESCR, "device %d videostreaming "
609 "interface %d FORMAT error\n",
610 dev->udev->devnum,
611 alts->desc.bInterfaceNumber);
612 return -EINVAL;
613 }
614
615 switch (buffer[8] & 0x7f) {
616 case 0:
617 strscpy(format->name, "SD-DV", sizeof(format->name));
618 break;
619 case 1:
620 strscpy(format->name, "SDL-DV", sizeof(format->name));
621 break;
622 case 2:
623 strscpy(format->name, "HD-DV", sizeof(format->name));
624 break;
625 default:
626 uvc_trace(UVC_TRACE_DESCR, "device %d videostreaming "
627 "interface %d: unknown DV format %u\n",
628 dev->udev->devnum,
629 alts->desc.bInterfaceNumber, buffer[8]);
630 return -EINVAL;
631 }
632
633 strlcat(format->name, buffer[8] & (1 << 7) ? " 60Hz" : " 50Hz",
634 sizeof(format->name));
635
636 format->fcc = V4L2_PIX_FMT_DV;
637 format->flags = UVC_FMT_FLAG_COMPRESSED | UVC_FMT_FLAG_STREAM;
638 format->bpp = 0;
639 ftype = 0;
640
641 /* Create a dummy frame descriptor. */
642 frame = &format->frame[0];
643 memset(&format->frame[0], 0, sizeof(format->frame[0]));
644 frame->bFrameIntervalType = 1;
645 frame->dwDefaultFrameInterval = 1;
646 frame->dwFrameInterval = *intervals;
647 *(*intervals)++ = 1;
648 format->nframes = 1;
649 break;
650
651 case UVC_VS_FORMAT_MPEG2TS:
652 case UVC_VS_FORMAT_STREAM_BASED:
653 /* Not supported yet. */
654 default:
655 uvc_trace(UVC_TRACE_DESCR, "device %d videostreaming "
656 "interface %d unsupported format %u\n",
657 dev->udev->devnum, alts->desc.bInterfaceNumber,
658 buffer[2]);
659 return -EINVAL;
660 }
661
662 uvc_trace(UVC_TRACE_DESCR, "Found format %s.\n", format->name);
663
664 buflen -= buffer[0];
665 buffer += buffer[0];
666
667 /* Parse the frame descriptors. Only uncompressed, MJPEG and frame
668 * based formats have frame descriptors.
669 */
670 while (buflen > 2 && buffer[1] == USB_DT_CS_INTERFACE &&
671 buffer[2] == ftype) {
672 frame = &format->frame[format->nframes];
673 if (ftype != UVC_VS_FRAME_FRAME_BASED)
674 n = buflen > 25 ? buffer[25] : 0;
675 else
676 n = buflen > 21 ? buffer[21] : 0;
677
678 n = n ? n : 3;
679
680 if (buflen < 26 + 4*n) {
681 uvc_trace(UVC_TRACE_DESCR, "device %d videostreaming "
682 "interface %d FRAME error\n", dev->udev->devnum,
683 alts->desc.bInterfaceNumber);
684 return -EINVAL;
685 }
686
687 frame->bFrameIndex = buffer[3];
688 frame->bmCapabilities = buffer[4];
689 frame->wWidth = get_unaligned_le16(&buffer[5])
690 * width_multiplier;
691 frame->wHeight = get_unaligned_le16(&buffer[7]);
692 frame->dwMinBitRate = get_unaligned_le32(&buffer[9]);
693 frame->dwMaxBitRate = get_unaligned_le32(&buffer[13]);
694 if (ftype != UVC_VS_FRAME_FRAME_BASED) {
695 frame->dwMaxVideoFrameBufferSize =
696 get_unaligned_le32(&buffer[17]);
697 frame->dwDefaultFrameInterval =
698 get_unaligned_le32(&buffer[21]);
699 frame->bFrameIntervalType = buffer[25];
700 } else {
701 frame->dwMaxVideoFrameBufferSize = 0;
702 frame->dwDefaultFrameInterval =
703 get_unaligned_le32(&buffer[17]);
704 frame->bFrameIntervalType = buffer[21];
705 }
706 frame->dwFrameInterval = *intervals;
707
708 /* Several UVC chipsets screw up dwMaxVideoFrameBufferSize
709 * completely. Observed behaviours range from setting the
710 * value to 1.1x the actual frame size to hardwiring the
711 * 16 low bits to 0. This results in a higher than necessary
712 * memory usage as well as a wrong image size information. For
713 * uncompressed formats this can be fixed by computing the
714 * value from the frame size.
715 */
716 if (!(format->flags & UVC_FMT_FLAG_COMPRESSED))
717 frame->dwMaxVideoFrameBufferSize = format->bpp
718 * frame->wWidth * frame->wHeight / 8;
719
720 /* Some bogus devices report dwMinFrameInterval equal to
721 * dwMaxFrameInterval and have dwFrameIntervalStep set to
722 * zero. Setting all null intervals to 1 fixes the problem and
723 * some other divisions by zero that could happen.
724 */
725 for (i = 0; i < n; ++i) {
726 interval = get_unaligned_le32(&buffer[26+4*i]);
727 *(*intervals)++ = interval ? interval : 1;
728 }
729
730 /* Make sure that the default frame interval stays between
731 * the boundaries.
732 */
733 n -= frame->bFrameIntervalType ? 1 : 2;
734 frame->dwDefaultFrameInterval =
735 min(frame->dwFrameInterval[n],
736 max(frame->dwFrameInterval[0],
737 frame->dwDefaultFrameInterval));
738
739 if (dev->quirks & UVC_QUIRK_RESTRICT_FRAME_RATE) {
740 frame->bFrameIntervalType = 1;
741 frame->dwFrameInterval[0] =
742 frame->dwDefaultFrameInterval;
743 }
744
745 uvc_trace(UVC_TRACE_DESCR, "- %ux%u (%u.%u fps)\n",
746 frame->wWidth, frame->wHeight,
747 10000000/frame->dwDefaultFrameInterval,
748 (100000000/frame->dwDefaultFrameInterval)%10);
749
750 format->nframes++;
751 buflen -= buffer[0];
752 buffer += buffer[0];
753 }
754
755 if (buflen > 2 && buffer[1] == USB_DT_CS_INTERFACE &&
756 buffer[2] == UVC_VS_STILL_IMAGE_FRAME) {
757 buflen -= buffer[0];
758 buffer += buffer[0];
759 }
760
761 if (buflen > 2 && buffer[1] == USB_DT_CS_INTERFACE &&
762 buffer[2] == UVC_VS_COLORFORMAT) {
763 if (buflen < 6) {
764 uvc_trace(UVC_TRACE_DESCR, "device %d videostreaming "
765 "interface %d COLORFORMAT error\n",
766 dev->udev->devnum,
767 alts->desc.bInterfaceNumber);
768 return -EINVAL;
769 }
770
771 format->colorspace = uvc_colorspace(buffer[3]);
772 format->xfer_func = uvc_xfer_func(buffer[4]);
773 format->ycbcr_enc = uvc_ycbcr_enc(buffer[5]);
774
775 buflen -= buffer[0];
776 buffer += buffer[0];
777 }
778
779 return buffer - start;
780 }
781
uvc_parse_streaming(struct uvc_device * dev,struct usb_interface * intf)782 static int uvc_parse_streaming(struct uvc_device *dev,
783 struct usb_interface *intf)
784 {
785 struct uvc_streaming *streaming = NULL;
786 struct uvc_format *format;
787 struct uvc_frame *frame;
788 struct usb_host_interface *alts = &intf->altsetting[0];
789 unsigned char *_buffer, *buffer = alts->extra;
790 int _buflen, buflen = alts->extralen;
791 unsigned int nformats = 0, nframes = 0, nintervals = 0;
792 unsigned int size, i, n, p;
793 u32 *interval;
794 u16 psize;
795 int ret = -EINVAL;
796
797 if (intf->cur_altsetting->desc.bInterfaceSubClass
798 != UVC_SC_VIDEOSTREAMING) {
799 uvc_trace(UVC_TRACE_DESCR, "device %d interface %d isn't a "
800 "video streaming interface\n", dev->udev->devnum,
801 intf->altsetting[0].desc.bInterfaceNumber);
802 return -EINVAL;
803 }
804
805 if (usb_driver_claim_interface(&uvc_driver.driver, intf, dev)) {
806 uvc_trace(UVC_TRACE_DESCR, "device %d interface %d is already "
807 "claimed\n", dev->udev->devnum,
808 intf->altsetting[0].desc.bInterfaceNumber);
809 return -EINVAL;
810 }
811
812 streaming = uvc_stream_new(dev, intf);
813 if (streaming == NULL) {
814 usb_driver_release_interface(&uvc_driver.driver, intf);
815 return -ENOMEM;
816 }
817
818 /* The Pico iMage webcam has its class-specific interface descriptors
819 * after the endpoint descriptors.
820 */
821 if (buflen == 0) {
822 for (i = 0; i < alts->desc.bNumEndpoints; ++i) {
823 struct usb_host_endpoint *ep = &alts->endpoint[i];
824
825 if (ep->extralen == 0)
826 continue;
827
828 if (ep->extralen > 2 &&
829 ep->extra[1] == USB_DT_CS_INTERFACE) {
830 uvc_trace(UVC_TRACE_DESCR, "trying extra data "
831 "from endpoint %u.\n", i);
832 buffer = alts->endpoint[i].extra;
833 buflen = alts->endpoint[i].extralen;
834 break;
835 }
836 }
837 }
838
839 /* Skip the standard interface descriptors. */
840 while (buflen > 2 && buffer[1] != USB_DT_CS_INTERFACE) {
841 buflen -= buffer[0];
842 buffer += buffer[0];
843 }
844
845 if (buflen <= 2) {
846 uvc_trace(UVC_TRACE_DESCR, "no class-specific streaming "
847 "interface descriptors found.\n");
848 goto error;
849 }
850
851 /* Parse the header descriptor. */
852 switch (buffer[2]) {
853 case UVC_VS_OUTPUT_HEADER:
854 streaming->type = V4L2_BUF_TYPE_VIDEO_OUTPUT;
855 size = 9;
856 break;
857
858 case UVC_VS_INPUT_HEADER:
859 streaming->type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
860 size = 13;
861 break;
862
863 default:
864 uvc_trace(UVC_TRACE_DESCR, "device %d videostreaming interface "
865 "%d HEADER descriptor not found.\n", dev->udev->devnum,
866 alts->desc.bInterfaceNumber);
867 goto error;
868 }
869
870 p = buflen >= 4 ? buffer[3] : 0;
871 n = buflen >= size ? buffer[size-1] : 0;
872
873 if (buflen < size + p*n) {
874 uvc_trace(UVC_TRACE_DESCR, "device %d videostreaming "
875 "interface %d HEADER descriptor is invalid.\n",
876 dev->udev->devnum, alts->desc.bInterfaceNumber);
877 goto error;
878 }
879
880 streaming->header.bNumFormats = p;
881 streaming->header.bEndpointAddress = buffer[6];
882 if (buffer[2] == UVC_VS_INPUT_HEADER) {
883 streaming->header.bmInfo = buffer[7];
884 streaming->header.bTerminalLink = buffer[8];
885 streaming->header.bStillCaptureMethod = buffer[9];
886 streaming->header.bTriggerSupport = buffer[10];
887 streaming->header.bTriggerUsage = buffer[11];
888 } else {
889 streaming->header.bTerminalLink = buffer[7];
890 }
891 streaming->header.bControlSize = n;
892
893 streaming->header.bmaControls = kmemdup(&buffer[size], p * n,
894 GFP_KERNEL);
895 if (streaming->header.bmaControls == NULL) {
896 ret = -ENOMEM;
897 goto error;
898 }
899
900 buflen -= buffer[0];
901 buffer += buffer[0];
902
903 _buffer = buffer;
904 _buflen = buflen;
905
906 /* Count the format and frame descriptors. */
907 while (_buflen > 2 && _buffer[1] == USB_DT_CS_INTERFACE) {
908 switch (_buffer[2]) {
909 case UVC_VS_FORMAT_UNCOMPRESSED:
910 case UVC_VS_FORMAT_MJPEG:
911 case UVC_VS_FORMAT_FRAME_BASED:
912 nformats++;
913 break;
914
915 case UVC_VS_FORMAT_DV:
916 /* DV format has no frame descriptor. We will create a
917 * dummy frame descriptor with a dummy frame interval.
918 */
919 nformats++;
920 nframes++;
921 nintervals++;
922 break;
923
924 case UVC_VS_FORMAT_MPEG2TS:
925 case UVC_VS_FORMAT_STREAM_BASED:
926 uvc_trace(UVC_TRACE_DESCR, "device %d videostreaming "
927 "interface %d FORMAT %u is not supported.\n",
928 dev->udev->devnum,
929 alts->desc.bInterfaceNumber, _buffer[2]);
930 break;
931
932 case UVC_VS_FRAME_UNCOMPRESSED:
933 case UVC_VS_FRAME_MJPEG:
934 nframes++;
935 if (_buflen > 25)
936 nintervals += _buffer[25] ? _buffer[25] : 3;
937 break;
938
939 case UVC_VS_FRAME_FRAME_BASED:
940 nframes++;
941 if (_buflen > 21)
942 nintervals += _buffer[21] ? _buffer[21] : 3;
943 break;
944 }
945
946 _buflen -= _buffer[0];
947 _buffer += _buffer[0];
948 }
949
950 if (nformats == 0) {
951 uvc_trace(UVC_TRACE_DESCR, "device %d videostreaming interface "
952 "%d has no supported formats defined.\n",
953 dev->udev->devnum, alts->desc.bInterfaceNumber);
954 goto error;
955 }
956
957 size = nformats * sizeof(*format) + nframes * sizeof(*frame)
958 + nintervals * sizeof(*interval);
959 format = kzalloc(size, GFP_KERNEL);
960 if (format == NULL) {
961 ret = -ENOMEM;
962 goto error;
963 }
964
965 frame = (struct uvc_frame *)&format[nformats];
966 interval = (u32 *)&frame[nframes];
967
968 streaming->format = format;
969 streaming->nformats = nformats;
970
971 /* Parse the format descriptors. */
972 while (buflen > 2 && buffer[1] == USB_DT_CS_INTERFACE) {
973 switch (buffer[2]) {
974 case UVC_VS_FORMAT_UNCOMPRESSED:
975 case UVC_VS_FORMAT_MJPEG:
976 case UVC_VS_FORMAT_DV:
977 case UVC_VS_FORMAT_FRAME_BASED:
978 format->frame = frame;
979 ret = uvc_parse_format(dev, streaming, format,
980 &interval, buffer, buflen);
981 if (ret < 0)
982 goto error;
983
984 frame += format->nframes;
985 format++;
986
987 buflen -= ret;
988 buffer += ret;
989 continue;
990
991 default:
992 break;
993 }
994
995 buflen -= buffer[0];
996 buffer += buffer[0];
997 }
998
999 if (buflen)
1000 uvc_trace(UVC_TRACE_DESCR, "device %d videostreaming interface "
1001 "%d has %u bytes of trailing descriptor garbage.\n",
1002 dev->udev->devnum, alts->desc.bInterfaceNumber, buflen);
1003
1004 /* Parse the alternate settings to find the maximum bandwidth. */
1005 for (i = 0; i < intf->num_altsetting; ++i) {
1006 struct usb_host_endpoint *ep;
1007 alts = &intf->altsetting[i];
1008 ep = uvc_find_endpoint(alts,
1009 streaming->header.bEndpointAddress);
1010 if (ep == NULL)
1011 continue;
1012
1013 psize = le16_to_cpu(ep->desc.wMaxPacketSize);
1014 psize = (psize & 0x07ff) * (1 + ((psize >> 11) & 3));
1015 if (psize > streaming->maxpsize)
1016 streaming->maxpsize = psize;
1017 }
1018
1019 list_add_tail(&streaming->list, &dev->streams);
1020 return 0;
1021
1022 error:
1023 usb_driver_release_interface(&uvc_driver.driver, intf);
1024 uvc_stream_delete(streaming);
1025 return ret;
1026 }
1027
uvc_alloc_entity(u16 type,u8 id,unsigned int num_pads,unsigned int extra_size)1028 static struct uvc_entity *uvc_alloc_entity(u16 type, u8 id,
1029 unsigned int num_pads, unsigned int extra_size)
1030 {
1031 struct uvc_entity *entity;
1032 unsigned int num_inputs;
1033 unsigned int size;
1034 unsigned int i;
1035
1036 extra_size = roundup(extra_size, sizeof(*entity->pads));
1037 if (num_pads)
1038 num_inputs = type & UVC_TERM_OUTPUT ? num_pads : num_pads - 1;
1039 else
1040 num_inputs = 0;
1041 size = sizeof(*entity) + extra_size + sizeof(*entity->pads) * num_pads
1042 + num_inputs;
1043 entity = kzalloc(size, GFP_KERNEL);
1044 if (entity == NULL)
1045 return NULL;
1046
1047 entity->id = id;
1048 entity->type = type;
1049
1050 entity->num_links = 0;
1051 entity->num_pads = num_pads;
1052 entity->pads = ((void *)(entity + 1)) + extra_size;
1053
1054 for (i = 0; i < num_inputs; ++i)
1055 entity->pads[i].flags = MEDIA_PAD_FL_SINK;
1056 if (!UVC_ENTITY_IS_OTERM(entity) && num_pads)
1057 entity->pads[num_pads-1].flags = MEDIA_PAD_FL_SOURCE;
1058
1059 entity->bNrInPins = num_inputs;
1060 entity->baSourceID = (u8 *)(&entity->pads[num_pads]);
1061
1062 return entity;
1063 }
1064
1065 /* Parse vendor-specific extensions. */
uvc_parse_vendor_control(struct uvc_device * dev,const unsigned char * buffer,int buflen)1066 static int uvc_parse_vendor_control(struct uvc_device *dev,
1067 const unsigned char *buffer, int buflen)
1068 {
1069 struct usb_device *udev = dev->udev;
1070 struct usb_host_interface *alts = dev->intf->cur_altsetting;
1071 struct uvc_entity *unit;
1072 unsigned int n, p;
1073 int handled = 0;
1074
1075 switch (le16_to_cpu(dev->udev->descriptor.idVendor)) {
1076 case 0x046d: /* Logitech */
1077 if (buffer[1] != 0x41 || buffer[2] != 0x01)
1078 break;
1079
1080 /* Logitech implements several vendor specific functions
1081 * through vendor specific extension units (LXU).
1082 *
1083 * The LXU descriptors are similar to XU descriptors
1084 * (see "USB Device Video Class for Video Devices", section
1085 * 3.7.2.6 "Extension Unit Descriptor") with the following
1086 * differences:
1087 *
1088 * ----------------------------------------------------------
1089 * 0 bLength 1 Number
1090 * Size of this descriptor, in bytes: 24+p+n*2
1091 * ----------------------------------------------------------
1092 * 23+p+n bmControlsType N Bitmap
1093 * Individual bits in the set are defined:
1094 * 0: Absolute
1095 * 1: Relative
1096 *
1097 * This bitset is mapped exactly the same as bmControls.
1098 * ----------------------------------------------------------
1099 * 23+p+n*2 bReserved 1 Boolean
1100 * ----------------------------------------------------------
1101 * 24+p+n*2 iExtension 1 Index
1102 * Index of a string descriptor that describes this
1103 * extension unit.
1104 * ----------------------------------------------------------
1105 */
1106 p = buflen >= 22 ? buffer[21] : 0;
1107 n = buflen >= 25 + p ? buffer[22+p] : 0;
1108
1109 if (buflen < 25 + p + 2*n) {
1110 uvc_trace(UVC_TRACE_DESCR, "device %d videocontrol "
1111 "interface %d EXTENSION_UNIT error\n",
1112 udev->devnum, alts->desc.bInterfaceNumber);
1113 break;
1114 }
1115
1116 unit = uvc_alloc_entity(UVC_VC_EXTENSION_UNIT, buffer[3],
1117 p + 1, 2*n);
1118 if (unit == NULL)
1119 return -ENOMEM;
1120
1121 memcpy(unit->extension.guidExtensionCode, &buffer[4], 16);
1122 unit->extension.bNumControls = buffer[20];
1123 memcpy(unit->baSourceID, &buffer[22], p);
1124 unit->extension.bControlSize = buffer[22+p];
1125 unit->extension.bmControls = (u8 *)unit + sizeof(*unit);
1126 unit->extension.bmControlsType = (u8 *)unit + sizeof(*unit)
1127 + n;
1128 memcpy(unit->extension.bmControls, &buffer[23+p], 2*n);
1129
1130 if (buffer[24+p+2*n] != 0)
1131 usb_string(udev, buffer[24+p+2*n], unit->name,
1132 sizeof(unit->name));
1133 else
1134 sprintf(unit->name, "Extension %u", buffer[3]);
1135
1136 list_add_tail(&unit->list, &dev->entities);
1137 handled = 1;
1138 break;
1139 }
1140
1141 return handled;
1142 }
1143
uvc_parse_standard_control(struct uvc_device * dev,const unsigned char * buffer,int buflen)1144 static int uvc_parse_standard_control(struct uvc_device *dev,
1145 const unsigned char *buffer, int buflen)
1146 {
1147 struct usb_device *udev = dev->udev;
1148 struct uvc_entity *unit, *term;
1149 struct usb_interface *intf;
1150 struct usb_host_interface *alts = dev->intf->cur_altsetting;
1151 unsigned int i, n, p, len;
1152 u16 type;
1153
1154 switch (buffer[2]) {
1155 case UVC_VC_HEADER:
1156 n = buflen >= 12 ? buffer[11] : 0;
1157
1158 if (buflen < 12 + n) {
1159 uvc_trace(UVC_TRACE_DESCR, "device %d videocontrol "
1160 "interface %d HEADER error\n", udev->devnum,
1161 alts->desc.bInterfaceNumber);
1162 return -EINVAL;
1163 }
1164
1165 dev->uvc_version = get_unaligned_le16(&buffer[3]);
1166 dev->clock_frequency = get_unaligned_le32(&buffer[7]);
1167
1168 /* Parse all USB Video Streaming interfaces. */
1169 for (i = 0; i < n; ++i) {
1170 intf = usb_ifnum_to_if(udev, buffer[12+i]);
1171 if (intf == NULL) {
1172 uvc_trace(UVC_TRACE_DESCR, "device %d "
1173 "interface %d doesn't exists\n",
1174 udev->devnum, i);
1175 continue;
1176 }
1177
1178 uvc_parse_streaming(dev, intf);
1179 }
1180 break;
1181
1182 case UVC_VC_INPUT_TERMINAL:
1183 if (buflen < 8) {
1184 uvc_trace(UVC_TRACE_DESCR, "device %d videocontrol "
1185 "interface %d INPUT_TERMINAL error\n",
1186 udev->devnum, alts->desc.bInterfaceNumber);
1187 return -EINVAL;
1188 }
1189
1190 /*
1191 * Reject invalid terminal types that would cause issues:
1192 *
1193 * - The high byte must be non-zero, otherwise it would be
1194 * confused with a unit.
1195 *
1196 * - Bit 15 must be 0, as we use it internally as a terminal
1197 * direction flag.
1198 *
1199 * Other unknown types are accepted.
1200 */
1201 type = get_unaligned_le16(&buffer[4]);
1202 if ((type & 0x7f00) == 0 || (type & 0x8000) != 0) {
1203 uvc_trace(UVC_TRACE_DESCR, "device %d videocontrol "
1204 "interface %d INPUT_TERMINAL %d has invalid "
1205 "type 0x%04x, skipping\n", udev->devnum,
1206 alts->desc.bInterfaceNumber,
1207 buffer[3], type);
1208 return 0;
1209 }
1210
1211 n = 0;
1212 p = 0;
1213 len = 8;
1214
1215 if (type == UVC_ITT_CAMERA) {
1216 n = buflen >= 15 ? buffer[14] : 0;
1217 len = 15;
1218
1219 } else if (type == UVC_ITT_MEDIA_TRANSPORT_INPUT) {
1220 n = buflen >= 9 ? buffer[8] : 0;
1221 p = buflen >= 10 + n ? buffer[9+n] : 0;
1222 len = 10;
1223 }
1224
1225 if (buflen < len + n + p) {
1226 uvc_trace(UVC_TRACE_DESCR, "device %d videocontrol "
1227 "interface %d INPUT_TERMINAL error\n",
1228 udev->devnum, alts->desc.bInterfaceNumber);
1229 return -EINVAL;
1230 }
1231
1232 term = uvc_alloc_entity(type | UVC_TERM_INPUT, buffer[3],
1233 1, n + p);
1234 if (term == NULL)
1235 return -ENOMEM;
1236
1237 if (UVC_ENTITY_TYPE(term) == UVC_ITT_CAMERA) {
1238 term->camera.bControlSize = n;
1239 term->camera.bmControls = (u8 *)term + sizeof(*term);
1240 term->camera.wObjectiveFocalLengthMin =
1241 get_unaligned_le16(&buffer[8]);
1242 term->camera.wObjectiveFocalLengthMax =
1243 get_unaligned_le16(&buffer[10]);
1244 term->camera.wOcularFocalLength =
1245 get_unaligned_le16(&buffer[12]);
1246 memcpy(term->camera.bmControls, &buffer[15], n);
1247 } else if (UVC_ENTITY_TYPE(term) ==
1248 UVC_ITT_MEDIA_TRANSPORT_INPUT) {
1249 term->media.bControlSize = n;
1250 term->media.bmControls = (u8 *)term + sizeof(*term);
1251 term->media.bTransportModeSize = p;
1252 term->media.bmTransportModes = (u8 *)term
1253 + sizeof(*term) + n;
1254 memcpy(term->media.bmControls, &buffer[9], n);
1255 memcpy(term->media.bmTransportModes, &buffer[10+n], p);
1256 }
1257
1258 if (buffer[7] != 0)
1259 usb_string(udev, buffer[7], term->name,
1260 sizeof(term->name));
1261 else if (UVC_ENTITY_TYPE(term) == UVC_ITT_CAMERA)
1262 sprintf(term->name, "Camera %u", buffer[3]);
1263 else if (UVC_ENTITY_TYPE(term) == UVC_ITT_MEDIA_TRANSPORT_INPUT)
1264 sprintf(term->name, "Media %u", buffer[3]);
1265 else
1266 sprintf(term->name, "Input %u", buffer[3]);
1267
1268 list_add_tail(&term->list, &dev->entities);
1269 break;
1270
1271 case UVC_VC_OUTPUT_TERMINAL:
1272 if (buflen < 9) {
1273 uvc_trace(UVC_TRACE_DESCR, "device %d videocontrol "
1274 "interface %d OUTPUT_TERMINAL error\n",
1275 udev->devnum, alts->desc.bInterfaceNumber);
1276 return -EINVAL;
1277 }
1278
1279 /* Make sure the terminal type MSB is not null, otherwise it
1280 * could be confused with a unit.
1281 */
1282 type = get_unaligned_le16(&buffer[4]);
1283 if ((type & 0xff00) == 0) {
1284 uvc_trace(UVC_TRACE_DESCR, "device %d videocontrol "
1285 "interface %d OUTPUT_TERMINAL %d has invalid "
1286 "type 0x%04x, skipping\n", udev->devnum,
1287 alts->desc.bInterfaceNumber, buffer[3], type);
1288 return 0;
1289 }
1290
1291 term = uvc_alloc_entity(type | UVC_TERM_OUTPUT, buffer[3],
1292 1, 0);
1293 if (term == NULL)
1294 return -ENOMEM;
1295
1296 memcpy(term->baSourceID, &buffer[7], 1);
1297
1298 if (buffer[8] != 0)
1299 usb_string(udev, buffer[8], term->name,
1300 sizeof(term->name));
1301 else
1302 sprintf(term->name, "Output %u", buffer[3]);
1303
1304 list_add_tail(&term->list, &dev->entities);
1305 break;
1306
1307 case UVC_VC_SELECTOR_UNIT:
1308 p = buflen >= 5 ? buffer[4] : 0;
1309
1310 if (buflen < 5 || buflen < 6 + p) {
1311 uvc_trace(UVC_TRACE_DESCR, "device %d videocontrol "
1312 "interface %d SELECTOR_UNIT error\n",
1313 udev->devnum, alts->desc.bInterfaceNumber);
1314 return -EINVAL;
1315 }
1316
1317 unit = uvc_alloc_entity(buffer[2], buffer[3], p + 1, 0);
1318 if (unit == NULL)
1319 return -ENOMEM;
1320
1321 memcpy(unit->baSourceID, &buffer[5], p);
1322
1323 if (buffer[5+p] != 0)
1324 usb_string(udev, buffer[5+p], unit->name,
1325 sizeof(unit->name));
1326 else
1327 sprintf(unit->name, "Selector %u", buffer[3]);
1328
1329 list_add_tail(&unit->list, &dev->entities);
1330 break;
1331
1332 case UVC_VC_PROCESSING_UNIT:
1333 n = buflen >= 8 ? buffer[7] : 0;
1334 p = dev->uvc_version >= 0x0110 ? 10 : 9;
1335
1336 if (buflen < p + n) {
1337 uvc_trace(UVC_TRACE_DESCR, "device %d videocontrol "
1338 "interface %d PROCESSING_UNIT error\n",
1339 udev->devnum, alts->desc.bInterfaceNumber);
1340 return -EINVAL;
1341 }
1342
1343 unit = uvc_alloc_entity(buffer[2], buffer[3], 2, n);
1344 if (unit == NULL)
1345 return -ENOMEM;
1346
1347 memcpy(unit->baSourceID, &buffer[4], 1);
1348 unit->processing.wMaxMultiplier =
1349 get_unaligned_le16(&buffer[5]);
1350 unit->processing.bControlSize = buffer[7];
1351 unit->processing.bmControls = (u8 *)unit + sizeof(*unit);
1352 memcpy(unit->processing.bmControls, &buffer[8], n);
1353 if (dev->uvc_version >= 0x0110)
1354 unit->processing.bmVideoStandards = buffer[9+n];
1355
1356 if (buffer[8+n] != 0)
1357 usb_string(udev, buffer[8+n], unit->name,
1358 sizeof(unit->name));
1359 else
1360 sprintf(unit->name, "Processing %u", buffer[3]);
1361
1362 list_add_tail(&unit->list, &dev->entities);
1363 break;
1364
1365 case UVC_VC_EXTENSION_UNIT:
1366 p = buflen >= 22 ? buffer[21] : 0;
1367 n = buflen >= 24 + p ? buffer[22+p] : 0;
1368
1369 if (buflen < 24 + p + n) {
1370 uvc_trace(UVC_TRACE_DESCR, "device %d videocontrol "
1371 "interface %d EXTENSION_UNIT error\n",
1372 udev->devnum, alts->desc.bInterfaceNumber);
1373 return -EINVAL;
1374 }
1375
1376 unit = uvc_alloc_entity(buffer[2], buffer[3], p + 1, n);
1377 if (unit == NULL)
1378 return -ENOMEM;
1379
1380 memcpy(unit->extension.guidExtensionCode, &buffer[4], 16);
1381 unit->extension.bNumControls = buffer[20];
1382 memcpy(unit->baSourceID, &buffer[22], p);
1383 unit->extension.bControlSize = buffer[22+p];
1384 unit->extension.bmControls = (u8 *)unit + sizeof(*unit);
1385 memcpy(unit->extension.bmControls, &buffer[23+p], n);
1386
1387 if (buffer[23+p+n] != 0)
1388 usb_string(udev, buffer[23+p+n], unit->name,
1389 sizeof(unit->name));
1390 else
1391 sprintf(unit->name, "Extension %u", buffer[3]);
1392
1393 list_add_tail(&unit->list, &dev->entities);
1394 break;
1395
1396 default:
1397 uvc_trace(UVC_TRACE_DESCR, "Found an unknown CS_INTERFACE "
1398 "descriptor (%u)\n", buffer[2]);
1399 break;
1400 }
1401
1402 return 0;
1403 }
1404
uvc_parse_control(struct uvc_device * dev)1405 static int uvc_parse_control(struct uvc_device *dev)
1406 {
1407 struct usb_host_interface *alts = dev->intf->cur_altsetting;
1408 unsigned char *buffer = alts->extra;
1409 int buflen = alts->extralen;
1410 int ret;
1411
1412 /* Parse the default alternate setting only, as the UVC specification
1413 * defines a single alternate setting, the default alternate setting
1414 * zero.
1415 */
1416
1417 while (buflen > 2) {
1418 if (uvc_parse_vendor_control(dev, buffer, buflen) ||
1419 buffer[1] != USB_DT_CS_INTERFACE)
1420 goto next_descriptor;
1421
1422 if ((ret = uvc_parse_standard_control(dev, buffer, buflen)) < 0)
1423 return ret;
1424
1425 next_descriptor:
1426 buflen -= buffer[0];
1427 buffer += buffer[0];
1428 }
1429
1430 /* Check if the optional status endpoint is present. Built-in iSight
1431 * webcams have an interrupt endpoint but spit proprietary data that
1432 * don't conform to the UVC status endpoint messages. Don't try to
1433 * handle the interrupt endpoint for those cameras.
1434 */
1435 if (alts->desc.bNumEndpoints == 1 &&
1436 !(dev->quirks & UVC_QUIRK_BUILTIN_ISIGHT)) {
1437 struct usb_host_endpoint *ep = &alts->endpoint[0];
1438 struct usb_endpoint_descriptor *desc = &ep->desc;
1439
1440 if (usb_endpoint_is_int_in(desc) &&
1441 le16_to_cpu(desc->wMaxPacketSize) >= 8 &&
1442 desc->bInterval != 0) {
1443 uvc_trace(UVC_TRACE_DESCR, "Found a Status endpoint "
1444 "(addr %02x).\n", desc->bEndpointAddress);
1445 dev->int_ep = ep;
1446 }
1447 }
1448
1449 return 0;
1450 }
1451
1452 /* ------------------------------------------------------------------------
1453 * UVC device scan
1454 */
1455
1456 /*
1457 * Scan the UVC descriptors to locate a chain starting at an Output Terminal
1458 * and containing the following units:
1459 *
1460 * - one or more Output Terminals (USB Streaming or Display)
1461 * - zero or one Processing Unit
1462 * - zero, one or more single-input Selector Units
1463 * - zero or one multiple-input Selector Units, provided all inputs are
1464 * connected to input terminals
1465 * - zero, one or mode single-input Extension Units
1466 * - one or more Input Terminals (Camera, External or USB Streaming)
1467 *
1468 * The terminal and units must match on of the following structures:
1469 *
1470 * ITT_*(0) -> +---------+ +---------+ +---------+ -> TT_STREAMING(0)
1471 * ... | SU{0,1} | -> | PU{0,1} | -> | XU{0,n} | ...
1472 * ITT_*(n) -> +---------+ +---------+ +---------+ -> TT_STREAMING(n)
1473 *
1474 * +---------+ +---------+ -> OTT_*(0)
1475 * TT_STREAMING -> | PU{0,1} | -> | XU{0,n} | ...
1476 * +---------+ +---------+ -> OTT_*(n)
1477 *
1478 * The Processing Unit and Extension Units can be in any order. Additional
1479 * Extension Units connected to the main chain as single-unit branches are
1480 * also supported. Single-input Selector Units are ignored.
1481 */
uvc_scan_chain_entity(struct uvc_video_chain * chain,struct uvc_entity * entity)1482 static int uvc_scan_chain_entity(struct uvc_video_chain *chain,
1483 struct uvc_entity *entity)
1484 {
1485 switch (UVC_ENTITY_TYPE(entity)) {
1486 case UVC_VC_EXTENSION_UNIT:
1487 if (uvc_trace_param & UVC_TRACE_PROBE)
1488 printk(KERN_CONT " <- XU %d", entity->id);
1489
1490 if (entity->bNrInPins != 1) {
1491 uvc_trace(UVC_TRACE_DESCR, "Extension unit %d has more "
1492 "than 1 input pin.\n", entity->id);
1493 return -1;
1494 }
1495
1496 break;
1497
1498 case UVC_VC_PROCESSING_UNIT:
1499 if (uvc_trace_param & UVC_TRACE_PROBE)
1500 printk(KERN_CONT " <- PU %d", entity->id);
1501
1502 if (chain->processing != NULL) {
1503 uvc_trace(UVC_TRACE_DESCR, "Found multiple "
1504 "Processing Units in chain.\n");
1505 return -1;
1506 }
1507
1508 chain->processing = entity;
1509 break;
1510
1511 case UVC_VC_SELECTOR_UNIT:
1512 if (uvc_trace_param & UVC_TRACE_PROBE)
1513 printk(KERN_CONT " <- SU %d", entity->id);
1514
1515 /* Single-input selector units are ignored. */
1516 if (entity->bNrInPins == 1)
1517 break;
1518
1519 if (chain->selector != NULL) {
1520 uvc_trace(UVC_TRACE_DESCR, "Found multiple Selector "
1521 "Units in chain.\n");
1522 return -1;
1523 }
1524
1525 chain->selector = entity;
1526 break;
1527
1528 case UVC_ITT_VENDOR_SPECIFIC:
1529 case UVC_ITT_CAMERA:
1530 case UVC_ITT_MEDIA_TRANSPORT_INPUT:
1531 if (uvc_trace_param & UVC_TRACE_PROBE)
1532 printk(KERN_CONT " <- IT %d\n", entity->id);
1533
1534 break;
1535
1536 case UVC_OTT_VENDOR_SPECIFIC:
1537 case UVC_OTT_DISPLAY:
1538 case UVC_OTT_MEDIA_TRANSPORT_OUTPUT:
1539 if (uvc_trace_param & UVC_TRACE_PROBE)
1540 printk(KERN_CONT " OT %d", entity->id);
1541
1542 break;
1543
1544 case UVC_TT_STREAMING:
1545 if (UVC_ENTITY_IS_ITERM(entity)) {
1546 if (uvc_trace_param & UVC_TRACE_PROBE)
1547 printk(KERN_CONT " <- IT %d\n", entity->id);
1548 } else {
1549 if (uvc_trace_param & UVC_TRACE_PROBE)
1550 printk(KERN_CONT " OT %d", entity->id);
1551 }
1552
1553 break;
1554
1555 default:
1556 uvc_trace(UVC_TRACE_DESCR, "Unsupported entity type "
1557 "0x%04x found in chain.\n", UVC_ENTITY_TYPE(entity));
1558 return -1;
1559 }
1560
1561 list_add_tail(&entity->chain, &chain->entities);
1562 return 0;
1563 }
1564
uvc_scan_chain_forward(struct uvc_video_chain * chain,struct uvc_entity * entity,struct uvc_entity * prev)1565 static int uvc_scan_chain_forward(struct uvc_video_chain *chain,
1566 struct uvc_entity *entity, struct uvc_entity *prev)
1567 {
1568 struct uvc_entity *forward;
1569 int found;
1570
1571 /* Forward scan */
1572 forward = NULL;
1573 found = 0;
1574
1575 while (1) {
1576 forward = uvc_entity_by_reference(chain->dev, entity->id,
1577 forward);
1578 if (forward == NULL)
1579 break;
1580 if (forward == prev)
1581 continue;
1582 if (forward->chain.next || forward->chain.prev) {
1583 uvc_trace(UVC_TRACE_DESCR, "Found reference to "
1584 "entity %d already in chain.\n", forward->id);
1585 return -EINVAL;
1586 }
1587
1588 switch (UVC_ENTITY_TYPE(forward)) {
1589 case UVC_VC_EXTENSION_UNIT:
1590 if (forward->bNrInPins != 1) {
1591 uvc_trace(UVC_TRACE_DESCR, "Extension unit %d "
1592 "has more than 1 input pin.\n",
1593 entity->id);
1594 return -EINVAL;
1595 }
1596
1597 /*
1598 * Some devices reference an output terminal as the
1599 * source of extension units. This is incorrect, as
1600 * output terminals only have an input pin, and thus
1601 * can't be connected to any entity in the forward
1602 * direction. The resulting topology would cause issues
1603 * when registering the media controller graph. To
1604 * avoid this problem, connect the extension unit to
1605 * the source of the output terminal instead.
1606 */
1607 if (UVC_ENTITY_IS_OTERM(entity)) {
1608 struct uvc_entity *source;
1609
1610 source = uvc_entity_by_id(chain->dev,
1611 entity->baSourceID[0]);
1612 if (!source) {
1613 uvc_trace(UVC_TRACE_DESCR,
1614 "Can't connect extension unit %u in chain\n",
1615 forward->id);
1616 break;
1617 }
1618
1619 forward->baSourceID[0] = source->id;
1620 }
1621
1622 list_add_tail(&forward->chain, &chain->entities);
1623 if (uvc_trace_param & UVC_TRACE_PROBE) {
1624 if (!found)
1625 printk(KERN_CONT " (->");
1626
1627 printk(KERN_CONT " XU %d", forward->id);
1628 found = 1;
1629 }
1630 break;
1631
1632 case UVC_OTT_VENDOR_SPECIFIC:
1633 case UVC_OTT_DISPLAY:
1634 case UVC_OTT_MEDIA_TRANSPORT_OUTPUT:
1635 case UVC_TT_STREAMING:
1636 if (UVC_ENTITY_IS_ITERM(forward)) {
1637 uvc_trace(UVC_TRACE_DESCR, "Unsupported input "
1638 "terminal %u.\n", forward->id);
1639 return -EINVAL;
1640 }
1641
1642 if (UVC_ENTITY_IS_OTERM(entity)) {
1643 uvc_trace(UVC_TRACE_DESCR,
1644 "Unsupported connection between output terminals %u and %u\n",
1645 entity->id, forward->id);
1646 break;
1647 }
1648
1649 list_add_tail(&forward->chain, &chain->entities);
1650 if (uvc_trace_param & UVC_TRACE_PROBE) {
1651 if (!found)
1652 printk(KERN_CONT " (->");
1653
1654 printk(KERN_CONT " OT %d", forward->id);
1655 found = 1;
1656 }
1657 break;
1658 }
1659 }
1660 if (found)
1661 printk(KERN_CONT ")");
1662
1663 return 0;
1664 }
1665
uvc_scan_chain_backward(struct uvc_video_chain * chain,struct uvc_entity ** _entity)1666 static int uvc_scan_chain_backward(struct uvc_video_chain *chain,
1667 struct uvc_entity **_entity)
1668 {
1669 struct uvc_entity *entity = *_entity;
1670 struct uvc_entity *term;
1671 int id = -EINVAL, i;
1672
1673 switch (UVC_ENTITY_TYPE(entity)) {
1674 case UVC_VC_EXTENSION_UNIT:
1675 case UVC_VC_PROCESSING_UNIT:
1676 id = entity->baSourceID[0];
1677 break;
1678
1679 case UVC_VC_SELECTOR_UNIT:
1680 /* Single-input selector units are ignored. */
1681 if (entity->bNrInPins == 1) {
1682 id = entity->baSourceID[0];
1683 break;
1684 }
1685
1686 if (uvc_trace_param & UVC_TRACE_PROBE)
1687 printk(KERN_CONT " <- IT");
1688
1689 chain->selector = entity;
1690 for (i = 0; i < entity->bNrInPins; ++i) {
1691 id = entity->baSourceID[i];
1692 term = uvc_entity_by_id(chain->dev, id);
1693 if (term == NULL || !UVC_ENTITY_IS_ITERM(term)) {
1694 uvc_trace(UVC_TRACE_DESCR, "Selector unit %d "
1695 "input %d isn't connected to an "
1696 "input terminal\n", entity->id, i);
1697 return -1;
1698 }
1699
1700 if (term->chain.next || term->chain.prev) {
1701 uvc_trace(UVC_TRACE_DESCR, "Found reference to "
1702 "entity %d already in chain.\n",
1703 term->id);
1704 return -EINVAL;
1705 }
1706
1707 if (uvc_trace_param & UVC_TRACE_PROBE)
1708 printk(KERN_CONT " %d", term->id);
1709
1710 list_add_tail(&term->chain, &chain->entities);
1711 uvc_scan_chain_forward(chain, term, entity);
1712 }
1713
1714 if (uvc_trace_param & UVC_TRACE_PROBE)
1715 printk(KERN_CONT "\n");
1716
1717 id = 0;
1718 break;
1719
1720 case UVC_ITT_VENDOR_SPECIFIC:
1721 case UVC_ITT_CAMERA:
1722 case UVC_ITT_MEDIA_TRANSPORT_INPUT:
1723 case UVC_OTT_VENDOR_SPECIFIC:
1724 case UVC_OTT_DISPLAY:
1725 case UVC_OTT_MEDIA_TRANSPORT_OUTPUT:
1726 case UVC_TT_STREAMING:
1727 id = UVC_ENTITY_IS_OTERM(entity) ? entity->baSourceID[0] : 0;
1728 break;
1729 }
1730
1731 if (id <= 0) {
1732 *_entity = NULL;
1733 return id;
1734 }
1735
1736 entity = uvc_entity_by_id(chain->dev, id);
1737 if (entity == NULL) {
1738 uvc_trace(UVC_TRACE_DESCR, "Found reference to "
1739 "unknown entity %d.\n", id);
1740 return -EINVAL;
1741 }
1742
1743 *_entity = entity;
1744 return 0;
1745 }
1746
uvc_scan_chain(struct uvc_video_chain * chain,struct uvc_entity * term)1747 static int uvc_scan_chain(struct uvc_video_chain *chain,
1748 struct uvc_entity *term)
1749 {
1750 struct uvc_entity *entity, *prev;
1751
1752 uvc_trace(UVC_TRACE_PROBE, "Scanning UVC chain:");
1753
1754 entity = term;
1755 prev = NULL;
1756
1757 while (entity != NULL) {
1758 /* Entity must not be part of an existing chain */
1759 if (entity->chain.next || entity->chain.prev) {
1760 uvc_trace(UVC_TRACE_DESCR, "Found reference to "
1761 "entity %d already in chain.\n", entity->id);
1762 return -EINVAL;
1763 }
1764
1765 /* Process entity */
1766 if (uvc_scan_chain_entity(chain, entity) < 0)
1767 return -EINVAL;
1768
1769 /* Forward scan */
1770 if (uvc_scan_chain_forward(chain, entity, prev) < 0)
1771 return -EINVAL;
1772
1773 /* Backward scan */
1774 prev = entity;
1775 if (uvc_scan_chain_backward(chain, &entity) < 0)
1776 return -EINVAL;
1777 }
1778
1779 return 0;
1780 }
1781
uvc_print_terms(struct list_head * terms,u16 dir,char * buffer)1782 static unsigned int uvc_print_terms(struct list_head *terms, u16 dir,
1783 char *buffer)
1784 {
1785 struct uvc_entity *term;
1786 unsigned int nterms = 0;
1787 char *p = buffer;
1788
1789 list_for_each_entry(term, terms, chain) {
1790 if (!UVC_ENTITY_IS_TERM(term) ||
1791 UVC_TERM_DIRECTION(term) != dir)
1792 continue;
1793
1794 if (nterms)
1795 p += sprintf(p, ",");
1796 if (++nterms >= 4) {
1797 p += sprintf(p, "...");
1798 break;
1799 }
1800 p += sprintf(p, "%u", term->id);
1801 }
1802
1803 return p - buffer;
1804 }
1805
uvc_print_chain(struct uvc_video_chain * chain)1806 static const char *uvc_print_chain(struct uvc_video_chain *chain)
1807 {
1808 static char buffer[43];
1809 char *p = buffer;
1810
1811 p += uvc_print_terms(&chain->entities, UVC_TERM_INPUT, p);
1812 p += sprintf(p, " -> ");
1813 uvc_print_terms(&chain->entities, UVC_TERM_OUTPUT, p);
1814
1815 return buffer;
1816 }
1817
uvc_alloc_chain(struct uvc_device * dev)1818 static struct uvc_video_chain *uvc_alloc_chain(struct uvc_device *dev)
1819 {
1820 struct uvc_video_chain *chain;
1821
1822 chain = kzalloc(sizeof(*chain), GFP_KERNEL);
1823 if (chain == NULL)
1824 return NULL;
1825
1826 INIT_LIST_HEAD(&chain->entities);
1827 mutex_init(&chain->ctrl_mutex);
1828 chain->dev = dev;
1829 v4l2_prio_init(&chain->prio);
1830
1831 return chain;
1832 }
1833
1834 /*
1835 * Fallback heuristic for devices that don't connect units and terminals in a
1836 * valid chain.
1837 *
1838 * Some devices have invalid baSourceID references, causing uvc_scan_chain()
1839 * to fail, but if we just take the entities we can find and put them together
1840 * in the most sensible chain we can think of, turns out they do work anyway.
1841 * Note: This heuristic assumes there is a single chain.
1842 *
1843 * At the time of writing, devices known to have such a broken chain are
1844 * - Acer Integrated Camera (5986:055a)
1845 * - Realtek rtl157a7 (0bda:57a7)
1846 */
uvc_scan_fallback(struct uvc_device * dev)1847 static int uvc_scan_fallback(struct uvc_device *dev)
1848 {
1849 struct uvc_video_chain *chain;
1850 struct uvc_entity *iterm = NULL;
1851 struct uvc_entity *oterm = NULL;
1852 struct uvc_entity *entity;
1853 struct uvc_entity *prev;
1854
1855 /*
1856 * Start by locating the input and output terminals. We only support
1857 * devices with exactly one of each for now.
1858 */
1859 list_for_each_entry(entity, &dev->entities, list) {
1860 if (UVC_ENTITY_IS_ITERM(entity)) {
1861 if (iterm)
1862 return -EINVAL;
1863 iterm = entity;
1864 }
1865
1866 if (UVC_ENTITY_IS_OTERM(entity)) {
1867 if (oterm)
1868 return -EINVAL;
1869 oterm = entity;
1870 }
1871 }
1872
1873 if (iterm == NULL || oterm == NULL)
1874 return -EINVAL;
1875
1876 /* Allocate the chain and fill it. */
1877 chain = uvc_alloc_chain(dev);
1878 if (chain == NULL)
1879 return -ENOMEM;
1880
1881 if (uvc_scan_chain_entity(chain, oterm) < 0)
1882 goto error;
1883
1884 prev = oterm;
1885
1886 /*
1887 * Add all Processing and Extension Units with two pads. The order
1888 * doesn't matter much, use reverse list traversal to connect units in
1889 * UVC descriptor order as we build the chain from output to input. This
1890 * leads to units appearing in the order meant by the manufacturer for
1891 * the cameras known to require this heuristic.
1892 */
1893 list_for_each_entry_reverse(entity, &dev->entities, list) {
1894 if (entity->type != UVC_VC_PROCESSING_UNIT &&
1895 entity->type != UVC_VC_EXTENSION_UNIT)
1896 continue;
1897
1898 if (entity->num_pads != 2)
1899 continue;
1900
1901 if (uvc_scan_chain_entity(chain, entity) < 0)
1902 goto error;
1903
1904 prev->baSourceID[0] = entity->id;
1905 prev = entity;
1906 }
1907
1908 if (uvc_scan_chain_entity(chain, iterm) < 0)
1909 goto error;
1910
1911 prev->baSourceID[0] = iterm->id;
1912
1913 list_add_tail(&chain->list, &dev->chains);
1914
1915 uvc_trace(UVC_TRACE_PROBE,
1916 "Found a video chain by fallback heuristic (%s).\n",
1917 uvc_print_chain(chain));
1918
1919 return 0;
1920
1921 error:
1922 kfree(chain);
1923 return -EINVAL;
1924 }
1925
1926 /*
1927 * Scan the device for video chains and register video devices.
1928 *
1929 * Chains are scanned starting at their output terminals and walked backwards.
1930 */
uvc_scan_device(struct uvc_device * dev)1931 static int uvc_scan_device(struct uvc_device *dev)
1932 {
1933 struct uvc_video_chain *chain;
1934 struct uvc_entity *term;
1935
1936 list_for_each_entry(term, &dev->entities, list) {
1937 if (!UVC_ENTITY_IS_OTERM(term))
1938 continue;
1939
1940 /* If the terminal is already included in a chain, skip it.
1941 * This can happen for chains that have multiple output
1942 * terminals, where all output terminals beside the first one
1943 * will be inserted in the chain in forward scans.
1944 */
1945 if (term->chain.next || term->chain.prev)
1946 continue;
1947
1948 chain = uvc_alloc_chain(dev);
1949 if (chain == NULL)
1950 return -ENOMEM;
1951
1952 term->flags |= UVC_ENTITY_FLAG_DEFAULT;
1953
1954 if (uvc_scan_chain(chain, term) < 0) {
1955 kfree(chain);
1956 continue;
1957 }
1958
1959 uvc_trace(UVC_TRACE_PROBE, "Found a valid video chain (%s).\n",
1960 uvc_print_chain(chain));
1961
1962 list_add_tail(&chain->list, &dev->chains);
1963 }
1964
1965 if (list_empty(&dev->chains))
1966 uvc_scan_fallback(dev);
1967
1968 if (list_empty(&dev->chains)) {
1969 uvc_printk(KERN_INFO, "No valid video chain found.\n");
1970 return -1;
1971 }
1972
1973 return 0;
1974 }
1975
1976 /* ------------------------------------------------------------------------
1977 * Video device registration and unregistration
1978 */
1979
1980 /*
1981 * Delete the UVC device.
1982 *
1983 * Called by the kernel when the last reference to the uvc_device structure
1984 * is released.
1985 *
1986 * As this function is called after or during disconnect(), all URBs have
1987 * already been cancelled by the USB core. There is no need to kill the
1988 * interrupt URB manually.
1989 */
uvc_delete(struct kref * kref)1990 static void uvc_delete(struct kref *kref)
1991 {
1992 struct uvc_device *dev = container_of(kref, struct uvc_device, ref);
1993 struct list_head *p, *n;
1994
1995 uvc_status_cleanup(dev);
1996 uvc_ctrl_cleanup_device(dev);
1997
1998 usb_put_intf(dev->intf);
1999 usb_put_dev(dev->udev);
2000
2001 #ifdef CONFIG_MEDIA_CONTROLLER
2002 media_device_cleanup(&dev->mdev);
2003 #endif
2004
2005 list_for_each_safe(p, n, &dev->chains) {
2006 struct uvc_video_chain *chain;
2007 chain = list_entry(p, struct uvc_video_chain, list);
2008 kfree(chain);
2009 }
2010
2011 list_for_each_safe(p, n, &dev->entities) {
2012 struct uvc_entity *entity;
2013 entity = list_entry(p, struct uvc_entity, list);
2014 #ifdef CONFIG_MEDIA_CONTROLLER
2015 uvc_mc_cleanup_entity(entity);
2016 #endif
2017 kfree(entity);
2018 }
2019
2020 list_for_each_safe(p, n, &dev->streams) {
2021 struct uvc_streaming *streaming;
2022 streaming = list_entry(p, struct uvc_streaming, list);
2023 usb_driver_release_interface(&uvc_driver.driver,
2024 streaming->intf);
2025 uvc_stream_delete(streaming);
2026 }
2027
2028 kfree(dev);
2029 }
2030
uvc_release(struct video_device * vdev)2031 static void uvc_release(struct video_device *vdev)
2032 {
2033 struct uvc_streaming *stream = video_get_drvdata(vdev);
2034 struct uvc_device *dev = stream->dev;
2035
2036 kref_put(&dev->ref, uvc_delete);
2037 }
2038
2039 /*
2040 * Unregister the video devices.
2041 */
uvc_unregister_video(struct uvc_device * dev)2042 static void uvc_unregister_video(struct uvc_device *dev)
2043 {
2044 struct uvc_streaming *stream;
2045
2046 list_for_each_entry(stream, &dev->streams, list) {
2047 if (!video_is_registered(&stream->vdev))
2048 continue;
2049
2050 video_unregister_device(&stream->vdev);
2051 video_unregister_device(&stream->meta.vdev);
2052
2053 uvc_debugfs_cleanup_stream(stream);
2054 }
2055
2056 uvc_status_unregister(dev);
2057
2058 if (dev->vdev.dev)
2059 v4l2_device_unregister(&dev->vdev);
2060 #ifdef CONFIG_MEDIA_CONTROLLER
2061 if (media_devnode_is_registered(dev->mdev.devnode))
2062 media_device_unregister(&dev->mdev);
2063 #endif
2064 }
2065
uvc_register_video_device(struct uvc_device * dev,struct uvc_streaming * stream,struct video_device * vdev,struct uvc_video_queue * queue,enum v4l2_buf_type type,const struct v4l2_file_operations * fops,const struct v4l2_ioctl_ops * ioctl_ops)2066 int uvc_register_video_device(struct uvc_device *dev,
2067 struct uvc_streaming *stream,
2068 struct video_device *vdev,
2069 struct uvc_video_queue *queue,
2070 enum v4l2_buf_type type,
2071 const struct v4l2_file_operations *fops,
2072 const struct v4l2_ioctl_ops *ioctl_ops)
2073 {
2074 int ret;
2075
2076 /* Initialize the video buffers queue. */
2077 ret = uvc_queue_init(queue, type, !uvc_no_drop_param);
2078 if (ret)
2079 return ret;
2080
2081 /* Register the device with V4L. */
2082
2083 /*
2084 * We already hold a reference to dev->udev. The video device will be
2085 * unregistered before the reference is released, so we don't need to
2086 * get another one.
2087 */
2088 vdev->v4l2_dev = &dev->vdev;
2089 vdev->fops = fops;
2090 vdev->ioctl_ops = ioctl_ops;
2091 vdev->release = uvc_release;
2092 vdev->prio = &stream->chain->prio;
2093 if (type == V4L2_BUF_TYPE_VIDEO_OUTPUT)
2094 vdev->vfl_dir = VFL_DIR_TX;
2095 else
2096 vdev->vfl_dir = VFL_DIR_RX;
2097
2098 switch (type) {
2099 case V4L2_BUF_TYPE_VIDEO_CAPTURE:
2100 default:
2101 vdev->device_caps = V4L2_CAP_VIDEO_CAPTURE | V4L2_CAP_STREAMING;
2102 break;
2103 case V4L2_BUF_TYPE_VIDEO_OUTPUT:
2104 vdev->device_caps = V4L2_CAP_VIDEO_OUTPUT | V4L2_CAP_STREAMING;
2105 break;
2106 case V4L2_BUF_TYPE_META_CAPTURE:
2107 vdev->device_caps = V4L2_CAP_META_CAPTURE | V4L2_CAP_STREAMING;
2108 break;
2109 }
2110
2111 strscpy(vdev->name, dev->name, sizeof(vdev->name));
2112
2113 /*
2114 * Set the driver data before calling video_register_device, otherwise
2115 * the file open() handler might race us.
2116 */
2117 video_set_drvdata(vdev, stream);
2118
2119 ret = video_register_device(vdev, VFL_TYPE_VIDEO, -1);
2120 if (ret < 0) {
2121 uvc_printk(KERN_ERR, "Failed to register %s device (%d).\n",
2122 v4l2_type_names[type], ret);
2123 return ret;
2124 }
2125
2126 kref_get(&dev->ref);
2127 return 0;
2128 }
2129
uvc_register_video(struct uvc_device * dev,struct uvc_streaming * stream)2130 static int uvc_register_video(struct uvc_device *dev,
2131 struct uvc_streaming *stream)
2132 {
2133 int ret;
2134
2135 /* Initialize the streaming interface with default parameters. */
2136 ret = uvc_video_init(stream);
2137 if (ret < 0) {
2138 uvc_printk(KERN_ERR, "Failed to initialize the device (%d).\n",
2139 ret);
2140 return ret;
2141 }
2142
2143 if (stream->type == V4L2_BUF_TYPE_VIDEO_CAPTURE)
2144 stream->chain->caps |= V4L2_CAP_VIDEO_CAPTURE
2145 | V4L2_CAP_META_CAPTURE;
2146 else
2147 stream->chain->caps |= V4L2_CAP_VIDEO_OUTPUT;
2148
2149 uvc_debugfs_init_stream(stream);
2150
2151 /* Register the device with V4L. */
2152 return uvc_register_video_device(dev, stream, &stream->vdev,
2153 &stream->queue, stream->type,
2154 &uvc_fops, &uvc_ioctl_ops);
2155 }
2156
2157 /*
2158 * Register all video devices in all chains.
2159 */
uvc_register_terms(struct uvc_device * dev,struct uvc_video_chain * chain)2160 static int uvc_register_terms(struct uvc_device *dev,
2161 struct uvc_video_chain *chain)
2162 {
2163 struct uvc_streaming *stream;
2164 struct uvc_entity *term;
2165 int ret;
2166
2167 list_for_each_entry(term, &chain->entities, chain) {
2168 if (UVC_ENTITY_TYPE(term) != UVC_TT_STREAMING)
2169 continue;
2170
2171 stream = uvc_stream_by_id(dev, term->id);
2172 if (stream == NULL) {
2173 uvc_printk(KERN_INFO, "No streaming interface found "
2174 "for terminal %u.", term->id);
2175 continue;
2176 }
2177
2178 stream->chain = chain;
2179 ret = uvc_register_video(dev, stream);
2180 if (ret < 0)
2181 return ret;
2182
2183 /* Register a metadata node, but ignore a possible failure,
2184 * complete registration of video nodes anyway.
2185 */
2186 uvc_meta_register(stream);
2187
2188 term->vdev = &stream->vdev;
2189 }
2190
2191 return 0;
2192 }
2193
uvc_register_chains(struct uvc_device * dev)2194 static int uvc_register_chains(struct uvc_device *dev)
2195 {
2196 struct uvc_video_chain *chain;
2197 int ret;
2198
2199 list_for_each_entry(chain, &dev->chains, list) {
2200 ret = uvc_register_terms(dev, chain);
2201 if (ret < 0)
2202 return ret;
2203
2204 #ifdef CONFIG_MEDIA_CONTROLLER
2205 ret = uvc_mc_register_entities(chain);
2206 if (ret < 0)
2207 uvc_printk(KERN_INFO,
2208 "Failed to register entities (%d).\n", ret);
2209 #endif
2210 }
2211
2212 return 0;
2213 }
2214
2215 /* ------------------------------------------------------------------------
2216 * USB probe, disconnect, suspend and resume
2217 */
2218
2219 static const struct uvc_device_info uvc_quirk_none = { 0 };
2220
uvc_probe(struct usb_interface * intf,const struct usb_device_id * id)2221 static int uvc_probe(struct usb_interface *intf,
2222 const struct usb_device_id *id)
2223 {
2224 struct usb_device *udev = interface_to_usbdev(intf);
2225 struct uvc_device *dev;
2226 const struct uvc_device_info *info =
2227 (const struct uvc_device_info *)id->driver_info;
2228 int function;
2229 int ret;
2230
2231 if (id->idVendor && id->idProduct)
2232 uvc_trace(UVC_TRACE_PROBE, "Probing known UVC device %s "
2233 "(%04x:%04x)\n", udev->devpath, id->idVendor,
2234 id->idProduct);
2235 else
2236 uvc_trace(UVC_TRACE_PROBE, "Probing generic UVC device %s\n",
2237 udev->devpath);
2238
2239 /* Allocate memory for the device and initialize it. */
2240 dev = kzalloc(sizeof(*dev), GFP_KERNEL);
2241 if (dev == NULL)
2242 return -ENOMEM;
2243
2244 INIT_LIST_HEAD(&dev->entities);
2245 INIT_LIST_HEAD(&dev->chains);
2246 INIT_LIST_HEAD(&dev->streams);
2247 kref_init(&dev->ref);
2248 atomic_set(&dev->nmappings, 0);
2249 mutex_init(&dev->lock);
2250
2251 dev->udev = usb_get_dev(udev);
2252 dev->intf = usb_get_intf(intf);
2253 dev->intfnum = intf->cur_altsetting->desc.bInterfaceNumber;
2254 dev->info = info ? info : &uvc_quirk_none;
2255 dev->quirks = uvc_quirks_param == -1
2256 ? dev->info->quirks : uvc_quirks_param;
2257
2258 if (udev->product != NULL)
2259 strscpy(dev->name, udev->product, sizeof(dev->name));
2260 else
2261 snprintf(dev->name, sizeof(dev->name),
2262 "UVC Camera (%04x:%04x)",
2263 le16_to_cpu(udev->descriptor.idVendor),
2264 le16_to_cpu(udev->descriptor.idProduct));
2265
2266 /*
2267 * Add iFunction or iInterface to names when available as additional
2268 * distinguishers between interfaces. iFunction is prioritized over
2269 * iInterface which matches Windows behavior at the point of writing.
2270 */
2271 if (intf->intf_assoc && intf->intf_assoc->iFunction != 0)
2272 function = intf->intf_assoc->iFunction;
2273 else
2274 function = intf->cur_altsetting->desc.iInterface;
2275 if (function != 0) {
2276 size_t len;
2277
2278 strlcat(dev->name, ": ", sizeof(dev->name));
2279 len = strlen(dev->name);
2280 usb_string(udev, function, dev->name + len,
2281 sizeof(dev->name) - len);
2282 }
2283
2284 /* Initialize the media device. */
2285 #ifdef CONFIG_MEDIA_CONTROLLER
2286 dev->mdev.dev = &intf->dev;
2287 strscpy(dev->mdev.model, dev->name, sizeof(dev->mdev.model));
2288 if (udev->serial)
2289 strscpy(dev->mdev.serial, udev->serial,
2290 sizeof(dev->mdev.serial));
2291 usb_make_path(udev, dev->mdev.bus_info, sizeof(dev->mdev.bus_info));
2292 dev->mdev.hw_revision = le16_to_cpu(udev->descriptor.bcdDevice);
2293 media_device_init(&dev->mdev);
2294
2295 dev->vdev.mdev = &dev->mdev;
2296 #endif
2297
2298 /* Parse the Video Class control descriptor. */
2299 if (uvc_parse_control(dev) < 0) {
2300 uvc_trace(UVC_TRACE_PROBE, "Unable to parse UVC "
2301 "descriptors.\n");
2302 goto error;
2303 }
2304
2305 uvc_printk(KERN_INFO, "Found UVC %u.%02x device %s (%04x:%04x)\n",
2306 dev->uvc_version >> 8, dev->uvc_version & 0xff,
2307 udev->product ? udev->product : "<unnamed>",
2308 le16_to_cpu(udev->descriptor.idVendor),
2309 le16_to_cpu(udev->descriptor.idProduct));
2310
2311 if (dev->quirks != dev->info->quirks) {
2312 uvc_printk(KERN_INFO, "Forcing device quirks to 0x%x by module "
2313 "parameter for testing purpose.\n", dev->quirks);
2314 uvc_printk(KERN_INFO, "Please report required quirks to the "
2315 "linux-uvc-devel mailing list.\n");
2316 }
2317
2318 /* Register the V4L2 device. */
2319 if (v4l2_device_register(&intf->dev, &dev->vdev) < 0)
2320 goto error;
2321
2322 /* Initialize controls. */
2323 if (uvc_ctrl_init_device(dev) < 0)
2324 goto error;
2325
2326 /* Scan the device for video chains. */
2327 if (uvc_scan_device(dev) < 0)
2328 goto error;
2329
2330 /* Register video device nodes. */
2331 if (uvc_register_chains(dev) < 0)
2332 goto error;
2333
2334 #ifdef CONFIG_MEDIA_CONTROLLER
2335 /* Register the media device node */
2336 if (media_device_register(&dev->mdev) < 0)
2337 goto error;
2338 #endif
2339 /* Save our data pointer in the interface data. */
2340 usb_set_intfdata(intf, dev);
2341
2342 /* Initialize the interrupt URB. */
2343 if ((ret = uvc_status_init(dev)) < 0) {
2344 uvc_printk(KERN_INFO, "Unable to initialize the status "
2345 "endpoint (%d), status interrupt will not be "
2346 "supported.\n", ret);
2347 }
2348
2349 uvc_trace(UVC_TRACE_PROBE, "UVC device initialized.\n");
2350 if (udev->quirks & USB_QUIRK_AUTO_SUSPEND ||
2351 udev->parent->quirks & USB_QUIRK_AUTO_SUSPEND)
2352 uvc_printk(KERN_INFO, "auto-suspend is blacklisted for this device\n");
2353 else
2354 usb_enable_autosuspend(udev);
2355 return 0;
2356
2357 error:
2358 uvc_unregister_video(dev);
2359 kref_put(&dev->ref, uvc_delete);
2360 return -ENODEV;
2361 }
2362
uvc_disconnect(struct usb_interface * intf)2363 static void uvc_disconnect(struct usb_interface *intf)
2364 {
2365 struct uvc_device *dev = usb_get_intfdata(intf);
2366
2367 /* Set the USB interface data to NULL. This can be done outside the
2368 * lock, as there's no other reader.
2369 */
2370 usb_set_intfdata(intf, NULL);
2371
2372 if (intf->cur_altsetting->desc.bInterfaceSubClass ==
2373 UVC_SC_VIDEOSTREAMING)
2374 return;
2375
2376 uvc_unregister_video(dev);
2377 kref_put(&dev->ref, uvc_delete);
2378 }
2379
uvc_suspend(struct usb_interface * intf,pm_message_t message)2380 static int uvc_suspend(struct usb_interface *intf, pm_message_t message)
2381 {
2382 struct uvc_device *dev = usb_get_intfdata(intf);
2383 struct uvc_streaming *stream;
2384
2385 uvc_trace(UVC_TRACE_SUSPEND, "Suspending interface %u\n",
2386 intf->cur_altsetting->desc.bInterfaceNumber);
2387
2388 /* Controls are cached on the fly so they don't need to be saved. */
2389 if (intf->cur_altsetting->desc.bInterfaceSubClass ==
2390 UVC_SC_VIDEOCONTROL) {
2391 mutex_lock(&dev->lock);
2392 if (dev->users)
2393 uvc_status_stop(dev);
2394 mutex_unlock(&dev->lock);
2395 return 0;
2396 }
2397
2398 list_for_each_entry(stream, &dev->streams, list) {
2399 if (stream->intf == intf)
2400 return uvc_video_suspend(stream);
2401 }
2402
2403 uvc_trace(UVC_TRACE_SUSPEND, "Suspend: video streaming USB interface "
2404 "mismatch.\n");
2405 return -EINVAL;
2406 }
2407
__uvc_resume(struct usb_interface * intf,int reset)2408 static int __uvc_resume(struct usb_interface *intf, int reset)
2409 {
2410 struct uvc_device *dev = usb_get_intfdata(intf);
2411 struct uvc_streaming *stream;
2412 int ret = 0;
2413
2414 uvc_trace(UVC_TRACE_SUSPEND, "Resuming interface %u\n",
2415 intf->cur_altsetting->desc.bInterfaceNumber);
2416
2417 if (intf->cur_altsetting->desc.bInterfaceSubClass ==
2418 UVC_SC_VIDEOCONTROL) {
2419 if (reset) {
2420 ret = uvc_ctrl_restore_values(dev);
2421 if (ret < 0)
2422 return ret;
2423 }
2424
2425 mutex_lock(&dev->lock);
2426 if (dev->users)
2427 ret = uvc_status_start(dev, GFP_NOIO);
2428 mutex_unlock(&dev->lock);
2429
2430 return ret;
2431 }
2432
2433 list_for_each_entry(stream, &dev->streams, list) {
2434 if (stream->intf == intf) {
2435 ret = uvc_video_resume(stream, reset);
2436 if (ret < 0)
2437 uvc_queue_streamoff(&stream->queue,
2438 stream->queue.queue.type);
2439 return ret;
2440 }
2441 }
2442
2443 uvc_trace(UVC_TRACE_SUSPEND, "Resume: video streaming USB interface "
2444 "mismatch.\n");
2445 return -EINVAL;
2446 }
2447
uvc_resume(struct usb_interface * intf)2448 static int uvc_resume(struct usb_interface *intf)
2449 {
2450 return __uvc_resume(intf, 0);
2451 }
2452
uvc_reset_resume(struct usb_interface * intf)2453 static int uvc_reset_resume(struct usb_interface *intf)
2454 {
2455 return __uvc_resume(intf, 1);
2456 }
2457
2458 /* ------------------------------------------------------------------------
2459 * Module parameters
2460 */
2461
uvc_clock_param_get(char * buffer,const struct kernel_param * kp)2462 static int uvc_clock_param_get(char *buffer, const struct kernel_param *kp)
2463 {
2464 if (uvc_clock_param == CLOCK_MONOTONIC)
2465 return sprintf(buffer, "CLOCK_MONOTONIC");
2466 else
2467 return sprintf(buffer, "CLOCK_REALTIME");
2468 }
2469
uvc_clock_param_set(const char * val,const struct kernel_param * kp)2470 static int uvc_clock_param_set(const char *val, const struct kernel_param *kp)
2471 {
2472 if (strncasecmp(val, "clock_", strlen("clock_")) == 0)
2473 val += strlen("clock_");
2474
2475 if (strcasecmp(val, "monotonic") == 0)
2476 uvc_clock_param = CLOCK_MONOTONIC;
2477 else if (strcasecmp(val, "realtime") == 0)
2478 uvc_clock_param = CLOCK_REALTIME;
2479 else
2480 return -EINVAL;
2481
2482 return 0;
2483 }
2484
2485 module_param_call(clock, uvc_clock_param_set, uvc_clock_param_get,
2486 &uvc_clock_param, S_IRUGO|S_IWUSR);
2487 MODULE_PARM_DESC(clock, "Video buffers timestamp clock");
2488 module_param_named(hwtimestamps, uvc_hw_timestamps_param, uint, S_IRUGO|S_IWUSR);
2489 MODULE_PARM_DESC(hwtimestamps, "Use hardware timestamps");
2490 module_param_named(nodrop, uvc_no_drop_param, uint, S_IRUGO|S_IWUSR);
2491 MODULE_PARM_DESC(nodrop, "Don't drop incomplete frames");
2492 module_param_named(quirks, uvc_quirks_param, uint, S_IRUGO|S_IWUSR);
2493 MODULE_PARM_DESC(quirks, "Forced device quirks");
2494 module_param_named(trace, uvc_trace_param, uint, S_IRUGO|S_IWUSR);
2495 MODULE_PARM_DESC(trace, "Trace level bitmask");
2496 module_param_named(timeout, uvc_timeout_param, uint, S_IRUGO|S_IWUSR);
2497 MODULE_PARM_DESC(timeout, "Streaming control requests timeout");
2498
2499 /* ------------------------------------------------------------------------
2500 * Driver initialization and cleanup
2501 */
2502
2503 static const struct uvc_device_info uvc_quirk_probe_minmax = {
2504 .quirks = UVC_QUIRK_PROBE_MINMAX,
2505 };
2506
2507 static const struct uvc_device_info uvc_quirk_fix_bandwidth = {
2508 .quirks = UVC_QUIRK_FIX_BANDWIDTH,
2509 };
2510
2511 static const struct uvc_device_info uvc_quirk_probe_def = {
2512 .quirks = UVC_QUIRK_PROBE_DEF,
2513 };
2514
2515 static const struct uvc_device_info uvc_quirk_stream_no_fid = {
2516 .quirks = UVC_QUIRK_STREAM_NO_FID,
2517 };
2518
2519 static const struct uvc_device_info uvc_quirk_force_y8 = {
2520 .quirks = UVC_QUIRK_FORCE_Y8,
2521 };
2522
2523 #define UVC_INFO_QUIRK(q) (kernel_ulong_t)&(struct uvc_device_info){.quirks = q}
2524 #define UVC_INFO_META(m) (kernel_ulong_t)&(struct uvc_device_info) \
2525 {.meta_format = m}
2526
2527 /*
2528 * The Logitech cameras listed below have their interface class set to
2529 * VENDOR_SPEC because they don't announce themselves as UVC devices, even
2530 * though they are compliant.
2531 */
2532 static const struct usb_device_id uvc_ids[] = {
2533 /* LogiLink Wireless Webcam */
2534 { .match_flags = USB_DEVICE_ID_MATCH_DEVICE
2535 | USB_DEVICE_ID_MATCH_INT_INFO,
2536 .idVendor = 0x0416,
2537 .idProduct = 0xa91a,
2538 .bInterfaceClass = USB_CLASS_VIDEO,
2539 .bInterfaceSubClass = 1,
2540 .bInterfaceProtocol = 0,
2541 .driver_info = (kernel_ulong_t)&uvc_quirk_probe_minmax },
2542 /* Genius eFace 2025 */
2543 { .match_flags = USB_DEVICE_ID_MATCH_DEVICE
2544 | USB_DEVICE_ID_MATCH_INT_INFO,
2545 .idVendor = 0x0458,
2546 .idProduct = 0x706e,
2547 .bInterfaceClass = USB_CLASS_VIDEO,
2548 .bInterfaceSubClass = 1,
2549 .bInterfaceProtocol = 0,
2550 .driver_info = (kernel_ulong_t)&uvc_quirk_probe_minmax },
2551 /* Microsoft Lifecam NX-6000 */
2552 { .match_flags = USB_DEVICE_ID_MATCH_DEVICE
2553 | USB_DEVICE_ID_MATCH_INT_INFO,
2554 .idVendor = 0x045e,
2555 .idProduct = 0x00f8,
2556 .bInterfaceClass = USB_CLASS_VIDEO,
2557 .bInterfaceSubClass = 1,
2558 .bInterfaceProtocol = 0,
2559 .driver_info = (kernel_ulong_t)&uvc_quirk_probe_minmax },
2560 /* Microsoft Lifecam NX-3000 */
2561 { .match_flags = USB_DEVICE_ID_MATCH_DEVICE
2562 | USB_DEVICE_ID_MATCH_INT_INFO,
2563 .idVendor = 0x045e,
2564 .idProduct = 0x0721,
2565 .bInterfaceClass = USB_CLASS_VIDEO,
2566 .bInterfaceSubClass = 1,
2567 .bInterfaceProtocol = 0,
2568 .driver_info = (kernel_ulong_t)&uvc_quirk_probe_def },
2569 /* Microsoft Lifecam VX-7000 */
2570 { .match_flags = USB_DEVICE_ID_MATCH_DEVICE
2571 | USB_DEVICE_ID_MATCH_INT_INFO,
2572 .idVendor = 0x045e,
2573 .idProduct = 0x0723,
2574 .bInterfaceClass = USB_CLASS_VIDEO,
2575 .bInterfaceSubClass = 1,
2576 .bInterfaceProtocol = 0,
2577 .driver_info = (kernel_ulong_t)&uvc_quirk_probe_minmax },
2578 /* Logitech Quickcam Fusion */
2579 { .match_flags = USB_DEVICE_ID_MATCH_DEVICE
2580 | USB_DEVICE_ID_MATCH_INT_INFO,
2581 .idVendor = 0x046d,
2582 .idProduct = 0x08c1,
2583 .bInterfaceClass = USB_CLASS_VENDOR_SPEC,
2584 .bInterfaceSubClass = 1,
2585 .bInterfaceProtocol = 0 },
2586 /* Logitech Quickcam Orbit MP */
2587 { .match_flags = USB_DEVICE_ID_MATCH_DEVICE
2588 | USB_DEVICE_ID_MATCH_INT_INFO,
2589 .idVendor = 0x046d,
2590 .idProduct = 0x08c2,
2591 .bInterfaceClass = USB_CLASS_VENDOR_SPEC,
2592 .bInterfaceSubClass = 1,
2593 .bInterfaceProtocol = 0 },
2594 /* Logitech Quickcam Pro for Notebook */
2595 { .match_flags = USB_DEVICE_ID_MATCH_DEVICE
2596 | USB_DEVICE_ID_MATCH_INT_INFO,
2597 .idVendor = 0x046d,
2598 .idProduct = 0x08c3,
2599 .bInterfaceClass = USB_CLASS_VENDOR_SPEC,
2600 .bInterfaceSubClass = 1,
2601 .bInterfaceProtocol = 0 },
2602 /* Logitech Quickcam Pro 5000 */
2603 { .match_flags = USB_DEVICE_ID_MATCH_DEVICE
2604 | USB_DEVICE_ID_MATCH_INT_INFO,
2605 .idVendor = 0x046d,
2606 .idProduct = 0x08c5,
2607 .bInterfaceClass = USB_CLASS_VENDOR_SPEC,
2608 .bInterfaceSubClass = 1,
2609 .bInterfaceProtocol = 0 },
2610 /* Logitech Quickcam OEM Dell Notebook */
2611 { .match_flags = USB_DEVICE_ID_MATCH_DEVICE
2612 | USB_DEVICE_ID_MATCH_INT_INFO,
2613 .idVendor = 0x046d,
2614 .idProduct = 0x08c6,
2615 .bInterfaceClass = USB_CLASS_VENDOR_SPEC,
2616 .bInterfaceSubClass = 1,
2617 .bInterfaceProtocol = 0 },
2618 /* Logitech Quickcam OEM Cisco VT Camera II */
2619 { .match_flags = USB_DEVICE_ID_MATCH_DEVICE
2620 | USB_DEVICE_ID_MATCH_INT_INFO,
2621 .idVendor = 0x046d,
2622 .idProduct = 0x08c7,
2623 .bInterfaceClass = USB_CLASS_VENDOR_SPEC,
2624 .bInterfaceSubClass = 1,
2625 .bInterfaceProtocol = 0 },
2626 /* Logitech HD Pro Webcam C920 */
2627 { .match_flags = USB_DEVICE_ID_MATCH_DEVICE
2628 | USB_DEVICE_ID_MATCH_INT_INFO,
2629 .idVendor = 0x046d,
2630 .idProduct = 0x082d,
2631 .bInterfaceClass = USB_CLASS_VIDEO,
2632 .bInterfaceSubClass = 1,
2633 .bInterfaceProtocol = 0,
2634 .driver_info = UVC_INFO_QUIRK(UVC_QUIRK_RESTORE_CTRLS_ON_INIT) },
2635 /* Chicony CNF7129 (Asus EEE 100HE) */
2636 { .match_flags = USB_DEVICE_ID_MATCH_DEVICE
2637 | USB_DEVICE_ID_MATCH_INT_INFO,
2638 .idVendor = 0x04f2,
2639 .idProduct = 0xb071,
2640 .bInterfaceClass = USB_CLASS_VIDEO,
2641 .bInterfaceSubClass = 1,
2642 .bInterfaceProtocol = 0,
2643 .driver_info = UVC_INFO_QUIRK(UVC_QUIRK_RESTRICT_FRAME_RATE) },
2644 /* Alcor Micro AU3820 (Future Boy PC USB Webcam) */
2645 { .match_flags = USB_DEVICE_ID_MATCH_DEVICE
2646 | USB_DEVICE_ID_MATCH_INT_INFO,
2647 .idVendor = 0x058f,
2648 .idProduct = 0x3820,
2649 .bInterfaceClass = USB_CLASS_VIDEO,
2650 .bInterfaceSubClass = 1,
2651 .bInterfaceProtocol = 0,
2652 .driver_info = (kernel_ulong_t)&uvc_quirk_probe_minmax },
2653 /* Dell XPS m1530 */
2654 { .match_flags = USB_DEVICE_ID_MATCH_DEVICE
2655 | USB_DEVICE_ID_MATCH_INT_INFO,
2656 .idVendor = 0x05a9,
2657 .idProduct = 0x2640,
2658 .bInterfaceClass = USB_CLASS_VIDEO,
2659 .bInterfaceSubClass = 1,
2660 .bInterfaceProtocol = 0,
2661 .driver_info = (kernel_ulong_t)&uvc_quirk_probe_def },
2662 /* Dell SP2008WFP Monitor */
2663 { .match_flags = USB_DEVICE_ID_MATCH_DEVICE
2664 | USB_DEVICE_ID_MATCH_INT_INFO,
2665 .idVendor = 0x05a9,
2666 .idProduct = 0x2641,
2667 .bInterfaceClass = USB_CLASS_VIDEO,
2668 .bInterfaceSubClass = 1,
2669 .bInterfaceProtocol = 0,
2670 .driver_info = (kernel_ulong_t)&uvc_quirk_probe_def },
2671 /* Dell Alienware X51 */
2672 { .match_flags = USB_DEVICE_ID_MATCH_DEVICE
2673 | USB_DEVICE_ID_MATCH_INT_INFO,
2674 .idVendor = 0x05a9,
2675 .idProduct = 0x2643,
2676 .bInterfaceClass = USB_CLASS_VIDEO,
2677 .bInterfaceSubClass = 1,
2678 .bInterfaceProtocol = 0,
2679 .driver_info = (kernel_ulong_t)&uvc_quirk_probe_def },
2680 /* Dell Studio Hybrid 140g (OmniVision webcam) */
2681 { .match_flags = USB_DEVICE_ID_MATCH_DEVICE
2682 | USB_DEVICE_ID_MATCH_INT_INFO,
2683 .idVendor = 0x05a9,
2684 .idProduct = 0x264a,
2685 .bInterfaceClass = USB_CLASS_VIDEO,
2686 .bInterfaceSubClass = 1,
2687 .bInterfaceProtocol = 0,
2688 .driver_info = (kernel_ulong_t)&uvc_quirk_probe_def },
2689 /* Dell XPS M1330 (OmniVision OV7670 webcam) */
2690 { .match_flags = USB_DEVICE_ID_MATCH_DEVICE
2691 | USB_DEVICE_ID_MATCH_INT_INFO,
2692 .idVendor = 0x05a9,
2693 .idProduct = 0x7670,
2694 .bInterfaceClass = USB_CLASS_VIDEO,
2695 .bInterfaceSubClass = 1,
2696 .bInterfaceProtocol = 0,
2697 .driver_info = (kernel_ulong_t)&uvc_quirk_probe_def },
2698 /* Apple Built-In iSight */
2699 { .match_flags = USB_DEVICE_ID_MATCH_DEVICE
2700 | USB_DEVICE_ID_MATCH_INT_INFO,
2701 .idVendor = 0x05ac,
2702 .idProduct = 0x8501,
2703 .bInterfaceClass = USB_CLASS_VIDEO,
2704 .bInterfaceSubClass = 1,
2705 .bInterfaceProtocol = 0,
2706 .driver_info = UVC_INFO_QUIRK(UVC_QUIRK_PROBE_MINMAX
2707 | UVC_QUIRK_BUILTIN_ISIGHT) },
2708 /* Apple Built-In iSight via iBridge */
2709 { .match_flags = USB_DEVICE_ID_MATCH_DEVICE
2710 | USB_DEVICE_ID_MATCH_INT_INFO,
2711 .idVendor = 0x05ac,
2712 .idProduct = 0x8600,
2713 .bInterfaceClass = USB_CLASS_VIDEO,
2714 .bInterfaceSubClass = 1,
2715 .bInterfaceProtocol = 0,
2716 .driver_info = (kernel_ulong_t)&uvc_quirk_probe_def },
2717 /* Foxlink ("HP Webcam" on HP Mini 5103) */
2718 { .match_flags = USB_DEVICE_ID_MATCH_DEVICE
2719 | USB_DEVICE_ID_MATCH_INT_INFO,
2720 .idVendor = 0x05c8,
2721 .idProduct = 0x0403,
2722 .bInterfaceClass = USB_CLASS_VIDEO,
2723 .bInterfaceSubClass = 1,
2724 .bInterfaceProtocol = 0,
2725 .driver_info = (kernel_ulong_t)&uvc_quirk_fix_bandwidth },
2726 /* Genesys Logic USB 2.0 PC Camera */
2727 { .match_flags = USB_DEVICE_ID_MATCH_DEVICE
2728 | USB_DEVICE_ID_MATCH_INT_INFO,
2729 .idVendor = 0x05e3,
2730 .idProduct = 0x0505,
2731 .bInterfaceClass = USB_CLASS_VIDEO,
2732 .bInterfaceSubClass = 1,
2733 .bInterfaceProtocol = 0,
2734 .driver_info = (kernel_ulong_t)&uvc_quirk_stream_no_fid },
2735 /* Hercules Classic Silver */
2736 { .match_flags = USB_DEVICE_ID_MATCH_DEVICE
2737 | USB_DEVICE_ID_MATCH_INT_INFO,
2738 .idVendor = 0x06f8,
2739 .idProduct = 0x300c,
2740 .bInterfaceClass = USB_CLASS_VIDEO,
2741 .bInterfaceSubClass = 1,
2742 .bInterfaceProtocol = 0,
2743 .driver_info = (kernel_ulong_t)&uvc_quirk_fix_bandwidth },
2744 /* ViMicro Vega */
2745 { .match_flags = USB_DEVICE_ID_MATCH_DEVICE
2746 | USB_DEVICE_ID_MATCH_INT_INFO,
2747 .idVendor = 0x0ac8,
2748 .idProduct = 0x332d,
2749 .bInterfaceClass = USB_CLASS_VIDEO,
2750 .bInterfaceSubClass = 1,
2751 .bInterfaceProtocol = 0,
2752 .driver_info = (kernel_ulong_t)&uvc_quirk_fix_bandwidth },
2753 /* ViMicro - Minoru3D */
2754 { .match_flags = USB_DEVICE_ID_MATCH_DEVICE
2755 | USB_DEVICE_ID_MATCH_INT_INFO,
2756 .idVendor = 0x0ac8,
2757 .idProduct = 0x3410,
2758 .bInterfaceClass = USB_CLASS_VIDEO,
2759 .bInterfaceSubClass = 1,
2760 .bInterfaceProtocol = 0,
2761 .driver_info = (kernel_ulong_t)&uvc_quirk_fix_bandwidth },
2762 /* ViMicro Venus - Minoru3D */
2763 { .match_flags = USB_DEVICE_ID_MATCH_DEVICE
2764 | USB_DEVICE_ID_MATCH_INT_INFO,
2765 .idVendor = 0x0ac8,
2766 .idProduct = 0x3420,
2767 .bInterfaceClass = USB_CLASS_VIDEO,
2768 .bInterfaceSubClass = 1,
2769 .bInterfaceProtocol = 0,
2770 .driver_info = (kernel_ulong_t)&uvc_quirk_fix_bandwidth },
2771 /* Ophir Optronics - SPCAM 620U */
2772 { .match_flags = USB_DEVICE_ID_MATCH_DEVICE
2773 | USB_DEVICE_ID_MATCH_INT_INFO,
2774 .idVendor = 0x0bd3,
2775 .idProduct = 0x0555,
2776 .bInterfaceClass = USB_CLASS_VIDEO,
2777 .bInterfaceSubClass = 1,
2778 .bInterfaceProtocol = 0,
2779 .driver_info = (kernel_ulong_t)&uvc_quirk_probe_minmax },
2780 /* MT6227 */
2781 { .match_flags = USB_DEVICE_ID_MATCH_DEVICE
2782 | USB_DEVICE_ID_MATCH_INT_INFO,
2783 .idVendor = 0x0e8d,
2784 .idProduct = 0x0004,
2785 .bInterfaceClass = USB_CLASS_VIDEO,
2786 .bInterfaceSubClass = 1,
2787 .bInterfaceProtocol = 0,
2788 .driver_info = UVC_INFO_QUIRK(UVC_QUIRK_PROBE_MINMAX
2789 | UVC_QUIRK_PROBE_DEF) },
2790 /* IMC Networks (Medion Akoya) */
2791 { .match_flags = USB_DEVICE_ID_MATCH_DEVICE
2792 | USB_DEVICE_ID_MATCH_INT_INFO,
2793 .idVendor = 0x13d3,
2794 .idProduct = 0x5103,
2795 .bInterfaceClass = USB_CLASS_VIDEO,
2796 .bInterfaceSubClass = 1,
2797 .bInterfaceProtocol = 0,
2798 .driver_info = (kernel_ulong_t)&uvc_quirk_stream_no_fid },
2799 /* JMicron USB2.0 XGA WebCam */
2800 { .match_flags = USB_DEVICE_ID_MATCH_DEVICE
2801 | USB_DEVICE_ID_MATCH_INT_INFO,
2802 .idVendor = 0x152d,
2803 .idProduct = 0x0310,
2804 .bInterfaceClass = USB_CLASS_VIDEO,
2805 .bInterfaceSubClass = 1,
2806 .bInterfaceProtocol = 0,
2807 .driver_info = (kernel_ulong_t)&uvc_quirk_probe_minmax },
2808 /* Syntek (HP Spartan) */
2809 { .match_flags = USB_DEVICE_ID_MATCH_DEVICE
2810 | USB_DEVICE_ID_MATCH_INT_INFO,
2811 .idVendor = 0x174f,
2812 .idProduct = 0x5212,
2813 .bInterfaceClass = USB_CLASS_VIDEO,
2814 .bInterfaceSubClass = 1,
2815 .bInterfaceProtocol = 0,
2816 .driver_info = (kernel_ulong_t)&uvc_quirk_stream_no_fid },
2817 /* Syntek (Samsung Q310) */
2818 { .match_flags = USB_DEVICE_ID_MATCH_DEVICE
2819 | USB_DEVICE_ID_MATCH_INT_INFO,
2820 .idVendor = 0x174f,
2821 .idProduct = 0x5931,
2822 .bInterfaceClass = USB_CLASS_VIDEO,
2823 .bInterfaceSubClass = 1,
2824 .bInterfaceProtocol = 0,
2825 .driver_info = (kernel_ulong_t)&uvc_quirk_stream_no_fid },
2826 /* Syntek (Packard Bell EasyNote MX52 */
2827 { .match_flags = USB_DEVICE_ID_MATCH_DEVICE
2828 | USB_DEVICE_ID_MATCH_INT_INFO,
2829 .idVendor = 0x174f,
2830 .idProduct = 0x8a12,
2831 .bInterfaceClass = USB_CLASS_VIDEO,
2832 .bInterfaceSubClass = 1,
2833 .bInterfaceProtocol = 0,
2834 .driver_info = (kernel_ulong_t)&uvc_quirk_stream_no_fid },
2835 /* Syntek (Asus F9SG) */
2836 { .match_flags = USB_DEVICE_ID_MATCH_DEVICE
2837 | USB_DEVICE_ID_MATCH_INT_INFO,
2838 .idVendor = 0x174f,
2839 .idProduct = 0x8a31,
2840 .bInterfaceClass = USB_CLASS_VIDEO,
2841 .bInterfaceSubClass = 1,
2842 .bInterfaceProtocol = 0,
2843 .driver_info = (kernel_ulong_t)&uvc_quirk_stream_no_fid },
2844 /* Syntek (Asus U3S) */
2845 { .match_flags = USB_DEVICE_ID_MATCH_DEVICE
2846 | USB_DEVICE_ID_MATCH_INT_INFO,
2847 .idVendor = 0x174f,
2848 .idProduct = 0x8a33,
2849 .bInterfaceClass = USB_CLASS_VIDEO,
2850 .bInterfaceSubClass = 1,
2851 .bInterfaceProtocol = 0,
2852 .driver_info = (kernel_ulong_t)&uvc_quirk_stream_no_fid },
2853 /* Syntek (JAOtech Smart Terminal) */
2854 { .match_flags = USB_DEVICE_ID_MATCH_DEVICE
2855 | USB_DEVICE_ID_MATCH_INT_INFO,
2856 .idVendor = 0x174f,
2857 .idProduct = 0x8a34,
2858 .bInterfaceClass = USB_CLASS_VIDEO,
2859 .bInterfaceSubClass = 1,
2860 .bInterfaceProtocol = 0,
2861 .driver_info = (kernel_ulong_t)&uvc_quirk_stream_no_fid },
2862 /* Miricle 307K */
2863 { .match_flags = USB_DEVICE_ID_MATCH_DEVICE
2864 | USB_DEVICE_ID_MATCH_INT_INFO,
2865 .idVendor = 0x17dc,
2866 .idProduct = 0x0202,
2867 .bInterfaceClass = USB_CLASS_VIDEO,
2868 .bInterfaceSubClass = 1,
2869 .bInterfaceProtocol = 0,
2870 .driver_info = (kernel_ulong_t)&uvc_quirk_stream_no_fid },
2871 /* Lenovo Thinkpad SL400/SL500 */
2872 { .match_flags = USB_DEVICE_ID_MATCH_DEVICE
2873 | USB_DEVICE_ID_MATCH_INT_INFO,
2874 .idVendor = 0x17ef,
2875 .idProduct = 0x480b,
2876 .bInterfaceClass = USB_CLASS_VIDEO,
2877 .bInterfaceSubClass = 1,
2878 .bInterfaceProtocol = 0,
2879 .driver_info = (kernel_ulong_t)&uvc_quirk_stream_no_fid },
2880 /* Aveo Technology USB 2.0 Camera */
2881 { .match_flags = USB_DEVICE_ID_MATCH_DEVICE
2882 | USB_DEVICE_ID_MATCH_INT_INFO,
2883 .idVendor = 0x1871,
2884 .idProduct = 0x0306,
2885 .bInterfaceClass = USB_CLASS_VIDEO,
2886 .bInterfaceSubClass = 1,
2887 .bInterfaceProtocol = 0,
2888 .driver_info = UVC_INFO_QUIRK(UVC_QUIRK_PROBE_MINMAX
2889 | UVC_QUIRK_PROBE_EXTRAFIELDS) },
2890 /* Aveo Technology USB 2.0 Camera (Tasco USB Microscope) */
2891 { .match_flags = USB_DEVICE_ID_MATCH_DEVICE
2892 | USB_DEVICE_ID_MATCH_INT_INFO,
2893 .idVendor = 0x1871,
2894 .idProduct = 0x0516,
2895 .bInterfaceClass = USB_CLASS_VENDOR_SPEC,
2896 .bInterfaceSubClass = 1,
2897 .bInterfaceProtocol = 0 },
2898 /* Ecamm Pico iMage */
2899 { .match_flags = USB_DEVICE_ID_MATCH_DEVICE
2900 | USB_DEVICE_ID_MATCH_INT_INFO,
2901 .idVendor = 0x18cd,
2902 .idProduct = 0xcafe,
2903 .bInterfaceClass = USB_CLASS_VIDEO,
2904 .bInterfaceSubClass = 1,
2905 .bInterfaceProtocol = 0,
2906 .driver_info = UVC_INFO_QUIRK(UVC_QUIRK_PROBE_EXTRAFIELDS) },
2907 /* Manta MM-353 Plako */
2908 { .match_flags = USB_DEVICE_ID_MATCH_DEVICE
2909 | USB_DEVICE_ID_MATCH_INT_INFO,
2910 .idVendor = 0x18ec,
2911 .idProduct = 0x3188,
2912 .bInterfaceClass = USB_CLASS_VIDEO,
2913 .bInterfaceSubClass = 1,
2914 .bInterfaceProtocol = 0,
2915 .driver_info = (kernel_ulong_t)&uvc_quirk_probe_minmax },
2916 /* FSC WebCam V30S */
2917 { .match_flags = USB_DEVICE_ID_MATCH_DEVICE
2918 | USB_DEVICE_ID_MATCH_INT_INFO,
2919 .idVendor = 0x18ec,
2920 .idProduct = 0x3288,
2921 .bInterfaceClass = USB_CLASS_VIDEO,
2922 .bInterfaceSubClass = 1,
2923 .bInterfaceProtocol = 0,
2924 .driver_info = (kernel_ulong_t)&uvc_quirk_probe_minmax },
2925 /* Arkmicro unbranded */
2926 { .match_flags = USB_DEVICE_ID_MATCH_DEVICE
2927 | USB_DEVICE_ID_MATCH_INT_INFO,
2928 .idVendor = 0x18ec,
2929 .idProduct = 0x3290,
2930 .bInterfaceClass = USB_CLASS_VIDEO,
2931 .bInterfaceSubClass = 1,
2932 .bInterfaceProtocol = 0,
2933 .driver_info = (kernel_ulong_t)&uvc_quirk_probe_def },
2934 /* The Imaging Source USB CCD cameras */
2935 { .match_flags = USB_DEVICE_ID_MATCH_DEVICE
2936 | USB_DEVICE_ID_MATCH_INT_INFO,
2937 .idVendor = 0x199e,
2938 .idProduct = 0x8102,
2939 .bInterfaceClass = USB_CLASS_VENDOR_SPEC,
2940 .bInterfaceSubClass = 1,
2941 .bInterfaceProtocol = 0 },
2942 /* Bodelin ProScopeHR */
2943 { .match_flags = USB_DEVICE_ID_MATCH_DEVICE
2944 | USB_DEVICE_ID_MATCH_DEV_HI
2945 | USB_DEVICE_ID_MATCH_INT_INFO,
2946 .idVendor = 0x19ab,
2947 .idProduct = 0x1000,
2948 .bcdDevice_hi = 0x0126,
2949 .bInterfaceClass = USB_CLASS_VIDEO,
2950 .bInterfaceSubClass = 1,
2951 .bInterfaceProtocol = 0,
2952 .driver_info = UVC_INFO_QUIRK(UVC_QUIRK_STATUS_INTERVAL) },
2953 /* MSI StarCam 370i */
2954 { .match_flags = USB_DEVICE_ID_MATCH_DEVICE
2955 | USB_DEVICE_ID_MATCH_INT_INFO,
2956 .idVendor = 0x1b3b,
2957 .idProduct = 0x2951,
2958 .bInterfaceClass = USB_CLASS_VIDEO,
2959 .bInterfaceSubClass = 1,
2960 .bInterfaceProtocol = 0,
2961 .driver_info = (kernel_ulong_t)&uvc_quirk_probe_minmax },
2962 /* Generalplus Technology Inc. 808 Camera */
2963 { .match_flags = USB_DEVICE_ID_MATCH_DEVICE
2964 | USB_DEVICE_ID_MATCH_INT_INFO,
2965 .idVendor = 0x1b3f,
2966 .idProduct = 0x2002,
2967 .bInterfaceClass = USB_CLASS_VIDEO,
2968 .bInterfaceSubClass = 1,
2969 .bInterfaceProtocol = 0,
2970 .driver_info = (kernel_ulong_t)&uvc_quirk_probe_minmax },
2971 /* SiGma Micro USB Web Camera */
2972 { .match_flags = USB_DEVICE_ID_MATCH_DEVICE
2973 | USB_DEVICE_ID_MATCH_INT_INFO,
2974 .idVendor = 0x1c4f,
2975 .idProduct = 0x3000,
2976 .bInterfaceClass = USB_CLASS_VIDEO,
2977 .bInterfaceSubClass = 1,
2978 .bInterfaceProtocol = 0,
2979 .driver_info = UVC_INFO_QUIRK(UVC_QUIRK_PROBE_MINMAX
2980 | UVC_QUIRK_IGNORE_SELECTOR_UNIT) },
2981 /* Oculus VR Positional Tracker DK2 */
2982 { .match_flags = USB_DEVICE_ID_MATCH_DEVICE
2983 | USB_DEVICE_ID_MATCH_INT_INFO,
2984 .idVendor = 0x2833,
2985 .idProduct = 0x0201,
2986 .bInterfaceClass = USB_CLASS_VIDEO,
2987 .bInterfaceSubClass = 1,
2988 .bInterfaceProtocol = 0,
2989 .driver_info = (kernel_ulong_t)&uvc_quirk_force_y8 },
2990 /* Oculus VR Rift Sensor */
2991 { .match_flags = USB_DEVICE_ID_MATCH_DEVICE
2992 | USB_DEVICE_ID_MATCH_INT_INFO,
2993 .idVendor = 0x2833,
2994 .idProduct = 0x0211,
2995 .bInterfaceClass = USB_CLASS_VENDOR_SPEC,
2996 .bInterfaceSubClass = 1,
2997 .bInterfaceProtocol = 0,
2998 .driver_info = (kernel_ulong_t)&uvc_quirk_force_y8 },
2999 /* GEO Semiconductor GC6500 */
3000 { .match_flags = USB_DEVICE_ID_MATCH_DEVICE
3001 | USB_DEVICE_ID_MATCH_INT_INFO,
3002 .idVendor = 0x29fe,
3003 .idProduct = 0x4d53,
3004 .bInterfaceClass = USB_CLASS_VIDEO,
3005 .bInterfaceSubClass = 1,
3006 .bInterfaceProtocol = 0,
3007 .driver_info = UVC_INFO_QUIRK(UVC_QUIRK_FORCE_BPP) },
3008 /* Intel RealSense D4M */
3009 { .match_flags = USB_DEVICE_ID_MATCH_DEVICE
3010 | USB_DEVICE_ID_MATCH_INT_INFO,
3011 .idVendor = 0x8086,
3012 .idProduct = 0x0b03,
3013 .bInterfaceClass = USB_CLASS_VIDEO,
3014 .bInterfaceSubClass = 1,
3015 .bInterfaceProtocol = 0,
3016 .driver_info = UVC_INFO_META(V4L2_META_FMT_D4XX) },
3017 /* Generic USB Video Class */
3018 { USB_INTERFACE_INFO(USB_CLASS_VIDEO, 1, UVC_PC_PROTOCOL_UNDEFINED) },
3019 { USB_INTERFACE_INFO(USB_CLASS_VIDEO, 1, UVC_PC_PROTOCOL_15) },
3020 {}
3021 };
3022
3023 MODULE_DEVICE_TABLE(usb, uvc_ids);
3024
3025 struct uvc_driver uvc_driver = {
3026 .driver = {
3027 .name = "uvcvideo",
3028 .probe = uvc_probe,
3029 .disconnect = uvc_disconnect,
3030 .suspend = uvc_suspend,
3031 .resume = uvc_resume,
3032 .reset_resume = uvc_reset_resume,
3033 .id_table = uvc_ids,
3034 .supports_autosuspend = 1,
3035 },
3036 };
3037
uvc_init(void)3038 static int __init uvc_init(void)
3039 {
3040 int ret;
3041
3042 uvc_debugfs_init();
3043
3044 ret = usb_register(&uvc_driver.driver);
3045 if (ret < 0) {
3046 uvc_debugfs_cleanup();
3047 return ret;
3048 }
3049
3050 printk(KERN_INFO DRIVER_DESC " (" DRIVER_VERSION ")\n");
3051 return 0;
3052 }
3053
uvc_cleanup(void)3054 static void __exit uvc_cleanup(void)
3055 {
3056 usb_deregister(&uvc_driver.driver);
3057 uvc_debugfs_cleanup();
3058 }
3059
3060 module_init(uvc_init);
3061 module_exit(uvc_cleanup);
3062
3063 MODULE_AUTHOR(DRIVER_AUTHOR);
3064 MODULE_DESCRIPTION(DRIVER_DESC);
3065 MODULE_LICENSE("GPL");
3066 MODULE_VERSION(DRIVER_VERSION);
3067
3068