projects / GitHub / mt8127 / android_kernel_alcatel_ttab.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
Merge branch 'v4l_for_linus' of git://git.kernel.org/pub/scm/linux/kernel/git/mchehab...
[GitHub/mt8127/android_kernel_alcatel_ttab.git] / drivers / media / video / uvc / uvc_driver.c
CommitLineData
c0efd232
LP		 1/*
2 * uvc_driver.c -- USB Video Class driver
3 *
11fc5baf
LP		 4 * Copyright (C) 2005-2010
5 * Laurent Pinchart (laurent.pinchart@ideasonboard.com)
c0efd232
LP		 6 *
7 * This program is free software; you can redistribute it and/or modify
8 * it under the terms of the GNU General Public License as published by
9 * the Free Software Foundation; either version 2 of the License, or
10 * (at your option) any later version.
11 *
12 */
13
14/*
ff924203
LP		 15 * This driver aims to support video input and ouput devices compliant with the
16 * 'USB Video Class' specification.
c0efd232
LP		 17 *
18 * The driver doesn't support the deprecated v4l1 interface. It implements the
19 * mmap capture method only, and doesn't do any image format conversion in
20 * software. If your user-space application doesn't support YUYV or MJPEG, fix
21 * it :-). Please note that the MJPEG data have been stripped from their
22 * Huffman tables (DHT marker), you will need to add it back if your JPEG
23 * codec can't handle MJPEG data.
24 */
25
26#include <linux/kernel.h>
c0efd232
LP		 27#include <linux/list.h>
28#include <linux/module.h>
5a0e3ad6 29#include <linux/slab.h>
c0efd232
LP		 30#include <linux/usb.h>
31#include <linux/videodev2.h>
32#include <linux/vmalloc.h>
33#include <linux/wait.h>
34#include <asm/atomic.h>
9bc6218d 35#include <asm/unaligned.h>
c0efd232
LP		 36
37#include <media/v4l2-common.h>
38
39#include "uvcvideo.h"
40
11fc5baf
LP		 41#define DRIVER_AUTHOR "Laurent Pinchart " \
42 "<laurent.pinchart@ideasonboard.com>"
c0efd232 43#define DRIVER_DESC "USB Video Class driver"
c0efd232 44
310fe524 45unsigned int uvc_clock_param = CLOCK_MONOTONIC;
0fbd8ee6 46unsigned int uvc_no_drop_param;
73de3592 47static unsigned int uvc_quirks_param = -1;
c0efd232 48unsigned int uvc_trace_param;
b232a012 49unsigned int uvc_timeout_param = UVC_CTRL_STREAMING_TIMEOUT;
c0efd232
LP		 50
51/* ------------------------------------------------------------------------
2c2d264b 52 * Video formats
c0efd232
LP		 53 */
54
55static struct uvc_format_desc uvc_fmts[] = {
56 {
57 .name = "YUV 4:2:2 (YUYV)",
58 .guid = UVC_GUID_FORMAT_YUY2,
59 .fcc = V4L2_PIX_FMT_YUYV,
60 },
68f194e0
DR		 61 {
62 .name = "YUV 4:2:2 (YUYV)",
63 .guid = UVC_GUID_FORMAT_YUY2_ISIGHT,
64 .fcc = V4L2_PIX_FMT_YUYV,
65 },
c0efd232
LP		 66 {
67 .name = "YUV 4:2:0 (NV12)",
68 .guid = UVC_GUID_FORMAT_NV12,
69 .fcc = V4L2_PIX_FMT_NV12,
70 },
71 {
72 .name = "MJPEG",
73 .guid = UVC_GUID_FORMAT_MJPEG,
74 .fcc = V4L2_PIX_FMT_MJPEG,
75 },
76 {
77 .name = "YVU 4:2:0 (YV12)",
78 .guid = UVC_GUID_FORMAT_YV12,
79 .fcc = V4L2_PIX_FMT_YVU420,
80 },
81 {
82 .name = "YUV 4:2:0 (I420)",
83 .guid = UVC_GUID_FORMAT_I420,
84 .fcc = V4L2_PIX_FMT_YUV420,
85 },
7225a1dc
HG		 86 {
87 .name = "YUV 4:2:0 (M420)",
88 .guid = UVC_GUID_FORMAT_M420,
89 .fcc = V4L2_PIX_FMT_M420,
90 },
c0efd232
LP		 91 {
92 .name = "YUV 4:2:2 (UYVY)",
93 .guid = UVC_GUID_FORMAT_UYVY,
94 .fcc = V4L2_PIX_FMT_UYVY,
95 },
96 {
61421206 97 .name = "Greyscale (8-bit)",
c0efd232
LP		 98 .guid = UVC_GUID_FORMAT_Y800,
99 .fcc = V4L2_PIX_FMT_GREY,
100 },
61421206
LP		 101 {
102 .name = "Greyscale (16-bit)",
103 .guid = UVC_GUID_FORMAT_Y16,
104 .fcc = V4L2_PIX_FMT_Y16,
105 },
c0efd232
LP		 106 {
107 .name = "RGB Bayer",
108 .guid = UVC_GUID_FORMAT_BY8,
109 .fcc = V4L2_PIX_FMT_SBGGR8,
110 },
50791079
LP		 111 {
112 .name = "RGB565",
113 .guid = UVC_GUID_FORMAT_RGBP,
114 .fcc = V4L2_PIX_FMT_RGB565,
115 },
c0efd232
LP		 116};
117
118/* ------------------------------------------------------------------------
119 * Utility functions
120 */
121
122struct usb_host_endpoint *uvc_find_endpoint(struct usb_host_interface *alts,
123 __u8 epaddr)
124{
125 struct usb_host_endpoint *ep;
126 unsigned int i;
127
128 for (i = 0; i < alts->desc.bNumEndpoints; ++i) {
129 ep = &alts->endpoint[i];
130 if (ep->desc.bEndpointAddress == epaddr)
131 return ep;
132 }
133
134 return NULL;
135}
136
137static struct uvc_format_desc *uvc_format_by_guid(const __u8 guid[16])
138{
139 unsigned int len = ARRAY_SIZE(uvc_fmts);
140 unsigned int i;
141
142 for (i = 0; i < len; ++i) {
143 if (memcmp(guid, uvc_fmts[i].guid, 16) == 0)
144 return &uvc_fmts[i];
145 }
146
147 return NULL;
148}
149
150static __u32 uvc_colorspace(const __u8 primaries)
151{
152 static const __u8 colorprimaries[] = {
153 0,
154 V4L2_COLORSPACE_SRGB,
155 V4L2_COLORSPACE_470_SYSTEM_M,
156 V4L2_COLORSPACE_470_SYSTEM_BG,
157 V4L2_COLORSPACE_SMPTE170M,
158 V4L2_COLORSPACE_SMPTE240M,
159 };
160
161 if (primaries < ARRAY_SIZE(colorprimaries))
162 return colorprimaries[primaries];
163
164 return 0;
165}
166
167/* Simplify a fraction using a simple continued fraction decomposition. The
168 * idea here is to convert fractions such as 333333/10000000 to 1/30 using
169 * 32 bit arithmetic only. The algorithm is not perfect and relies upon two
170 * arbitrary parameters to remove non-significative terms from the simple
171 * continued fraction decomposition. Using 8 and 333 for n_terms and threshold
172 * respectively seems to give nice results.
173 */
174void uvc_simplify_fraction(uint32_t *numerator, uint32_t *denominator,
175 unsigned int n_terms, unsigned int threshold)
176{
177 uint32_t *an;
178 uint32_t x, y, r;
179 unsigned int i, n;
180
181 an = kmalloc(n_terms * sizeof *an, GFP_KERNEL);
182 if (an == NULL)
183 return;
184
185 /* Convert the fraction to a simple continued fraction. See
186 * http://mathforum.org/dr.math/faq/faq.fractions.html
187 * Stop if the current term is bigger than or equal to the given
188 * threshold.
189 */
190 x = *numerator;
191 y = *denominator;
192
193 for (n = 0; n < n_terms && y != 0; ++n) {
194 an[n] = x / y;
195 if (an[n] >= threshold) {
196 if (n < 2)
197 n++;
198 break;
199 }
200
201 r = x - an[n] * y;
202 x = y;
203 y = r;
204 }
205
206 /* Expand the simple continued fraction back to an integer fraction. */
207 x = 0;
208 y = 1;
209
210 for (i = n; i > 0; --i) {
211 r = y;
212 y = an[i-1] * y + x;
213 x = r;
214 }
215
216 *numerator = y;
217 *denominator = x;
218 kfree(an);
219}
220
221/* Convert a fraction to a frame interval in 100ns multiples. The idea here is
222 * to compute numerator / denominator * 10000000 using 32 bit fixed point
223 * arithmetic only.
224 */
225uint32_t uvc_fraction_to_interval(uint32_t numerator, uint32_t denominator)
226{
227 uint32_t multiplier;
228
229 /* Saturate the result if the operation would overflow. */
230 if (denominator == 0 ||
231 numerator/denominator >= ((uint32_t)-1)/10000000)
232 return (uint32_t)-1;
233
234 /* Divide both the denominator and the multiplier by two until
235 * numerator * multiplier doesn't overflow. If anyone knows a better
236 * algorithm please let me know.
237 */
238 multiplier = 10000000;
239 while (numerator > ((uint32_t)-1)/multiplier) {
240 multiplier /= 2;
241 denominator /= 2;
242 }
243
244 return denominator ? numerator * multiplier / denominator : 0;
245}
246
247/* ------------------------------------------------------------------------
248 * Terminal and unit management
249 */
250
251static struct uvc_entity *uvc_entity_by_id(struct uvc_device *dev, int id)
252{
253 struct uvc_entity *entity;
254
255 list_for_each_entry(entity, &dev->entities, list) {
256 if (entity->id == id)
257 return entity;
258 }
259
260 return NULL;
261}
262
263static struct uvc_entity *uvc_entity_by_reference(struct uvc_device *dev,
264 int id, struct uvc_entity *entity)
265{
266 unsigned int i;
267
268 if (entity == NULL)
269 entity = list_entry(&dev->entities, struct uvc_entity, list);
270
271 list_for_each_entry_continue(entity, &dev->entities, list) {
8ca5a639
LP		 272 for (i = 0; i < entity->bNrInPins; ++i)
273 if (entity->baSourceID[i] == id)
c0efd232 274 return entity;
c0efd232
LP		 275 }
276
277 return NULL;
278}
279
8e113595
LP		 280static struct uvc_streaming *uvc_stream_by_id(struct uvc_device *dev, int id)
281{
282 struct uvc_streaming *stream;
283
284 list_for_each_entry(stream, &dev->streams, list) {
285 if (stream->header.bTerminalLink == id)
286 return stream;
287 }
288
289 return NULL;
290}
291
c0efd232 292/* ------------------------------------------------------------------------
8e113595 293 * Descriptors parsing
c0efd232
LP		 294 */
295
296static int uvc_parse_format(struct uvc_device *dev,
297 struct uvc_streaming *streaming, struct uvc_format *format,
298 __u32 **intervals, unsigned char *buffer, int buflen)
299{
300 struct usb_interface *intf = streaming->intf;
301 struct usb_host_interface *alts = intf->cur_altsetting;
302 struct uvc_format_desc *fmtdesc;
303 struct uvc_frame *frame;
304 const unsigned char *start = buffer;
305 unsigned int interval;
306 unsigned int i, n;
307 __u8 ftype;
308
309 format->type = buffer[2];
310 format->index = buffer[3];
311
312 switch (buffer[2]) {
b482d923
LP		 313 case UVC_VS_FORMAT_UNCOMPRESSED:
314 case UVC_VS_FORMAT_FRAME_BASED:
315 n = buffer[2] == UVC_VS_FORMAT_UNCOMPRESSED ? 27 : 28;
233548a2 316 if (buflen < n) {
b2d9cc42 317 uvc_trace(UVC_TRACE_DESCR, "device %d videostreaming "
c0efd232
LP		 318 "interface %d FORMAT error\n",
319 dev->udev->devnum,
320 alts->desc.bInterfaceNumber);
321 return -EINVAL;
322 }
323
324 /* Find the format descriptor from its GUID. */
325 fmtdesc = uvc_format_by_guid(&buffer[5]);
326
327 if (fmtdesc != NULL) {
d0ebf307 328 strlcpy(format->name, fmtdesc->name,
c0efd232
LP		 329 sizeof format->name);
330 format->fcc = fmtdesc->fcc;
331 } else {
36bd883e
LP		 332 uvc_printk(KERN_INFO, "Unknown video format %pUl\n",
333 &buffer[5]);
334 snprintf(format->name, sizeof(format->name), "%pUl\n",
335 &buffer[5]);
c0efd232
LP		 336 format->fcc = 0;
337 }
338
339 format->bpp = buffer[21];
b482d923
LP		 340 if (buffer[2] == UVC_VS_FORMAT_UNCOMPRESSED) {
341 ftype = UVC_VS_FRAME_UNCOMPRESSED;
c0efd232 342 } else {
b482d923 343 ftype = UVC_VS_FRAME_FRAME_BASED;
c0efd232
LP		 344 if (buffer[27])
345 format->flags = UVC_FMT_FLAG_COMPRESSED;
346 }
347 break;
348
b482d923 349 case UVC_VS_FORMAT_MJPEG:
c0efd232 350 if (buflen < 11) {
b2d9cc42 351 uvc_trace(UVC_TRACE_DESCR, "device %d videostreaming "
c0efd232
LP		 352 "interface %d FORMAT error\n",
353 dev->udev->devnum,
354 alts->desc.bInterfaceNumber);
355 return -EINVAL;
356 }
357
d0ebf307 358 strlcpy(format->name, "MJPEG", sizeof format->name);
c0efd232
LP		 359 format->fcc = V4L2_PIX_FMT_MJPEG;
360 format->flags = UVC_FMT_FLAG_COMPRESSED;
361 format->bpp = 0;
b482d923 362 ftype = UVC_VS_FRAME_MJPEG;
c0efd232
LP		 363 break;
364
b482d923 365 case UVC_VS_FORMAT_DV:
c0efd232 366 if (buflen < 9) {
b2d9cc42 367 uvc_trace(UVC_TRACE_DESCR, "device %d videostreaming "
c0efd232
LP		 368 "interface %d FORMAT error\n",
369 dev->udev->devnum,
370 alts->desc.bInterfaceNumber);
371 return -EINVAL;
372 }
373
374 switch (buffer[8] & 0x7f) {
375 case 0:
d0ebf307 376 strlcpy(format->name, "SD-DV", sizeof format->name);
c0efd232
LP		 377 break;
378 case 1:
d0ebf307 379 strlcpy(format->name, "SDL-DV", sizeof format->name);
c0efd232
LP		 380 break;
381 case 2:
d0ebf307 382 strlcpy(format->name, "HD-DV", sizeof format->name);
c0efd232
LP		 383 break;
384 default:
b2d9cc42 385 uvc_trace(UVC_TRACE_DESCR, "device %d videostreaming "
c0efd232
LP		 386 "interface %d: unknown DV format %u\n",
387 dev->udev->devnum,
388 alts->desc.bInterfaceNumber, buffer[8]);
389 return -EINVAL;
390 }
391
d0ebf307 392 strlcat(format->name, buffer[8] & (1 << 7) ? " 60Hz" : " 50Hz",
c0efd232
LP		 393 sizeof format->name);
394
395 format->fcc = V4L2_PIX_FMT_DV;
396 format->flags = UVC_FMT_FLAG_COMPRESSED | UVC_FMT_FLAG_STREAM;
397 format->bpp = 0;
398 ftype = 0;
399
400 /* Create a dummy frame descriptor. */
401 frame = &format->frame[0];
402 memset(&format->frame[0], 0, sizeof format->frame[0]);
403 frame->bFrameIntervalType = 1;
404 frame->dwDefaultFrameInterval = 1;
405 frame->dwFrameInterval = *intervals;
406 *(*intervals)++ = 1;
407 format->nframes = 1;
408 break;
409
b482d923
LP		 410 case UVC_VS_FORMAT_MPEG2TS:
411 case UVC_VS_FORMAT_STREAM_BASED:
c0efd232
LP		 412 /* Not supported yet. */
413 default:
b2d9cc42 414 uvc_trace(UVC_TRACE_DESCR, "device %d videostreaming "
c0efd232
LP		 415 "interface %d unsupported format %u\n",
416 dev->udev->devnum, alts->desc.bInterfaceNumber,
417 buffer[2]);
418 return -EINVAL;
419 }
420
421 uvc_trace(UVC_TRACE_DESCR, "Found format %s.\n", format->name);
422
423 buflen -= buffer[0];
424 buffer += buffer[0];
425
426 /* Parse the frame descriptors. Only uncompressed, MJPEG and frame
427 * based formats have frame descriptors.
428 */
c4ed8c66
LP		 429 while (buflen > 2 && buffer[1] == USB_DT_CS_INTERFACE &&
430 buffer[2] == ftype) {
078f8947 431 frame = &format->frame[format->nframes];
b482d923 432 if (ftype != UVC_VS_FRAME_FRAME_BASED)
c0efd232
LP		 433 n = buflen > 25 ? buffer[25] : 0;
434 else
435 n = buflen > 21 ? buffer[21] : 0;
436
437 n = n ? n : 3;
438
439 if (buflen < 26 + 4*n) {
b2d9cc42 440 uvc_trace(UVC_TRACE_DESCR, "device %d videostreaming "
c0efd232
LP		 441 "interface %d FRAME error\n", dev->udev->devnum,
442 alts->desc.bInterfaceNumber);
443 return -EINVAL;
444 }
445
446 frame->bFrameIndex = buffer[3];
447 frame->bmCapabilities = buffer[4];
9bc6218d
MH		 448 frame->wWidth = get_unaligned_le16(&buffer[5]);
449 frame->wHeight = get_unaligned_le16(&buffer[7]);
450 frame->dwMinBitRate = get_unaligned_le32(&buffer[9]);
451 frame->dwMaxBitRate = get_unaligned_le32(&buffer[13]);
b482d923 452 if (ftype != UVC_VS_FRAME_FRAME_BASED) {
c0efd232 453 frame->dwMaxVideoFrameBufferSize =
9bc6218d 454 get_unaligned_le32(&buffer[17]);
c0efd232 455 frame->dwDefaultFrameInterval =
9bc6218d 456 get_unaligned_le32(&buffer[21]);
c0efd232
LP		 457 frame->bFrameIntervalType = buffer[25];
458 } else {
459 frame->dwMaxVideoFrameBufferSize = 0;
460 frame->dwDefaultFrameInterval =
9bc6218d 461 get_unaligned_le32(&buffer[17]);
c0efd232
LP		 462 frame->bFrameIntervalType = buffer[21];
463 }
464 frame->dwFrameInterval = *intervals;
465
466 /* Several UVC chipsets screw up dwMaxVideoFrameBufferSize
467 * completely. Observed behaviours range from setting the
2c2d264b 468 * value to 1.1x the actual frame size to hardwiring the
c0efd232
LP		 469 * 16 low bits to 0. This results in a higher than necessary
470 * memory usage as well as a wrong image size information. For
471 * uncompressed formats this can be fixed by computing the
472 * value from the frame size.
473 */
474 if (!(format->flags & UVC_FMT_FLAG_COMPRESSED))
475 frame->dwMaxVideoFrameBufferSize = format->bpp
476 * frame->wWidth * frame->wHeight / 8;
477
478 /* Some bogus devices report dwMinFrameInterval equal to
479 * dwMaxFrameInterval and have dwFrameIntervalStep set to
480 * zero. Setting all null intervals to 1 fixes the problem and
2c2d264b 481 * some other divisions by zero that could happen.
c0efd232
LP		 482 */
483 for (i = 0; i < n; ++i) {
9bc6218d 484 interval = get_unaligned_le32(&buffer[26+4*i]);
c0efd232
LP		 485 *(*intervals)++ = interval ? interval : 1;
486 }
487
488 /* Make sure that the default frame interval stays between
489 * the boundaries.
490 */
491 n -= frame->bFrameIntervalType ? 1 : 2;
492 frame->dwDefaultFrameInterval =
493 min(frame->dwFrameInterval[n],
494 max(frame->dwFrameInterval[0],
495 frame->dwDefaultFrameInterval));
496
86d8b6ab
LP		 497 if (dev->quirks & UVC_QUIRK_RESTRICT_FRAME_RATE) {
498 frame->bFrameIntervalType = 1;
499 frame->dwFrameInterval[0] =
500 frame->dwDefaultFrameInterval;
501 }
502
c0efd232
LP		 503 uvc_trace(UVC_TRACE_DESCR, "- %ux%u (%u.%u fps)\n",
504 frame->wWidth, frame->wHeight,
505 10000000/frame->dwDefaultFrameInterval,
506 (100000000/frame->dwDefaultFrameInterval)%10);
507
078f8947 508 format->nframes++;
c0efd232
LP		 509 buflen -= buffer[0];
510 buffer += buffer[0];
511 }
512
c4ed8c66
LP		 513 if (buflen > 2 && buffer[1] == USB_DT_CS_INTERFACE &&
514 buffer[2] == UVC_VS_STILL_IMAGE_FRAME) {
c0efd232
LP		 515 buflen -= buffer[0];
516 buffer += buffer[0];
517 }
518
c4ed8c66
LP		 519 if (buflen > 2 && buffer[1] == USB_DT_CS_INTERFACE &&
520 buffer[2] == UVC_VS_COLORFORMAT) {
c0efd232 521 if (buflen < 6) {
b2d9cc42 522 uvc_trace(UVC_TRACE_DESCR, "device %d videostreaming "
c0efd232
LP		 523 "interface %d COLORFORMAT error\n",
524 dev->udev->devnum,
525 alts->desc.bInterfaceNumber);
526 return -EINVAL;
527 }
528
529 format->colorspace = uvc_colorspace(buffer[3]);
530
531 buflen -= buffer[0];
532 buffer += buffer[0];
533 }
534
535 return buffer - start;
536}
537
538static int uvc_parse_streaming(struct uvc_device *dev,
539 struct usb_interface *intf)
540{
541 struct uvc_streaming *streaming = NULL;
542 struct uvc_format *format;
543 struct uvc_frame *frame;
544 struct usb_host_interface *alts = &intf->altsetting[0];
545 unsigned char *_buffer, *buffer = alts->extra;
546 int _buflen, buflen = alts->extralen;
547 unsigned int nformats = 0, nframes = 0, nintervals = 0;
548 unsigned int size, i, n, p;
549 __u32 *interval;
550 __u16 psize;
551 int ret = -EINVAL;
552
553 if (intf->cur_altsetting->desc.bInterfaceSubClass
b482d923 554 != UVC_SC_VIDEOSTREAMING) {
c0efd232
LP		 555 uvc_trace(UVC_TRACE_DESCR, "device %d interface %d isn't a "
556 "video streaming interface\n", dev->udev->devnum,
557 intf->altsetting[0].desc.bInterfaceNumber);
558 return -EINVAL;
559 }
560
561 if (usb_driver_claim_interface(&uvc_driver.driver, intf, dev)) {
562 uvc_trace(UVC_TRACE_DESCR, "device %d interface %d is already "
563 "claimed\n", dev->udev->devnum,
564 intf->altsetting[0].desc.bInterfaceNumber);
565 return -EINVAL;
566 }
567
568 streaming = kzalloc(sizeof *streaming, GFP_KERNEL);
569 if (streaming == NULL) {
570 usb_driver_release_interface(&uvc_driver.driver, intf);
571 return -EINVAL;
572 }
573
574 mutex_init(&streaming->mutex);
35f02a68 575 streaming->dev = dev;
c0efd232
LP		 576 streaming->intf = usb_get_intf(intf);
577 streaming->intfnum = intf->cur_altsetting->desc.bInterfaceNumber;
578
579 /* The Pico iMage webcam has its class-specific interface descriptors
580 * after the endpoint descriptors.
581 */
582 if (buflen == 0) {
583 for (i = 0; i < alts->desc.bNumEndpoints; ++i) {
584 struct usb_host_endpoint *ep = &alts->endpoint[i];
585
586 if (ep->extralen == 0)
587 continue;
588
589 if (ep->extralen > 2 &&
590 ep->extra[1] == USB_DT_CS_INTERFACE) {
591 uvc_trace(UVC_TRACE_DESCR, "trying extra data "
592 "from endpoint %u.\n", i);
593 buffer = alts->endpoint[i].extra;
594 buflen = alts->endpoint[i].extralen;
595 break;
596 }
597 }
598 }
599
600 /* Skip the standard interface descriptors. */
601 while (buflen > 2 && buffer[1] != USB_DT_CS_INTERFACE) {
602 buflen -= buffer[0];
603 buffer += buffer[0];
604 }
605
606 if (buflen <= 2) {
607 uvc_trace(UVC_TRACE_DESCR, "no class-specific streaming "
608 "interface descriptors found.\n");
609 goto error;
610 }
611
612 /* Parse the header descriptor. */
ff924203 613 switch (buffer[2]) {
b482d923 614 case UVC_VS_OUTPUT_HEADER:
ff924203
LP		 615 streaming->type = V4L2_BUF_TYPE_VIDEO_OUTPUT;
616 size = 9;
617 break;
618
b482d923 619 case UVC_VS_INPUT_HEADER:
ff924203
LP		 620 streaming->type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
621 size = 13;
622 break;
623
624 default:
c0efd232 625 uvc_trace(UVC_TRACE_DESCR, "device %d videostreaming interface "
ff924203
LP		 626 "%d HEADER descriptor not found.\n", dev->udev->devnum,
627 alts->desc.bInterfaceNumber);
c0efd232 628 goto error;
ff924203 629 }
c0efd232 630
ff924203
LP		 631 p = buflen >= 4 ? buffer[3] : 0;
632 n = buflen >= size ? buffer[size-1] : 0;
633
634 if (buflen < size + p*n) {
635 uvc_trace(UVC_TRACE_DESCR, "device %d videostreaming "
636 "interface %d HEADER descriptor is invalid.\n",
637 dev->udev->devnum, alts->desc.bInterfaceNumber);
638 goto error;
639 }
c0efd232 640
ff924203
LP		 641 streaming->header.bNumFormats = p;
642 streaming->header.bEndpointAddress = buffer[6];
b482d923 643 if (buffer[2] == UVC_VS_INPUT_HEADER) {
c0efd232
LP		 644 streaming->header.bmInfo = buffer[7];
645 streaming->header.bTerminalLink = buffer[8];
646 streaming->header.bStillCaptureMethod = buffer[9];
647 streaming->header.bTriggerSupport = buffer[10];
648 streaming->header.bTriggerUsage = buffer[11];
c0efd232 649 } else {
ff924203
LP		 650 streaming->header.bTerminalLink = buffer[7];
651 }
652 streaming->header.bControlSize = n;
653
0b21d55f
JL		 654 streaming->header.bmaControls = kmemdup(&buffer[size], p * n,
655 GFP_KERNEL);
ff924203
LP		 656 if (streaming->header.bmaControls == NULL) {
657 ret = -ENOMEM;
c0efd232
LP		 658 goto error;
659 }
660
661 buflen -= buffer[0];
662 buffer += buffer[0];
663
664 _buffer = buffer;
665 _buflen = buflen;
666
667 /* Count the format and frame descriptors. */
042e143e 668 while (_buflen > 2 && _buffer[1] == USB_DT_CS_INTERFACE) {
c0efd232 669 switch (_buffer[2]) {
b482d923
LP		 670 case UVC_VS_FORMAT_UNCOMPRESSED:
671 case UVC_VS_FORMAT_MJPEG:
672 case UVC_VS_FORMAT_FRAME_BASED:
c0efd232
LP		 673 nformats++;
674 break;
675
b482d923 676 case UVC_VS_FORMAT_DV:
c0efd232
LP		 677 /* DV format has no frame descriptor. We will create a
678 * dummy frame descriptor with a dummy frame interval.
679 */
680 nformats++;
681 nframes++;
682 nintervals++;
683 break;
684
b482d923
LP		 685 case UVC_VS_FORMAT_MPEG2TS:
686 case UVC_VS_FORMAT_STREAM_BASED:
c0efd232
LP		 687 uvc_trace(UVC_TRACE_DESCR, "device %d videostreaming "
688 "interface %d FORMAT %u is not supported.\n",
689 dev->udev->devnum,
690 alts->desc.bInterfaceNumber, _buffer[2]);
691 break;
692
b482d923
LP		 693 case UVC_VS_FRAME_UNCOMPRESSED:
694 case UVC_VS_FRAME_MJPEG:
c0efd232
LP		 695 nframes++;
696 if (_buflen > 25)
697 nintervals += _buffer[25] ? _buffer[25] : 3;
698 break;
699
b482d923 700 case UVC_VS_FRAME_FRAME_BASED:
c0efd232
LP		 701 nframes++;
702 if (_buflen > 21)
703 nintervals += _buffer[21] ? _buffer[21] : 3;
704 break;
705 }
706
707 _buflen -= _buffer[0];
708 _buffer += _buffer[0];
709 }
710
711 if (nformats == 0) {
712 uvc_trace(UVC_TRACE_DESCR, "device %d videostreaming interface "
713 "%d has no supported formats defined.\n",
714 dev->udev->devnum, alts->desc.bInterfaceNumber);
715 goto error;
716 }
717
718 size = nformats * sizeof *format + nframes * sizeof *frame
719 + nintervals * sizeof *interval;
720 format = kzalloc(size, GFP_KERNEL);
721 if (format == NULL) {
722 ret = -ENOMEM;
723 goto error;
724 }
725
726 frame = (struct uvc_frame *)&format[nformats];
727 interval = (__u32 *)&frame[nframes];
728
729 streaming->format = format;
730 streaming->nformats = nformats;
731
732 /* Parse the format descriptors. */
042e143e 733 while (buflen > 2 && buffer[1] == USB_DT_CS_INTERFACE) {
c0efd232 734 switch (buffer[2]) {
b482d923
LP		 735 case UVC_VS_FORMAT_UNCOMPRESSED:
736 case UVC_VS_FORMAT_MJPEG:
737 case UVC_VS_FORMAT_DV:
738 case UVC_VS_FORMAT_FRAME_BASED:
c0efd232
LP		 739 format->frame = frame;
740 ret = uvc_parse_format(dev, streaming, format,
741 &interval, buffer, buflen);
742 if (ret < 0)
743 goto error;
744
745 frame += format->nframes;
746 format++;
747
748 buflen -= ret;
749 buffer += ret;
750 continue;
751
752 default:
753 break;
754 }
755
756 buflen -= buffer[0];
757 buffer += buffer[0];
758 }
759
c4ed8c66
LP		 760 if (buflen)
761 uvc_trace(UVC_TRACE_DESCR, "device %d videostreaming interface "
762 "%d has %u bytes of trailing descriptor garbage.\n",
763 dev->udev->devnum, alts->desc.bInterfaceNumber, buflen);
764
c0efd232
LP		 765 /* Parse the alternate settings to find the maximum bandwidth. */
766 for (i = 0; i < intf->num_altsetting; ++i) {
767 struct usb_host_endpoint *ep;
768 alts = &intf->altsetting[i];
769 ep = uvc_find_endpoint(alts,
770 streaming->header.bEndpointAddress);
771 if (ep == NULL)
772 continue;
773
774 psize = le16_to_cpu(ep->desc.wMaxPacketSize);
775 psize = (psize & 0x07ff) * (1 + ((psize >> 11) & 3));
776 if (psize > streaming->maxpsize)
777 streaming->maxpsize = psize;
778 }
779
35f02a68 780 list_add_tail(&streaming->list, &dev->streams);
c0efd232
LP		 781 return 0;
782
783error:
784 usb_driver_release_interface(&uvc_driver.driver, intf);
785 usb_put_intf(intf);
786 kfree(streaming->format);
787 kfree(streaming->header.bmaControls);
788 kfree(streaming);
789 return ret;
790}
791
8ca5a639
LP		 792static struct uvc_entity *uvc_alloc_entity(u16 type, u8 id,
793 unsigned int num_pads, unsigned int extra_size)
794{
795 struct uvc_entity *entity;
796 unsigned int num_inputs;
797 unsigned int size;
798
799 num_inputs = (type & UVC_TERM_OUTPUT) ? num_pads : num_pads - 1;
800 size = sizeof(*entity) + extra_size + num_inputs;
801 entity = kzalloc(size, GFP_KERNEL);
802 if (entity == NULL)
803 return NULL;
804
805 entity->id = id;
806 entity->type = type;
807
808 entity->bNrInPins = num_inputs;
809 entity->baSourceID = ((__u8 *)entity) + sizeof(*entity) + extra_size;
810
811 return entity;
812}
813
c0efd232
LP		 814/* Parse vendor-specific extensions. */
815static int uvc_parse_vendor_control(struct uvc_device *dev,
816 const unsigned char *buffer, int buflen)
817{
818 struct usb_device *udev = dev->udev;
819 struct usb_host_interface *alts = dev->intf->cur_altsetting;
820 struct uvc_entity *unit;
821 unsigned int n, p;
822 int handled = 0;
823
824 switch (le16_to_cpu(dev->udev->descriptor.idVendor)) {
825 case 0x046d: /* Logitech */
826 if (buffer[1] != 0x41 || buffer[2] != 0x01)
827 break;
828
829 /* Logitech implements several vendor specific functions
830 * through vendor specific extension units (LXU).
831 *
832 * The LXU descriptors are similar to XU descriptors
833 * (see "USB Device Video Class for Video Devices", section
834 * 3.7.2.6 "Extension Unit Descriptor") with the following
835 * differences:
836 *
837 * ----------------------------------------------------------
838 * 0 bLength 1 Number
839 * Size of this descriptor, in bytes: 24+p+n*2
840 * ----------------------------------------------------------
841 * 23+p+n bmControlsType N Bitmap
842 * Individual bits in the set are defined:
843 * 0: Absolute
844 * 1: Relative
845 *
846 * This bitset is mapped exactly the same as bmControls.
847 * ----------------------------------------------------------
848 * 23+p+n*2 bReserved 1 Boolean
849 * ----------------------------------------------------------
850 * 24+p+n*2 iExtension 1 Index
851 * Index of a string descriptor that describes this
852 * extension unit.
853 * ----------------------------------------------------------
854 */
855 p = buflen >= 22 ? buffer[21] : 0;
856 n = buflen >= 25 + p ? buffer[22+p] : 0;
857
858 if (buflen < 25 + p + 2*n) {
859 uvc_trace(UVC_TRACE_DESCR, "device %d videocontrol "
860 "interface %d EXTENSION_UNIT error\n",
861 udev->devnum, alts->desc.bInterfaceNumber);
862 break;
863 }
864
8ca5a639
LP		 865 unit = uvc_alloc_entity(UVC_VC_EXTENSION_UNIT, buffer[3],
866 p + 1, 2*n);
c0efd232
LP		 867 if (unit == NULL)
868 return -ENOMEM;
869
c0efd232
LP		 870 memcpy(unit->extension.guidExtensionCode, &buffer[4], 16);
871 unit->extension.bNumControls = buffer[20];
8ca5a639 872 memcpy(unit->baSourceID, &buffer[22], p);
c0efd232 873 unit->extension.bControlSize = buffer[22+p];
8ca5a639
LP		 874 unit->extension.bmControls = (__u8 *)unit + sizeof(*unit);
875 unit->extension.bmControlsType = (__u8 *)unit + sizeof(*unit)
876 + n;
c0efd232
LP		 877 memcpy(unit->extension.bmControls, &buffer[23+p], 2*n);
878
879 if (buffer[24+p+2*n] != 0)
880 usb_string(udev, buffer[24+p+2*n], unit->name,
881 sizeof unit->name);
882 else
883 sprintf(unit->name, "Extension %u", buffer[3]);
884
885 list_add_tail(&unit->list, &dev->entities);
886 handled = 1;
887 break;
888 }
889
890 return handled;
891}
892
893static int uvc_parse_standard_control(struct uvc_device *dev,
894 const unsigned char *buffer, int buflen)
895{
896 struct usb_device *udev = dev->udev;
897 struct uvc_entity *unit, *term;
898 struct usb_interface *intf;
899 struct usb_host_interface *alts = dev->intf->cur_altsetting;
900 unsigned int i, n, p, len;
901 __u16 type;
902
903 switch (buffer[2]) {
b482d923 904 case UVC_VC_HEADER:
c0efd232
LP		 905 n = buflen >= 12 ? buffer[11] : 0;
906
907 if (buflen < 12 || buflen < 12 + n) {
908 uvc_trace(UVC_TRACE_DESCR, "device %d videocontrol "
909 "interface %d HEADER error\n", udev->devnum,
910 alts->desc.bInterfaceNumber);
911 return -EINVAL;
912 }
913
9bc6218d
MH		 914 dev->uvc_version = get_unaligned_le16(&buffer[3]);
915 dev->clock_frequency = get_unaligned_le32(&buffer[7]);
c0efd232
LP		 916
917 /* Parse all USB Video Streaming interfaces. */
918 for (i = 0; i < n; ++i) {
919 intf = usb_ifnum_to_if(udev, buffer[12+i]);
920 if (intf == NULL) {
921 uvc_trace(UVC_TRACE_DESCR, "device %d "
922 "interface %d doesn't exists\n",
923 udev->devnum, i);
924 continue;
925 }
926
927 uvc_parse_streaming(dev, intf);
928 }
929 break;
930
b482d923 931 case UVC_VC_INPUT_TERMINAL:
c0efd232
LP		 932 if (buflen < 8) {
933 uvc_trace(UVC_TRACE_DESCR, "device %d videocontrol "
934 "interface %d INPUT_TERMINAL error\n",
935 udev->devnum, alts->desc.bInterfaceNumber);
936 return -EINVAL;
937 }
938
939 /* Make sure the terminal type MSB is not null, otherwise it
940 * could be confused with a unit.
941 */
9bc6218d 942 type = get_unaligned_le16(&buffer[4]);
c0efd232
LP		 943 if ((type & 0xff00) == 0) {
944 uvc_trace(UVC_TRACE_DESCR, "device %d videocontrol "
945 "interface %d INPUT_TERMINAL %d has invalid "
946 "type 0x%04x, skipping\n", udev->devnum,
947 alts->desc.bInterfaceNumber,
948 buffer[3], type);
949 return 0;
950 }
951
952 n = 0;
953 p = 0;
954 len = 8;
955
b482d923 956 if (type == UVC_ITT_CAMERA) {
c0efd232
LP		 957 n = buflen >= 15 ? buffer[14] : 0;
958 len = 15;
959
b482d923 960 } else if (type == UVC_ITT_MEDIA_TRANSPORT_INPUT) {
c0efd232
LP		 961 n = buflen >= 9 ? buffer[8] : 0;
962 p = buflen >= 10 + n ? buffer[9+n] : 0;
963 len = 10;
964 }
965
966 if (buflen < len + n + p) {
967 uvc_trace(UVC_TRACE_DESCR, "device %d videocontrol "
968 "interface %d INPUT_TERMINAL error\n",
969 udev->devnum, alts->desc.bInterfaceNumber);
970 return -EINVAL;
971 }
972
8ca5a639
LP		 973 term = uvc_alloc_entity(type | UVC_TERM_INPUT, buffer[3],
974 1, n + p);
c0efd232
LP		 975 if (term == NULL)
976 return -ENOMEM;
977
b482d923 978 if (UVC_ENTITY_TYPE(term) == UVC_ITT_CAMERA) {
c0efd232
LP		 979 term->camera.bControlSize = n;
980 term->camera.bmControls = (__u8 *)term + sizeof *term;
981 term->camera.wObjectiveFocalLengthMin =
9bc6218d 982 get_unaligned_le16(&buffer[8]);
c0efd232 983 term->camera.wObjectiveFocalLengthMax =
9bc6218d 984 get_unaligned_le16(&buffer[10]);
c0efd232 985 term->camera.wOcularFocalLength =
9bc6218d 986 get_unaligned_le16(&buffer[12]);
c0efd232 987 memcpy(term->camera.bmControls, &buffer[15], n);
b482d923
LP		 988 } else if (UVC_ENTITY_TYPE(term) ==
989 UVC_ITT_MEDIA_TRANSPORT_INPUT) {
c0efd232
LP		 990 term->media.bControlSize = n;
991 term->media.bmControls = (__u8 *)term + sizeof *term;
992 term->media.bTransportModeSize = p;
993 term->media.bmTransportModes = (__u8 *)term
994 + sizeof *term + n;
995 memcpy(term->media.bmControls, &buffer[9], n);
996 memcpy(term->media.bmTransportModes, &buffer[10+n], p);
997 }
998
999 if (buffer[7] != 0)
1000 usb_string(udev, buffer[7], term->name,
1001 sizeof term->name);
b482d923 1002 else if (UVC_ENTITY_TYPE(term) == UVC_ITT_CAMERA)
c0efd232 1003 sprintf(term->name, "Camera %u", buffer[3]);
b482d923 1004 else if (UVC_ENTITY_TYPE(term) == UVC_ITT_MEDIA_TRANSPORT_INPUT)
c0efd232
LP		 1005 sprintf(term->name, "Media %u", buffer[3]);
1006 else
1007 sprintf(term->name, "Input %u", buffer[3]);
1008
1009 list_add_tail(&term->list, &dev->entities);
1010 break;
1011
b482d923 1012 case UVC_VC_OUTPUT_TERMINAL:
c0efd232
LP		 1013 if (buflen < 9) {
1014 uvc_trace(UVC_TRACE_DESCR, "device %d videocontrol "
1015 "interface %d OUTPUT_TERMINAL error\n",
1016 udev->devnum, alts->desc.bInterfaceNumber);
1017 return -EINVAL;
1018 }
1019
1020 /* Make sure the terminal type MSB is not null, otherwise it
1021 * could be confused with a unit.
1022 */
9bc6218d 1023 type = get_unaligned_le16(&buffer[4]);
c0efd232
LP		 1024 if ((type & 0xff00) == 0) {
1025 uvc_trace(UVC_TRACE_DESCR, "device %d videocontrol "
1026 "interface %d OUTPUT_TERMINAL %d has invalid "
1027 "type 0x%04x, skipping\n", udev->devnum,
1028 alts->desc.bInterfaceNumber, buffer[3], type);
1029 return 0;
1030 }
1031
8ca5a639
LP		 1032 term = uvc_alloc_entity(type | UVC_TERM_OUTPUT, buffer[3],
1033 1, 0);
c0efd232
LP		 1034 if (term == NULL)
1035 return -ENOMEM;
1036
8ca5a639 1037 memcpy(term->baSourceID, &buffer[7], 1);
c0efd232
LP		 1038
1039 if (buffer[8] != 0)
1040 usb_string(udev, buffer[8], term->name,
1041 sizeof term->name);
1042 else
1043 sprintf(term->name, "Output %u", buffer[3]);
1044
1045 list_add_tail(&term->list, &dev->entities);
1046 break;
1047
b482d923 1048 case UVC_VC_SELECTOR_UNIT:
c0efd232
LP		 1049 p = buflen >= 5 ? buffer[4] : 0;
1050
1051 if (buflen < 5 || buflen < 6 + p) {
1052 uvc_trace(UVC_TRACE_DESCR, "device %d videocontrol "
1053 "interface %d SELECTOR_UNIT error\n",
1054 udev->devnum, alts->desc.bInterfaceNumber);
1055 return -EINVAL;
1056 }
1057
8ca5a639 1058 unit = uvc_alloc_entity(buffer[2], buffer[3], p + 1, 0);
c0efd232
LP		 1059 if (unit == NULL)
1060 return -ENOMEM;
1061
8ca5a639 1062 memcpy(unit->baSourceID, &buffer[5], p);
c0efd232
LP		 1063
1064 if (buffer[5+p] != 0)
1065 usb_string(udev, buffer[5+p], unit->name,
1066 sizeof unit->name);
1067 else
1068 sprintf(unit->name, "Selector %u", buffer[3]);
1069
1070 list_add_tail(&unit->list, &dev->entities);
1071 break;
1072
b482d923 1073 case UVC_VC_PROCESSING_UNIT:
c0efd232
LP		 1074 n = buflen >= 8 ? buffer[7] : 0;
1075 p = dev->uvc_version >= 0x0110 ? 10 : 9;
1076
1077 if (buflen < p + n) {
1078 uvc_trace(UVC_TRACE_DESCR, "device %d videocontrol "
1079 "interface %d PROCESSING_UNIT error\n",
1080 udev->devnum, alts->desc.bInterfaceNumber);
1081 return -EINVAL;
1082 }
1083
8ca5a639 1084 unit = uvc_alloc_entity(buffer[2], buffer[3], 2, n);
c0efd232
LP		 1085 if (unit == NULL)
1086 return -ENOMEM;
1087
8ca5a639 1088 memcpy(unit->baSourceID, &buffer[4], 1);
c0efd232 1089 unit->processing.wMaxMultiplier =
9bc6218d 1090 get_unaligned_le16(&buffer[5]);
c0efd232
LP		 1091 unit->processing.bControlSize = buffer[7];
1092 unit->processing.bmControls = (__u8 *)unit + sizeof *unit;
1093 memcpy(unit->processing.bmControls, &buffer[8], n);
1094 if (dev->uvc_version >= 0x0110)
1095 unit->processing.bmVideoStandards = buffer[9+n];
1096
1097 if (buffer[8+n] != 0)
1098 usb_string(udev, buffer[8+n], unit->name,
1099 sizeof unit->name);
1100 else
1101 sprintf(unit->name, "Processing %u", buffer[3]);
1102
1103 list_add_tail(&unit->list, &dev->entities);
1104 break;
1105
b482d923 1106 case UVC_VC_EXTENSION_UNIT:
c0efd232
LP		 1107 p = buflen >= 22 ? buffer[21] : 0;
1108 n = buflen >= 24 + p ? buffer[22+p] : 0;
1109
1110 if (buflen < 24 + p + n) {
1111 uvc_trace(UVC_TRACE_DESCR, "device %d videocontrol "
1112 "interface %d EXTENSION_UNIT error\n",
1113 udev->devnum, alts->desc.bInterfaceNumber);
1114 return -EINVAL;
1115 }
1116
8ca5a639 1117 unit = uvc_alloc_entity(buffer[2], buffer[3], p + 1, n);
c0efd232
LP		 1118 if (unit == NULL)
1119 return -ENOMEM;
1120
c0efd232
LP		 1121 memcpy(unit->extension.guidExtensionCode, &buffer[4], 16);
1122 unit->extension.bNumControls = buffer[20];
8ca5a639 1123 memcpy(unit->baSourceID, &buffer[22], p);
c0efd232 1124 unit->extension.bControlSize = buffer[22+p];
8ca5a639 1125 unit->extension.bmControls = (__u8 *)unit + sizeof *unit;
c0efd232
LP		 1126 memcpy(unit->extension.bmControls, &buffer[23+p], n);
1127
1128 if (buffer[23+p+n] != 0)
1129 usb_string(udev, buffer[23+p+n], unit->name,
1130 sizeof unit->name);
1131 else
1132 sprintf(unit->name, "Extension %u", buffer[3]);
1133
1134 list_add_tail(&unit->list, &dev->entities);
1135 break;
1136
1137 default:
1138 uvc_trace(UVC_TRACE_DESCR, "Found an unknown CS_INTERFACE "
1139 "descriptor (%u)\n", buffer[2]);
1140 break;
1141 }
1142
1143 return 0;
1144}
1145
1146static int uvc_parse_control(struct uvc_device *dev)
1147{
1148 struct usb_host_interface *alts = dev->intf->cur_altsetting;
1149 unsigned char *buffer = alts->extra;
1150 int buflen = alts->extralen;
1151 int ret;
1152
1153 /* Parse the default alternate setting only, as the UVC specification
1154 * defines a single alternate setting, the default alternate setting
1155 * zero.
1156 */
1157
1158 while (buflen > 2) {
1159 if (uvc_parse_vendor_control(dev, buffer, buflen) ||
1160 buffer[1] != USB_DT_CS_INTERFACE)
1161 goto next_descriptor;
1162
1163 if ((ret = uvc_parse_standard_control(dev, buffer, buflen)) < 0)
1164 return ret;
1165
1166next_descriptor:
1167 buflen -= buffer[0];
1168 buffer += buffer[0];
1169 }
1170
538e7a00
LP		 1171 /* Check if the optional status endpoint is present. Built-in iSight
1172 * webcams have an interrupt endpoint but spit proprietary data that
1173 * don't conform to the UVC status endpoint messages. Don't try to
1174 * handle the interrupt endpoint for those cameras.
1175 */
1176 if (alts->desc.bNumEndpoints == 1 &&
1177 !(dev->quirks & UVC_QUIRK_BUILTIN_ISIGHT)) {
c0efd232
LP		 1178 struct usb_host_endpoint *ep = &alts->endpoint[0];
1179 struct usb_endpoint_descriptor *desc = &ep->desc;
1180
1181 if (usb_endpoint_is_int_in(desc) &&
1182 le16_to_cpu(desc->wMaxPacketSize) >= 8 &&
1183 desc->bInterval != 0) {
1184 uvc_trace(UVC_TRACE_DESCR, "Found a Status endpoint "
1185 "(addr %02x).\n", desc->bEndpointAddress);
1186 dev->int_ep = ep;
1187 }
1188 }
1189
1190 return 0;
1191}
1192
1193/* ------------------------------------------------------------------------
8e113595 1194 * UVC device scan
c0efd232
LP		 1195 */
1196
c0efd232
LP		 1197/*
1198 * Scan the UVC descriptors to locate a chain starting at an Output Terminal
1199 * and containing the following units:
1200 *
8e113595 1201 * - one or more Output Terminals (USB Streaming or Display)
c0efd232 1202 * - zero or one Processing Unit
8e113595 1203 * - zero, one or more single-input Selector Units
c0efd232
LP		 1204 * - zero or one multiple-input Selector Units, provided all inputs are
1205 * connected to input terminals
1206 * - zero, one or mode single-input Extension Units
2c2d264b 1207 * - one or more Input Terminals (Camera, External or USB Streaming)
c0efd232 1208 *
8e113595
LP		 1209 * The terminal and units must match on of the following structures:
1210 *
1211 * ITT_*(0) -> +---------+ +---------+ +---------+ -> TT_STREAMING(0)
1212 * ... | SU{0,1} | -> | PU{0,1} | -> | XU{0,n} | ...
1213 * ITT_*(n) -> +---------+ +---------+ +---------+ -> TT_STREAMING(n)
1214 *
1215 * +---------+ +---------+ -> OTT_*(0)
1216 * TT_STREAMING -> | PU{0,1} | -> | XU{0,n} | ...
1217 * +---------+ +---------+ -> OTT_*(n)
1218 *
1219 * The Processing Unit and Extension Units can be in any order. Additional
1220 * Extension Units connected to the main chain as single-unit branches are
1221 * also supported. Single-input Selector Units are ignored.
c0efd232 1222 */
8e113595 1223static int uvc_scan_chain_entity(struct uvc_video_chain *chain,
c0efd232
LP		 1224 struct uvc_entity *entity)
1225{
1226 switch (UVC_ENTITY_TYPE(entity)) {
b482d923 1227 case UVC_VC_EXTENSION_UNIT:
c0efd232
LP		 1228 if (uvc_trace_param & UVC_TRACE_PROBE)
1229 printk(" <- XU %d", entity->id);
1230
8ca5a639 1231 if (entity->bNrInPins != 1) {
c0efd232
LP		 1232 uvc_trace(UVC_TRACE_DESCR, "Extension unit %d has more "
1233 "than 1 input pin.\n", entity->id);
1234 return -1;
1235 }
1236
c0efd232
LP		 1237 break;
1238
b482d923 1239 case UVC_VC_PROCESSING_UNIT:
c0efd232
LP		 1240 if (uvc_trace_param & UVC_TRACE_PROBE)
1241 printk(" <- PU %d", entity->id);
1242
8e113595 1243 if (chain->processing != NULL) {
c0efd232
LP		 1244 uvc_trace(UVC_TRACE_DESCR, "Found multiple "
1245 "Processing Units in chain.\n");
1246 return -1;
1247 }
1248
8e113595 1249 chain->processing = entity;
c0efd232
LP		 1250 break;
1251
b482d923 1252 case UVC_VC_SELECTOR_UNIT:
c0efd232
LP		 1253 if (uvc_trace_param & UVC_TRACE_PROBE)
1254 printk(" <- SU %d", entity->id);
1255
1256 /* Single-input selector units are ignored. */
8ca5a639 1257 if (entity->bNrInPins == 1)
c0efd232
LP		 1258 break;
1259
8e113595 1260 if (chain->selector != NULL) {
c0efd232
LP		 1261 uvc_trace(UVC_TRACE_DESCR, "Found multiple Selector "
1262 "Units in chain.\n");
1263 return -1;
1264 }
1265
8e113595 1266 chain->selector = entity;
c0efd232
LP		 1267 break;
1268
b482d923
LP		 1269 case UVC_ITT_VENDOR_SPECIFIC:
1270 case UVC_ITT_CAMERA:
1271 case UVC_ITT_MEDIA_TRANSPORT_INPUT:
c0efd232
LP		 1272 if (uvc_trace_param & UVC_TRACE_PROBE)
1273 printk(" <- IT %d\n", entity->id);
1274
c0efd232
LP		 1275 break;
1276
4093a5c4
LP		 1277 case UVC_OTT_VENDOR_SPECIFIC:
1278 case UVC_OTT_DISPLAY:
1279 case UVC_OTT_MEDIA_TRANSPORT_OUTPUT:
1280 if (uvc_trace_param & UVC_TRACE_PROBE)
1281 printk(" OT %d", entity->id);
1282
1283 break;
1284
b482d923 1285 case UVC_TT_STREAMING:
4057ac6c
LP		 1286 if (UVC_ENTITY_IS_ITERM(entity)) {
1287 if (uvc_trace_param & UVC_TRACE_PROBE)
1288 printk(" <- IT %d\n", entity->id);
1289 } else {
1290 if (uvc_trace_param & UVC_TRACE_PROBE)
1291 printk(" OT %d", entity->id);
ff924203
LP		 1292 }
1293
ff924203
LP		 1294 break;
1295
c0efd232
LP		 1296 default:
1297 uvc_trace(UVC_TRACE_DESCR, "Unsupported entity type "
1298 "0x%04x found in chain.\n", UVC_ENTITY_TYPE(entity));
1299 return -1;
1300 }
1301
6241d8ca 1302 list_add_tail(&entity->chain, &chain->entities);
c0efd232
LP		 1303 return 0;
1304}
1305
8e113595 1306static int uvc_scan_chain_forward(struct uvc_video_chain *chain,
c0efd232
LP		 1307 struct uvc_entity *entity, struct uvc_entity *prev)
1308{
1309 struct uvc_entity *forward;
1310 int found;
1311
1312 /* Forward scan */
1313 forward = NULL;
1314 found = 0;
1315
1316 while (1) {
8e113595 1317 forward = uvc_entity_by_reference(chain->dev, entity->id,
c0efd232
LP		 1318 forward);
1319 if (forward == NULL)
1320 break;
8e113595 1321 if (forward == prev)
c0efd232
LP		 1322 continue;
1323
8e113595
LP		 1324 switch (UVC_ENTITY_TYPE(forward)) {
1325 case UVC_VC_EXTENSION_UNIT:
8ca5a639 1326 if (forward->bNrInPins != 1) {
8e113595
LP		 1327 uvc_trace(UVC_TRACE_DESCR, "Extension unit %d "
1328 "has more than 1 input pin.\n",
1329 entity->id);
1330 return -EINVAL;
1331 }
c0efd232 1332
6241d8ca 1333 list_add_tail(&forward->chain, &chain->entities);
8e113595
LP		 1334 if (uvc_trace_param & UVC_TRACE_PROBE) {
1335 if (!found)
1336 printk(" (->");
1337
1338 printk(" XU %d", forward->id);
1339 found = 1;
1340 }
1341 break;
1342
1343 case UVC_OTT_VENDOR_SPECIFIC:
1344 case UVC_OTT_DISPLAY:
1345 case UVC_OTT_MEDIA_TRANSPORT_OUTPUT:
1346 case UVC_TT_STREAMING:
1347 if (UVC_ENTITY_IS_ITERM(forward)) {
1348 uvc_trace(UVC_TRACE_DESCR, "Unsupported input "
1349 "terminal %u.\n", forward->id);
1350 return -EINVAL;
1351 }
c0efd232 1352
6241d8ca 1353 list_add_tail(&forward->chain, &chain->entities);
8e113595
LP		 1354 if (uvc_trace_param & UVC_TRACE_PROBE) {
1355 if (!found)
1356 printk(" (->");
1357
1358 printk(" OT %d", forward->id);
1359 found = 1;
1360 }
1361 break;
c0efd232
LP		 1362 }
1363 }
1364 if (found)
1365 printk(")");
1366
1367 return 0;
1368}
1369
8e113595 1370static int uvc_scan_chain_backward(struct uvc_video_chain *chain,
4057ac6c 1371 struct uvc_entity **_entity)
c0efd232 1372{
4057ac6c 1373 struct uvc_entity *entity = *_entity;
c0efd232 1374 struct uvc_entity *term;
4057ac6c 1375 int id = -EINVAL, i;
c0efd232
LP		 1376
1377 switch (UVC_ENTITY_TYPE(entity)) {
b482d923 1378 case UVC_VC_EXTENSION_UNIT:
b482d923 1379 case UVC_VC_PROCESSING_UNIT:
8ca5a639 1380 id = entity->baSourceID[0];
c0efd232
LP		 1381 break;
1382
b482d923 1383 case UVC_VC_SELECTOR_UNIT:
c0efd232 1384 /* Single-input selector units are ignored. */
8ca5a639
LP		 1385 if (entity->bNrInPins == 1) {
1386 id = entity->baSourceID[0];
c0efd232
LP		 1387 break;
1388 }
1389
1390 if (uvc_trace_param & UVC_TRACE_PROBE)
1391 printk(" <- IT");
1392
8e113595 1393 chain->selector = entity;
8ca5a639
LP		 1394 for (i = 0; i < entity->bNrInPins; ++i) {
1395 id = entity->baSourceID[i];
8e113595 1396 term = uvc_entity_by_id(chain->dev, id);
c0efd232
LP		 1397 if (term == NULL || !UVC_ENTITY_IS_ITERM(term)) {
1398 uvc_trace(UVC_TRACE_DESCR, "Selector unit %d "
1399 "input %d isn't connected to an "
1400 "input terminal\n", entity->id, i);
1401 return -1;
1402 }
1403
1404 if (uvc_trace_param & UVC_TRACE_PROBE)
1405 printk(" %d", term->id);
1406
6241d8ca 1407 list_add_tail(&term->chain, &chain->entities);
8e113595 1408 uvc_scan_chain_forward(chain, term, entity);
c0efd232
LP		 1409 }
1410
1411 if (uvc_trace_param & UVC_TRACE_PROBE)
1412 printk("\n");
1413
1414 id = 0;
1415 break;
4057ac6c
LP		 1416
1417 case UVC_ITT_VENDOR_SPECIFIC:
1418 case UVC_ITT_CAMERA:
1419 case UVC_ITT_MEDIA_TRANSPORT_INPUT:
1420 case UVC_OTT_VENDOR_SPECIFIC:
1421 case UVC_OTT_DISPLAY:
1422 case UVC_OTT_MEDIA_TRANSPORT_OUTPUT:
1423 case UVC_TT_STREAMING:
8ca5a639 1424 id = UVC_ENTITY_IS_OTERM(entity) ? entity->baSourceID[0] : 0;
4057ac6c 1425 break;
c0efd232
LP		 1426 }
1427
4057ac6c
LP		 1428 if (id <= 0) {
1429 *_entity = NULL;
1430 return id;
1431 }
1432
1433 entity = uvc_entity_by_id(chain->dev, id);
1434 if (entity == NULL) {
1435 uvc_trace(UVC_TRACE_DESCR, "Found reference to "
1436 "unknown entity %d.\n", id);
1437 return -EINVAL;
1438 }
1439
1440 *_entity = entity;
1441 return 0;
c0efd232
LP		 1442}
1443
8e113595 1444static int uvc_scan_chain(struct uvc_video_chain *chain,
4057ac6c 1445 struct uvc_entity *term)
c0efd232
LP		 1446{
1447 struct uvc_entity *entity, *prev;
c0efd232 1448
4057ac6c 1449 uvc_trace(UVC_TRACE_PROBE, "Scanning UVC chain:");
ff924203 1450
4057ac6c
LP		 1451 entity = term;
1452 prev = NULL;
8e113595 1453
4057ac6c
LP		 1454 while (entity != NULL) {
1455 /* Entity must not be part of an existing chain */
8e113595
LP		 1456 if (entity->chain.next || entity->chain.prev) {
1457 uvc_trace(UVC_TRACE_DESCR, "Found reference to "
4057ac6c 1458 "entity %d already in chain.\n", entity->id);
8e113595 1459 return -EINVAL;
c0efd232
LP		 1460 }
1461
1462 /* Process entity */
8e113595
LP		 1463 if (uvc_scan_chain_entity(chain, entity) < 0)
1464 return -EINVAL;
c0efd232
LP		 1465
1466 /* Forward scan */
8e113595
LP		 1467 if (uvc_scan_chain_forward(chain, entity, prev) < 0)
1468 return -EINVAL;
c0efd232 1469
c0efd232 1470 /* Backward scan */
4057ac6c
LP		 1471 prev = entity;
1472 if (uvc_scan_chain_backward(chain, &entity) < 0)
1473 return -EINVAL;
c0efd232
LP		 1474 }
1475
8e113595
LP		 1476 return 0;
1477}
1478
6241d8ca
LP		 1479static unsigned int uvc_print_terms(struct list_head *terms, u16 dir,
1480 char *buffer)
8e113595
LP		 1481{
1482 struct uvc_entity *term;
1483 unsigned int nterms = 0;
1484 char *p = buffer;
1485
1486 list_for_each_entry(term, terms, chain) {
6241d8ca
LP		 1487 if (!UVC_ENTITY_IS_TERM(term) ||
1488 UVC_TERM_DIRECTION(term) != dir)
1489 continue;
1490
1491 if (nterms)
8e113595 1492 p += sprintf(p, ",");
6241d8ca
LP		 1493 if (++nterms >= 4) {
1494 p += sprintf(p, "...");
1495 break;
8e113595 1496 }
6241d8ca 1497 p += sprintf(p, "%u", term->id);
ff924203 1498 }
c0efd232 1499
8e113595
LP		 1500 return p - buffer;
1501}
1502
1503static const char *uvc_print_chain(struct uvc_video_chain *chain)
1504{
1505 static char buffer[43];
1506 char *p = buffer;
1507
6241d8ca 1508 p += uvc_print_terms(&chain->entities, UVC_TERM_INPUT, p);
8e113595 1509 p += sprintf(p, " -> ");
6241d8ca 1510 uvc_print_terms(&chain->entities, UVC_TERM_OUTPUT, p);
8e113595
LP		 1511
1512 return buffer;
c0efd232
LP		 1513}
1514
1515/*
35f02a68 1516 * Scan the device for video chains and register video devices.
c0efd232 1517 *
8e113595 1518 * Chains are scanned starting at their output terminals and walked backwards.
c0efd232 1519 */
35f02a68 1520static int uvc_scan_device(struct uvc_device *dev)
c0efd232 1521{
8e113595 1522 struct uvc_video_chain *chain;
c0efd232 1523 struct uvc_entity *term;
c0efd232 1524
c0efd232 1525 list_for_each_entry(term, &dev->entities, list) {
8e113595 1526 if (!UVC_ENTITY_IS_OTERM(term))
c0efd232
LP		 1527 continue;
1528
8e113595
LP		 1529 /* If the terminal is already included in a chain, skip it.
1530 * This can happen for chains that have multiple output
1531 * terminals, where all output terminals beside the first one
1532 * will be inserted in the chain in forward scans.
1533 */
1534 if (term->chain.next || term->chain.prev)
c0efd232
LP		 1535 continue;
1536
8e113595
LP		 1537 chain = kzalloc(sizeof(*chain), GFP_KERNEL);
1538 if (chain == NULL)
1539 return -ENOMEM;
1540
6241d8ca 1541 INIT_LIST_HEAD(&chain->entities);
8e113595
LP		 1542 mutex_init(&chain->ctrl_mutex);
1543 chain->dev = dev;
1544
1545 if (uvc_scan_chain(chain, term) < 0) {
1546 kfree(chain);
1547 continue;
c0efd232 1548 }
8e113595
LP		 1549
1550 uvc_trace(UVC_TRACE_PROBE, "Found a valid video chain (%s).\n",
1551 uvc_print_chain(chain));
1552
1553 list_add_tail(&chain->list, &dev->chains);
c0efd232
LP		 1554 }
1555
8e113595 1556 if (list_empty(&dev->chains)) {
c0efd232
LP		 1557 uvc_printk(KERN_INFO, "No valid video chain found.\n");
1558 return -1;
1559 }
1560
c0efd232
LP		 1561 return 0;
1562}
1563
8e113595
LP		 1564/* ------------------------------------------------------------------------
1565 * Video device registration and unregistration
1566 */
1567
716fdee1
LP		 1568/*
1569 * Delete the UVC device.
1570 *
1571 * Called by the kernel when the last reference to the uvc_device structure
1572 * is released.
1573 *
1574 * As this function is called after or during disconnect(), all URBs have
1575 * already been canceled by the USB core. There is no need to kill the
1576 * interrupt URB manually.
1577 */
1578static void uvc_delete(struct uvc_device *dev)
1579{
1580 struct list_head *p, *n;
1581
1582 usb_put_intf(dev->intf);
1583 usb_put_dev(dev->udev);
1584
1585 uvc_status_cleanup(dev);
1586 uvc_ctrl_cleanup_device(dev);
1587
1588 list_for_each_safe(p, n, &dev->chains) {
1589 struct uvc_video_chain *chain;
1590 chain = list_entry(p, struct uvc_video_chain, list);
1591 kfree(chain);
1592 }
1593
1594 list_for_each_safe(p, n, &dev->entities) {
1595 struct uvc_entity *entity;
1596 entity = list_entry(p, struct uvc_entity, list);
1597 kfree(entity);
1598 }
1599
1600 list_for_each_safe(p, n, &dev->streams) {
1601 struct uvc_streaming *streaming;
1602 streaming = list_entry(p, struct uvc_streaming, list);
1603 usb_driver_release_interface(&uvc_driver.driver,
1604 streaming->intf);
1605 usb_put_intf(streaming->intf);
1606 kfree(streaming->format);
1607 kfree(streaming->header.bmaControls);
1608 kfree(streaming);
1609 }
1610
1611 kfree(dev);
1612}
1613
1614static void uvc_release(struct video_device *vdev)
1615{
1616 struct uvc_streaming *stream = video_get_drvdata(vdev);
1617 struct uvc_device *dev = stream->dev;
1618
1619 video_device_release(vdev);
1620
1621 /* Decrement the registered streams count and delete the device when it
1622 * reaches zero.
1623 */
1624 if (atomic_dec_and_test(&dev->nstreams))
1625 uvc_delete(dev);
1626}
1627
8e113595
LP		 1628/*
1629 * Unregister the video devices.
1630 */
1631static void uvc_unregister_video(struct uvc_device *dev)
1632{
1633 struct uvc_streaming *stream;
1634
716fdee1
LP		 1635 /* Unregistering all video devices might result in uvc_delete() being
1636 * called from inside the loop if there's no open file handle. To avoid
1637 * that, increment the stream count before iterating over the streams
1638 * and decrement it when done.
1639 */
1640 atomic_inc(&dev->nstreams);
1641
8e113595
LP		 1642 list_for_each_entry(stream, &dev->streams, list) {
1643 if (stream->vdev == NULL)
1644 continue;
1645
716fdee1 1646 video_unregister_device(stream->vdev);
8e113595
LP		 1647 stream->vdev = NULL;
1648 }
716fdee1
LP		 1649
1650 /* Decrement the stream count and call uvc_delete explicitly if there
1651 * are no stream left.
1652 */
1653 if (atomic_dec_and_test(&dev->nstreams))
1654 uvc_delete(dev);
8e113595
LP		 1655}
1656
1657static int uvc_register_video(struct uvc_device *dev,
1658 struct uvc_streaming *stream)
1659{
1660 struct video_device *vdev;
1661 int ret;
1662
1663 /* Initialize the streaming interface with default streaming
1664 * parameters.
1665 */
1666 ret = uvc_video_init(stream);
1667 if (ret < 0) {
1668 uvc_printk(KERN_ERR, "Failed to initialize the device "
1669 "(%d).\n", ret);
1670 return ret;
1671 }
1672
1673 /* Register the device with V4L. */
1674 vdev = video_device_alloc();
1675 if (vdev == NULL) {
1676 uvc_printk(KERN_ERR, "Failed to allocate video device (%d).\n",
1677 ret);
1678 return -ENOMEM;
1679 }
1680
1681 /* We already hold a reference to dev->udev. The video device will be
1682 * unregistered before the reference is released, so we don't need to
1683 * get another one.
1684 */
1685 vdev->parent = &dev->intf->dev;
8e113595 1686 vdev->fops = &uvc_fops;
716fdee1 1687 vdev->release = uvc_release;
8e113595
LP		 1688 strlcpy(vdev->name, dev->name, sizeof vdev->name);
1689
1690 /* Set the driver data before calling video_register_device, otherwise
1691 * uvc_v4l2_open might race us.
1692 */
1693 stream->vdev = vdev;
1694 video_set_drvdata(vdev, stream);
1695
1696 ret = video_register_device(vdev, VFL_TYPE_GRABBER, -1);
1697 if (ret < 0) {
1698 uvc_printk(KERN_ERR, "Failed to register video device (%d).\n",
1699 ret);
1700 stream->vdev = NULL;
1701 video_device_release(vdev);
1702 return ret;
1703 }
1704
716fdee1 1705 atomic_inc(&dev->nstreams);
8e113595
LP		 1706 return 0;
1707}
1708
1709/*
1710 * Register all video devices in all chains.
1711 */
1712static int uvc_register_terms(struct uvc_device *dev,
6241d8ca 1713 struct uvc_video_chain *chain)
8e113595
LP		 1714{
1715 struct uvc_streaming *stream;
1716 struct uvc_entity *term;
1717 int ret;
1718
6241d8ca 1719 list_for_each_entry(term, &chain->entities, chain) {
8e113595
LP		 1720 if (UVC_ENTITY_TYPE(term) != UVC_TT_STREAMING)
1721 continue;
1722
1723 stream = uvc_stream_by_id(dev, term->id);
1724 if (stream == NULL) {
1725 uvc_printk(KERN_INFO, "No streaming interface found "
1726 "for terminal %u.", term->id);
1727 continue;
1728 }
1729
1730 stream->chain = chain;
1731 ret = uvc_register_video(dev, stream);
1732 if (ret < 0)
1733 return ret;
1734 }
1735
1736 return 0;
1737}
1738
1739static int uvc_register_chains(struct uvc_device *dev)
1740{
1741 struct uvc_video_chain *chain;
1742 int ret;
1743
1744 list_for_each_entry(chain, &dev->chains, list) {
6241d8ca 1745 ret = uvc_register_terms(dev, chain);
8e113595
LP		 1746 if (ret < 0)
1747 return ret;
1748 }
1749
1750 return 0;
1751}
1752
1753/* ------------------------------------------------------------------------
1754 * USB probe, disconnect, suspend and resume
1755 */
1756
c0efd232
LP		 1757static int uvc_probe(struct usb_interface *intf,
1758 const struct usb_device_id *id)
1759{
1760 struct usb_device *udev = interface_to_usbdev(intf);
1761 struct uvc_device *dev;
1762 int ret;
1763
1764 if (id->idVendor && id->idProduct)
1765 uvc_trace(UVC_TRACE_PROBE, "Probing known UVC device %s "
1766 "(%04x:%04x)\n", udev->devpath, id->idVendor,
1767 id->idProduct);
1768 else
1769 uvc_trace(UVC_TRACE_PROBE, "Probing generic UVC device %s\n",
1770 udev->devpath);
1771
2c2d264b 1772 /* Allocate memory for the device and initialize it. */
c0efd232
LP		 1773 if ((dev = kzalloc(sizeof *dev, GFP_KERNEL)) == NULL)
1774 return -ENOMEM;
1775
1776 INIT_LIST_HEAD(&dev->entities);
8e113595 1777 INIT_LIST_HEAD(&dev->chains);
35f02a68 1778 INIT_LIST_HEAD(&dev->streams);
716fdee1 1779 atomic_set(&dev->nstreams, 0);
04a37e0f 1780 atomic_set(&dev->users, 0);
8fb91b33 1781 atomic_set(&dev->nmappings, 0);
c0efd232
LP		 1782
1783 dev->udev = usb_get_dev(udev);
1784 dev->intf = usb_get_intf(intf);
1785 dev->intfnum = intf->cur_altsetting->desc.bInterfaceNumber;
73de3592
LP		 1786 dev->quirks = (uvc_quirks_param == -1)
1787 ? id->driver_info : uvc_quirks_param;
c0efd232
LP		 1788
1789 if (udev->product != NULL)
d0ebf307 1790 strlcpy(dev->name, udev->product, sizeof dev->name);
c0efd232
LP		 1791 else
1792 snprintf(dev->name, sizeof dev->name,
1793 "UVC Camera (%04x:%04x)",
1794 le16_to_cpu(udev->descriptor.idVendor),
1795 le16_to_cpu(udev->descriptor.idProduct));
1796
2c2d264b 1797 /* Parse the Video Class control descriptor. */
c0efd232
LP		 1798 if (uvc_parse_control(dev) < 0) {
1799 uvc_trace(UVC_TRACE_PROBE, "Unable to parse UVC "
1800 "descriptors.\n");
1801 goto error;
1802 }
1803
fba4578e 1804 uvc_printk(KERN_INFO, "Found UVC %u.%02x device %s (%04x:%04x)\n",
c0efd232
LP		 1805 dev->uvc_version >> 8, dev->uvc_version & 0xff,
1806 udev->product ? udev->product : "<unnamed>",
1807 le16_to_cpu(udev->descriptor.idVendor),
1808 le16_to_cpu(udev->descriptor.idProduct));
1809
73de3592
LP		 1810 if (dev->quirks != id->driver_info) {
1811 uvc_printk(KERN_INFO, "Forcing device quirks to 0x%x by module "
1812 "parameter for testing purpose.\n", dev->quirks);
c0efd232
LP		 1813 uvc_printk(KERN_INFO, "Please report required quirks to the "
1814 "linux-uvc-devel mailing list.\n");
1815 }
1816
2c2d264b 1817 /* Initialize controls. */
c0efd232
LP		 1818 if (uvc_ctrl_init_device(dev) < 0)
1819 goto error;
1820
8e113595 1821 /* Scan the device for video chains. */
35f02a68 1822 if (uvc_scan_device(dev) < 0)
c0efd232
LP		 1823 goto error;
1824
8e113595
LP		 1825 /* Register video devices. */
1826 if (uvc_register_chains(dev) < 0)
1827 goto error;
1828
2c2d264b 1829 /* Save our data pointer in the interface data. */
c0efd232
LP		 1830 usb_set_intfdata(intf, dev);
1831
2c2d264b 1832 /* Initialize the interrupt URB. */
c0efd232
LP		 1833 if ((ret = uvc_status_init(dev)) < 0) {
1834 uvc_printk(KERN_INFO, "Unable to initialize the status "
1835 "endpoint (%d), status interrupt will not be "
1836 "supported.\n", ret);
1837 }
1838
1839 uvc_trace(UVC_TRACE_PROBE, "UVC device initialized.\n");
3dae8b41 1840 usb_enable_autosuspend(udev);
c0efd232
LP		 1841 return 0;
1842
1843error:
716fdee1 1844 uvc_unregister_video(dev);
c0efd232
LP		 1845 return -ENODEV;
1846}
1847
1848static void uvc_disconnect(struct usb_interface *intf)
1849{
1850 struct uvc_device *dev = usb_get_intfdata(intf);
1851
1852 /* Set the USB interface data to NULL. This can be done outside the
1853 * lock, as there's no other reader.
1854 */
1855 usb_set_intfdata(intf, NULL);
1856
b482d923
LP		 1857 if (intf->cur_altsetting->desc.bInterfaceSubClass ==
1858 UVC_SC_VIDEOSTREAMING)
c0efd232
LP		 1859 return;
1860
c0efd232 1861 dev->state |= UVC_DEV_DISCONNECTED;
a9e28585 1862
716fdee1 1863 uvc_unregister_video(dev);
c0efd232
LP		 1864}
1865
1866static int uvc_suspend(struct usb_interface *intf, pm_message_t message)
1867{
1868 struct uvc_device *dev = usb_get_intfdata(intf);
35f02a68 1869 struct uvc_streaming *stream;
c0efd232
LP		 1870
1871 uvc_trace(UVC_TRACE_SUSPEND, "Suspending interface %u\n",
1872 intf->cur_altsetting->desc.bInterfaceNumber);
1873
1874 /* Controls are cached on the fly so they don't need to be saved. */
b482d923
LP		 1875 if (intf->cur_altsetting->desc.bInterfaceSubClass ==
1876 UVC_SC_VIDEOCONTROL)
c0efd232
LP		 1877 return uvc_status_suspend(dev);
1878
35f02a68
LP		 1879 list_for_each_entry(stream, &dev->streams, list) {
1880 if (stream->intf == intf)
1881 return uvc_video_suspend(stream);
c0efd232
LP		 1882 }
1883
35f02a68
LP		 1884 uvc_trace(UVC_TRACE_SUSPEND, "Suspend: video streaming USB interface "
1885 "mismatch.\n");
1886 return -EINVAL;
c0efd232
LP		 1887}
1888
9b0ae867 1889static int __uvc_resume(struct usb_interface *intf, int reset)
c0efd232
LP		 1890{
1891 struct uvc_device *dev = usb_get_intfdata(intf);
35f02a68 1892 struct uvc_streaming *stream;
c0efd232
LP		 1893
1894 uvc_trace(UVC_TRACE_SUSPEND, "Resuming interface %u\n",
1895 intf->cur_altsetting->desc.bInterfaceNumber);
1896
b482d923
LP		 1897 if (intf->cur_altsetting->desc.bInterfaceSubClass ==
1898 UVC_SC_VIDEOCONTROL) {
7564f67d
HV		 1899 if (reset) {
1900 int ret = uvc_ctrl_resume_device(dev);
1901
1902 if (ret < 0)
1903 return ret;
1904 }
c0efd232
LP		 1905
1906 return uvc_status_resume(dev);
1907 }
1908
35f02a68
LP		 1909 list_for_each_entry(stream, &dev->streams, list) {
1910 if (stream->intf == intf)
1911 return uvc_video_resume(stream);
c0efd232
LP		 1912 }
1913
35f02a68
LP		 1914 uvc_trace(UVC_TRACE_SUSPEND, "Resume: video streaming USB interface "
1915 "mismatch.\n");
1916 return -EINVAL;
c0efd232
LP		 1917}
1918
9b0ae867
LP		 1919static int uvc_resume(struct usb_interface *intf)
1920{
1921 return __uvc_resume(intf, 0);
1922}
1923
1924static int uvc_reset_resume(struct usb_interface *intf)
1925{
1926 return __uvc_resume(intf, 1);
1927}
1928
310fe524
LP		 1929/* ------------------------------------------------------------------------
1930 * Module parameters
1931 */
1932
1933static int uvc_clock_param_get(char *buffer, struct kernel_param *kp)
1934{
1935 if (uvc_clock_param == CLOCK_MONOTONIC)
1936 return sprintf(buffer, "CLOCK_MONOTONIC");
1937 else
1938 return sprintf(buffer, "CLOCK_REALTIME");
1939}
1940
1941static int uvc_clock_param_set(const char *val, struct kernel_param *kp)
1942{
1943 if (strncasecmp(val, "clock_", strlen("clock_")) == 0)
1944 val += strlen("clock_");
1945
1946 if (strcasecmp(val, "monotonic") == 0)
1947 uvc_clock_param = CLOCK_MONOTONIC;
1948 else if (strcasecmp(val, "realtime") == 0)
1949 uvc_clock_param = CLOCK_REALTIME;
1950 else
1951 return -EINVAL;
1952
1953 return 0;
1954}
1955
1956module_param_call(clock, uvc_clock_param_set, uvc_clock_param_get,
1957 &uvc_clock_param, S_IRUGO|S_IWUSR);
1958MODULE_PARM_DESC(clock, "Video buffers timestamp clock");
1959module_param_named(nodrop, uvc_no_drop_param, uint, S_IRUGO|S_IWUSR);
1960MODULE_PARM_DESC(nodrop, "Don't drop incomplete frames");
1961module_param_named(quirks, uvc_quirks_param, uint, S_IRUGO|S_IWUSR);
1962MODULE_PARM_DESC(quirks, "Forced device quirks");
1963module_param_named(trace, uvc_trace_param, uint, S_IRUGO|S_IWUSR);
1964MODULE_PARM_DESC(trace, "Trace level bitmask");
1965module_param_named(timeout, uvc_timeout_param, uint, S_IRUGO|S_IWUSR);
1966MODULE_PARM_DESC(timeout, "Streaming control requests timeout");
1967
c0efd232
LP		 1968/* ------------------------------------------------------------------------
1969 * Driver initialization and cleanup
1970 */
1971
1972/*
1973 * The Logitech cameras listed below have their interface class set to
1974 * VENDOR_SPEC because they don't announce themselves as UVC devices, even
1975 * though they are compliant.
1976 */
1977static struct usb_device_id uvc_ids[] = {
bce039c0
LP		 1978 /* Genius eFace 2025 */
1979 { .match_flags = USB_DEVICE_ID_MATCH_DEVICE
1980 | USB_DEVICE_ID_MATCH_INT_INFO,
1981 .idVendor = 0x0458,
1982 .idProduct = 0x706e,
1983 .bInterfaceClass = USB_CLASS_VIDEO,
1984 .bInterfaceSubClass = 1,
1985 .bInterfaceProtocol = 0,
1986 .driver_info = UVC_QUIRK_PROBE_MINMAX },
c0efd232
LP		 1987 /* Microsoft Lifecam NX-6000 */
1988 { .match_flags = USB_DEVICE_ID_MATCH_DEVICE
1989 | USB_DEVICE_ID_MATCH_INT_INFO,
1990 .idVendor = 0x045e,
1991 .idProduct = 0x00f8,
1992 .bInterfaceClass = USB_CLASS_VIDEO,
1993 .bInterfaceSubClass = 1,
1994 .bInterfaceProtocol = 0,
1995 .driver_info = UVC_QUIRK_PROBE_MINMAX },
1996 /* Microsoft Lifecam VX-7000 */
1997 { .match_flags = USB_DEVICE_ID_MATCH_DEVICE
1998 | USB_DEVICE_ID_MATCH_INT_INFO,
1999 .idVendor = 0x045e,
2000 .idProduct = 0x0723,
2001 .bInterfaceClass = USB_CLASS_VIDEO,
2002 .bInterfaceSubClass = 1,
2003 .bInterfaceProtocol = 0,
2004 .driver_info = UVC_QUIRK_PROBE_MINMAX },
2005 /* Logitech Quickcam Fusion */
2006 { .match_flags = USB_DEVICE_ID_MATCH_DEVICE
2007 | USB_DEVICE_ID_MATCH_INT_INFO,
2008 .idVendor = 0x046d,
2009 .idProduct = 0x08c1,
2010 .bInterfaceClass = USB_CLASS_VENDOR_SPEC,
2011 .bInterfaceSubClass = 1,
2012 .bInterfaceProtocol = 0 },
2013 /* Logitech Quickcam Orbit MP */
2014 { .match_flags = USB_DEVICE_ID_MATCH_DEVICE
2015 | USB_DEVICE_ID_MATCH_INT_INFO,
2016 .idVendor = 0x046d,
2017 .idProduct = 0x08c2,
2018 .bInterfaceClass = USB_CLASS_VENDOR_SPEC,
2019 .bInterfaceSubClass = 1,
2020 .bInterfaceProtocol = 0 },
2021 /* Logitech Quickcam Pro for Notebook */
2022 { .match_flags = USB_DEVICE_ID_MATCH_DEVICE
2023 | USB_DEVICE_ID_MATCH_INT_INFO,
2024 .idVendor = 0x046d,
2025 .idProduct = 0x08c3,
2026 .bInterfaceClass = USB_CLASS_VENDOR_SPEC,
2027 .bInterfaceSubClass = 1,
2028 .bInterfaceProtocol = 0 },
2029 /* Logitech Quickcam Pro 5000 */
2030 { .match_flags = USB_DEVICE_ID_MATCH_DEVICE
2031 | USB_DEVICE_ID_MATCH_INT_INFO,
2032 .idVendor = 0x046d,
2033 .idProduct = 0x08c5,
2034 .bInterfaceClass = USB_CLASS_VENDOR_SPEC,
2035 .bInterfaceSubClass = 1,
2036 .bInterfaceProtocol = 0 },
2037 /* Logitech Quickcam OEM Dell Notebook */
2038 { .match_flags = USB_DEVICE_ID_MATCH_DEVICE
2039 | USB_DEVICE_ID_MATCH_INT_INFO,
2040 .idVendor = 0x046d,
2041 .idProduct = 0x08c6,
2042 .bInterfaceClass = USB_CLASS_VENDOR_SPEC,
2043 .bInterfaceSubClass = 1,
2044 .bInterfaceProtocol = 0 },
2045 /* Logitech Quickcam OEM Cisco VT Camera II */
2046 { .match_flags = USB_DEVICE_ID_MATCH_DEVICE
2047 | USB_DEVICE_ID_MATCH_INT_INFO,
2048 .idVendor = 0x046d,
2049 .idProduct = 0x08c7,
2050 .bInterfaceClass = USB_CLASS_VENDOR_SPEC,
2051 .bInterfaceSubClass = 1,
2052 .bInterfaceProtocol = 0 },
86d8b6ab
LP		 2053 /* Chicony CNF7129 (Asus EEE 100HE) */
2054 { .match_flags = USB_DEVICE_ID_MATCH_DEVICE
2055 | USB_DEVICE_ID_MATCH_INT_INFO,
2056 .idVendor = 0x04f2,
2057 .idProduct = 0xb071,
2058 .bInterfaceClass = USB_CLASS_VIDEO,
2059 .bInterfaceSubClass = 1,
2060 .bInterfaceProtocol = 0,
2061 .driver_info = UVC_QUIRK_RESTRICT_FRAME_RATE },
f61d1d8a
LP		 2062 /* Alcor Micro AU3820 (Future Boy PC USB Webcam) */
2063 { .match_flags = USB_DEVICE_ID_MATCH_DEVICE
2064 | USB_DEVICE_ID_MATCH_INT_INFO,
2065 .idVendor = 0x058f,
2066 .idProduct = 0x3820,
2067 .bInterfaceClass = USB_CLASS_VIDEO,
2068 .bInterfaceSubClass = 1,
2069 .bInterfaceProtocol = 0,
2070 .driver_info = UVC_QUIRK_PROBE_MINMAX },
c0efd232 2071 /* Apple Built-In iSight */
2c2d264b 2072 { .match_flags = USB_DEVICE_ID_MATCH_DEVICE
c0efd232
LP		 2073 | USB_DEVICE_ID_MATCH_INT_INFO,
2074 .idVendor = 0x05ac,
2075 .idProduct = 0x8501,
2c2d264b
LP		 2076 .bInterfaceClass = USB_CLASS_VIDEO,
2077 .bInterfaceSubClass = 1,
2078 .bInterfaceProtocol = 0,
c0efd232
LP		 2079 .driver_info = UVC_QUIRK_PROBE_MINMAX
2080 | UVC_QUIRK_BUILTIN_ISIGHT },
2081 /* Genesys Logic USB 2.0 PC Camera */
2c2d264b 2082 { .match_flags = USB_DEVICE_ID_MATCH_DEVICE
c0efd232 2083 | USB_DEVICE_ID_MATCH_INT_INFO,
2c2d264b
LP		 2084 .idVendor = 0x05e3,
2085 .idProduct = 0x0505,
2086 .bInterfaceClass = USB_CLASS_VIDEO,
2087 .bInterfaceSubClass = 1,
2088 .bInterfaceProtocol = 0,
2089 .driver_info = UVC_QUIRK_STREAM_NO_FID },
e01a2344
LP		 2090 /* Hercules Classic Silver */
2091 { .match_flags = USB_DEVICE_ID_MATCH_DEVICE
2092 | USB_DEVICE_ID_MATCH_INT_INFO,
2093 .idVendor = 0x06f8,
2094 .idProduct = 0x300c,
2095 .bInterfaceClass = USB_CLASS_VIDEO,
2096 .bInterfaceSubClass = 1,
2097 .bInterfaceProtocol = 0,
2098 .driver_info = UVC_QUIRK_FIX_BANDWIDTH },
d79cd839
LP		 2099 /* ViMicro Vega */
2100 { .match_flags = USB_DEVICE_ID_MATCH_DEVICE
2101 | USB_DEVICE_ID_MATCH_INT_INFO,
2102 .idVendor = 0x0ac8,
2103 .idProduct = 0x332d,
2104 .bInterfaceClass = USB_CLASS_VIDEO,
2105 .bInterfaceSubClass = 1,
2106 .bInterfaceProtocol = 0,
2107 .driver_info = UVC_QUIRK_FIX_BANDWIDTH },
2108 /* ViMicro - Minoru3D */
2109 { .match_flags = USB_DEVICE_ID_MATCH_DEVICE
2110 | USB_DEVICE_ID_MATCH_INT_INFO,
2111 .idVendor = 0x0ac8,
2112 .idProduct = 0x3410,
2113 .bInterfaceClass = USB_CLASS_VIDEO,
2114 .bInterfaceSubClass = 1,
2115 .bInterfaceProtocol = 0,
2116 .driver_info = UVC_QUIRK_FIX_BANDWIDTH },
2117 /* ViMicro Venus - Minoru3D */
2118 { .match_flags = USB_DEVICE_ID_MATCH_DEVICE
50144aee
LP		 2119 | USB_DEVICE_ID_MATCH_INT_INFO,
2120 .idVendor = 0x0ac8,
d79cd839 2121 .idProduct = 0x3420,
50144aee
LP		 2122 .bInterfaceClass = USB_CLASS_VIDEO,
2123 .bInterfaceSubClass = 1,
2124 .bInterfaceProtocol = 0,
2125 .driver_info = UVC_QUIRK_FIX_BANDWIDTH },
c0efd232
LP		 2126 /* MT6227 */
2127 { .match_flags = USB_DEVICE_ID_MATCH_DEVICE
2128 | USB_DEVICE_ID_MATCH_INT_INFO,
2129 .idVendor = 0x0e8d,
2130 .idProduct = 0x0004,
2131 .bInterfaceClass = USB_CLASS_VIDEO,
2132 .bInterfaceSubClass = 1,
2133 .bInterfaceProtocol = 0,
bab6f66c
LP		 2134 .driver_info = UVC_QUIRK_PROBE_MINMAX
2135 | UVC_QUIRK_PROBE_DEF },
9275b32b
LP		 2136 /* IMC Networks (Medion Akoya) */
2137 { .match_flags = USB_DEVICE_ID_MATCH_DEVICE
2138 | USB_DEVICE_ID_MATCH_INT_INFO,
2139 .idVendor = 0x13d3,
2140 .idProduct = 0x5103,
2141 .bInterfaceClass = USB_CLASS_VIDEO,
2142 .bInterfaceSubClass = 1,
2143 .bInterfaceProtocol = 0,
2144 .driver_info = UVC_QUIRK_STREAM_NO_FID },
d1787b1f
LP		 2145 /* JMicron USB2.0 XGA WebCam */
2146 { .match_flags = USB_DEVICE_ID_MATCH_DEVICE
2147 | USB_DEVICE_ID_MATCH_INT_INFO,
2148 .idVendor = 0x152d,
2149 .idProduct = 0x0310,
2150 .bInterfaceClass = USB_CLASS_VIDEO,
2151 .bInterfaceSubClass = 1,
2152 .bInterfaceProtocol = 0,
2153 .driver_info = UVC_QUIRK_PROBE_MINMAX },
c0efd232
LP		 2154 /* Syntek (HP Spartan) */
2155 { .match_flags = USB_DEVICE_ID_MATCH_DEVICE
2156 | USB_DEVICE_ID_MATCH_INT_INFO,
2157 .idVendor = 0x174f,
2158 .idProduct = 0x5212,
2159 .bInterfaceClass = USB_CLASS_VIDEO,
2160 .bInterfaceSubClass = 1,
2161 .bInterfaceProtocol = 0,
25e69850 2162 .driver_info = UVC_QUIRK_STREAM_NO_FID },
562f0fed
LP		 2163 /* Syntek (Samsung Q310) */
2164 { .match_flags = USB_DEVICE_ID_MATCH_DEVICE
2165 | USB_DEVICE_ID_MATCH_INT_INFO,
2166 .idVendor = 0x174f,
2167 .idProduct = 0x5931,
2168 .bInterfaceClass = USB_CLASS_VIDEO,
2169 .bInterfaceSubClass = 1,
2170 .bInterfaceProtocol = 0,
2171 .driver_info = UVC_QUIRK_STREAM_NO_FID },
f129b03b
LP		 2172 /* Syntek (Packard Bell EasyNote MX52 */
2173 { .match_flags = USB_DEVICE_ID_MATCH_DEVICE
2174 | USB_DEVICE_ID_MATCH_INT_INFO,
2175 .idVendor = 0x174f,
2176 .idProduct = 0x8a12,
2177 .bInterfaceClass = USB_CLASS_VIDEO,
2178 .bInterfaceSubClass = 1,
2179 .bInterfaceProtocol = 0,
2180 .driver_info = UVC_QUIRK_STREAM_NO_FID },
f61d1d8a 2181 /* Syntek (Asus F9SG) */
25e69850
LP		 2182 { .match_flags = USB_DEVICE_ID_MATCH_DEVICE
2183 | USB_DEVICE_ID_MATCH_INT_INFO,
2184 .idVendor = 0x174f,
2185 .idProduct = 0x8a31,
2186 .bInterfaceClass = USB_CLASS_VIDEO,
2187 .bInterfaceSubClass = 1,
2188 .bInterfaceProtocol = 0,
c0efd232
LP		 2189 .driver_info = UVC_QUIRK_STREAM_NO_FID },
2190 /* Syntek (Asus U3S) */
2191 { .match_flags = USB_DEVICE_ID_MATCH_DEVICE
2192 | USB_DEVICE_ID_MATCH_INT_INFO,
2193 .idVendor = 0x174f,
2194 .idProduct = 0x8a33,
2195 .bInterfaceClass = USB_CLASS_VIDEO,
2196 .bInterfaceSubClass = 1,
2197 .bInterfaceProtocol = 0,
2198 .driver_info = UVC_QUIRK_STREAM_NO_FID },
0ce566da
LP		 2199 /* Syntek (JAOtech Smart Terminal) */
2200 { .match_flags = USB_DEVICE_ID_MATCH_DEVICE
2201 | USB_DEVICE_ID_MATCH_INT_INFO,
2202 .idVendor = 0x174f,
2203 .idProduct = 0x8a34,
2204 .bInterfaceClass = USB_CLASS_VIDEO,
2205 .bInterfaceSubClass = 1,
2206 .bInterfaceProtocol = 0,
2207 .driver_info = UVC_QUIRK_STREAM_NO_FID },
70092c26
LP		 2208 /* Miricle 307K */
2209 { .match_flags = USB_DEVICE_ID_MATCH_DEVICE
2210 | USB_DEVICE_ID_MATCH_INT_INFO,
2211 .idVendor = 0x17dc,
2212 .idProduct = 0x0202,
2213 .bInterfaceClass = USB_CLASS_VIDEO,
2214 .bInterfaceSubClass = 1,
2215 .bInterfaceProtocol = 0,
2216 .driver_info = UVC_QUIRK_STREAM_NO_FID },
849a3aba 2217 /* Lenovo Thinkpad SL400/SL500 */
2f38483b
LP		 2218 { .match_flags = USB_DEVICE_ID_MATCH_DEVICE
2219 | USB_DEVICE_ID_MATCH_INT_INFO,
2220 .idVendor = 0x17ef,
2221 .idProduct = 0x480b,
2222 .bInterfaceClass = USB_CLASS_VIDEO,
2223 .bInterfaceSubClass = 1,
2224 .bInterfaceProtocol = 0,
2225 .driver_info = UVC_QUIRK_STREAM_NO_FID },
2d2bf2a3
LP		 2226 /* Aveo Technology USB 2.0 Camera */
2227 { .match_flags = USB_DEVICE_ID_MATCH_DEVICE
2228 | USB_DEVICE_ID_MATCH_INT_INFO,
2229 .idVendor = 0x1871,
2230 .idProduct = 0x0306,
2231 .bInterfaceClass = USB_CLASS_VIDEO,
2232 .bInterfaceSubClass = 1,
2233 .bInterfaceProtocol = 0,
5bdf1377
LP		 2234 .driver_info = UVC_QUIRK_PROBE_MINMAX
2235 | UVC_QUIRK_PROBE_EXTRAFIELDS },
c0efd232
LP		 2236 /* Ecamm Pico iMage */
2237 { .match_flags = USB_DEVICE_ID_MATCH_DEVICE
2238 | USB_DEVICE_ID_MATCH_INT_INFO,
2239 .idVendor = 0x18cd,
2240 .idProduct = 0xcafe,
2241 .bInterfaceClass = USB_CLASS_VIDEO,
2242 .bInterfaceSubClass = 1,
2243 .bInterfaceProtocol = 0,
2244 .driver_info = UVC_QUIRK_PROBE_EXTRAFIELDS },
2bb00fe6
LP		 2245 /* Manta MM-353 Plako */
2246 { .match_flags = USB_DEVICE_ID_MATCH_DEVICE
2247 | USB_DEVICE_ID_MATCH_INT_INFO,
2248 .idVendor = 0x18ec,
2249 .idProduct = 0x3188,
2250 .bInterfaceClass = USB_CLASS_VIDEO,
2251 .bInterfaceSubClass = 1,
2252 .bInterfaceProtocol = 0,
2253 .driver_info = UVC_QUIRK_PROBE_MINMAX },
ca4a3456
LP		 2254 /* FSC WebCam V30S */
2255 { .match_flags = USB_DEVICE_ID_MATCH_DEVICE
2256 | USB_DEVICE_ID_MATCH_INT_INFO,
2257 .idVendor = 0x18ec,
2258 .idProduct = 0x3288,
2259 .bInterfaceClass = USB_CLASS_VIDEO,
2260 .bInterfaceSubClass = 1,
2261 .bInterfaceProtocol = 0,
2262 .driver_info = UVC_QUIRK_PROBE_MINMAX },
1e4d05bc
LP		 2263 /* Arkmicro unbranded */
2264 { .match_flags = USB_DEVICE_ID_MATCH_DEVICE
2265 | USB_DEVICE_ID_MATCH_INT_INFO,
2266 .idVendor = 0x18ec,
2267 .idProduct = 0x3290,
2268 .bInterfaceClass = USB_CLASS_VIDEO,
2269 .bInterfaceSubClass = 1,
2270 .bInterfaceProtocol = 0,
2271 .driver_info = UVC_QUIRK_PROBE_DEF },
c0efd232
LP		 2272 /* Bodelin ProScopeHR */
2273 { .match_flags = USB_DEVICE_ID_MATCH_DEVICE
2274 | USB_DEVICE_ID_MATCH_DEV_HI
2275 | USB_DEVICE_ID_MATCH_INT_INFO,
2276 .idVendor = 0x19ab,
2277 .idProduct = 0x1000,
2278 .bcdDevice_hi = 0x0126,
2279 .bInterfaceClass = USB_CLASS_VIDEO,
2280 .bInterfaceSubClass = 1,
2281 .bInterfaceProtocol = 0,
2282 .driver_info = UVC_QUIRK_STATUS_INTERVAL },
3bc766ad
LP		 2283 /* MSI StarCam 370i */
2284 { .match_flags = USB_DEVICE_ID_MATCH_DEVICE
2285 | USB_DEVICE_ID_MATCH_INT_INFO,
2286 .idVendor = 0x1b3b,
2287 .idProduct = 0x2951,
2288 .bInterfaceClass = USB_CLASS_VIDEO,
2289 .bInterfaceSubClass = 1,
2290 .bInterfaceProtocol = 0,
2291 .driver_info = UVC_QUIRK_PROBE_MINMAX },
c0efd232
LP		 2292 /* SiGma Micro USB Web Camera */
2293 { .match_flags = USB_DEVICE_ID_MATCH_DEVICE
2294 | USB_DEVICE_ID_MATCH_INT_INFO,
2295 .idVendor = 0x1c4f,
2296 .idProduct = 0x3000,
2297 .bInterfaceClass = USB_CLASS_VIDEO,
2298 .bInterfaceSubClass = 1,
2299 .bInterfaceProtocol = 0,
2300 .driver_info = UVC_QUIRK_PROBE_MINMAX
d732c44c 2301 | UVC_QUIRK_IGNORE_SELECTOR_UNIT },
c0efd232
LP		 2302 /* Generic USB Video Class */
2303 { USB_INTERFACE_INFO(USB_CLASS_VIDEO, 1, 0) },
2304 {}
2305};
2306
2307MODULE_DEVICE_TABLE(usb, uvc_ids);
2308
2309struct uvc_driver uvc_driver = {
2310 .driver = {
2311 .name = "uvcvideo",
2312 .probe = uvc_probe,
2313 .disconnect = uvc_disconnect,
2314 .suspend = uvc_suspend,
2315 .resume = uvc_resume,
9b0ae867 2316 .reset_resume = uvc_reset_resume,
c0efd232
LP		 2317 .id_table = uvc_ids,
2318 .supports_autosuspend = 1,
2319 },
2320};
2321
2322static int __init uvc_init(void)
2323{
2324 int result;
2325
c0efd232
LP		 2326 result = usb_register(&uvc_driver.driver);
2327 if (result == 0)
2328 printk(KERN_INFO DRIVER_DESC " (" DRIVER_VERSION ")\n");
2329 return result;
2330}
2331
2332static void __exit uvc_cleanup(void)
2333{
2334 usb_deregister(&uvc_driver.driver);
2335}
2336
2337module_init(uvc_init);
2338module_exit(uvc_cleanup);
2339
c0efd232
LP		 2340MODULE_AUTHOR(DRIVER_AUTHOR);
2341MODULE_DESCRIPTION(DRIVER_DESC);
2342MODULE_LICENSE("GPL");
2343MODULE_VERSION(DRIVER_VERSION);
f87086e3 2344
kernel source for telekom puls (alcatel/mediatek)