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