source: src/linux/universal/linux-3.18/drivers/media/usb/uvc/uvc_driver.c @ 31885

Last change on this file since 31885 was 31885, checked in by brainslayer, 3 months ago

update

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