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