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