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