drivers/media/usb/uvc/uvc_driver.c

   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
  34 unsigned int uvc_clock_param = CLOCK_MONOTONIC;
  35 unsigned int uvc_no_drop_param;
  36 static unsigned int uvc_quirks_param = -1;
  37 unsigned int uvc_trace_param;
  38 unsigned int uvc_timeout_param = UVC_CTRL_STREAMING_TIMEOUT;
  39
  40 /* ------------------------------------------------------------------------
  41  * Video formats
  42  */
  43
  44 static 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
 151 struct 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
 166 static 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
 179 static __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  */
 203 void 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  */
 254 uint32_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
 280 struct 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
 292 static 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
 309 static 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
 325 static 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
 567 static 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
 812 error:
 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
 821 static 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. */
 856 static 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
 934 static 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
1187 static 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
1207 next_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  */
1264 static 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
1347 static 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
1411 static 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
1485 static 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
1520 static 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
1544 static 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
1556 /*
1557  * Scan the device for video chains and register video devices.
1558  *
1559  * Chains are scanned starting at their output terminals and walked backwards.
1560  */
1561 static int uvc_scan_device(struct uvc_device *dev)
1562 {
1563         struct uvc_video_chain *chain;
1564         struct uvc_entity *term;
1565
1566         list_for_each_entry(term, &dev->entities, list) {
1567                 if (!UVC_ENTITY_IS_OTERM(term))
1568                         continue;
1569
1570                 /* If the terminal is already included in a chain, skip it.
1571                  * This can happen for chains that have multiple output
1572                  * terminals, where all output terminals beside the first one
1573                  * will be inserted in the chain in forward scans.
1574                  */
1575                 if (term->chain.next || term->chain.prev)
1576                         continue;
1577
1578                 chain = kzalloc(sizeof(*chain), GFP_KERNEL);
1579                 if (chain == NULL)
1580                         return -ENOMEM;
1581
1582                 INIT_LIST_HEAD(&chain->entities);
1583                 mutex_init(&chain->ctrl_mutex);
1584                 chain->dev = dev;
1585                 v4l2_prio_init(&chain->prio);
1586
1587                 term->flags |= UVC_ENTITY_FLAG_DEFAULT;
1588
1589                 if (uvc_scan_chain(chain, term) < 0) {
1590                         kfree(chain);
1591                         continue;
1592                 }
1593
1594                 uvc_trace(UVC_TRACE_PROBE, "Found a valid video chain (%s).\n",
1595                           uvc_print_chain(chain));
1596
1597                 list_add_tail(&chain->list, &dev->chains);
1598         }
1599
1600         if (list_empty(&dev->chains)) {
1601                 uvc_printk(KERN_INFO, "No valid video chain found.\n");
1602                 return -1;
1603         }
1604
1605         return 0;
1606 }
1607
1608 /* ------------------------------------------------------------------------
1609  * Video device registration and unregistration
1610  */
1611
1612 /*
1613  * Delete the UVC device.
1614  *
1615  * Called by the kernel when the last reference to the uvc_device structure
1616  * is released.
1617  *
1618  * As this function is called after or during disconnect(), all URBs have
1619  * already been canceled by the USB core. There is no need to kill the
1620  * interrupt URB manually.
1621  */
1622 static void uvc_delete(struct uvc_device *dev)
1623 {
1624         struct list_head *p, *n;
1625
1626         usb_put_intf(dev->intf);
1627         usb_put_dev(dev->udev);
1628
1629         uvc_status_cleanup(dev);
1630         uvc_ctrl_cleanup_device(dev);
1631
1632         if (dev->vdev.dev)
1633                 v4l2_device_unregister(&dev->vdev);
1634 #ifdef CONFIG_MEDIA_CONTROLLER
1635         if (media_devnode_is_registered(&dev->mdev.devnode))
1636                 media_device_unregister(&dev->mdev);
1637 #endif
1638
1639         list_for_each_safe(p, n, &dev->chains) {
1640                 struct uvc_video_chain *chain;
1641                 chain = list_entry(p, struct uvc_video_chain, list);
1642                 kfree(chain);
1643         }
1644
1645         list_for_each_safe(p, n, &dev->entities) {
1646                 struct uvc_entity *entity;
1647                 entity = list_entry(p, struct uvc_entity, list);
1648 #ifdef CONFIG_MEDIA_CONTROLLER
1649                 uvc_mc_cleanup_entity(entity);
1650 #endif
1651                 if (entity->vdev) {
1652                         video_device_release(entity->vdev);
1653                         entity->vdev = NULL;
1654                 }
1655                 kfree(entity);
1656         }
1657
1658         list_for_each_safe(p, n, &dev->streams) {
1659                 struct uvc_streaming *streaming;
1660                 streaming = list_entry(p, struct uvc_streaming, list);
1661                 usb_driver_release_interface(&uvc_driver.driver,
1662                         streaming->intf);
1663                 usb_put_intf(streaming->intf);
1664                 kfree(streaming->format);
1665                 kfree(streaming->header.bmaControls);
1666                 kfree(streaming);
1667         }
1668
1669         kfree(dev);
1670 }
1671
1672 static void uvc_release(struct video_device *vdev)
1673 {
1674         struct uvc_streaming *stream = video_get_drvdata(vdev);
1675         struct uvc_device *dev = stream->dev;
1676
1677         /* Decrement the registered streams count and delete the device when it
1678          * reaches zero.
1679          */
1680         if (atomic_dec_and_test(&dev->nstreams))
1681                 uvc_delete(dev);
1682 }
1683
1684 /*
1685  * Unregister the video devices.
1686  */
1687 static void uvc_unregister_video(struct uvc_device *dev)
1688 {
1689         struct uvc_streaming *stream;
1690
1691         /* Unregistering all video devices might result in uvc_delete() being
1692          * called from inside the loop if there's no open file handle. To avoid
1693          * that, increment the stream count before iterating over the streams
1694          * and decrement it when done.
1695          */
1696         atomic_inc(&dev->nstreams);
1697
1698         list_for_each_entry(stream, &dev->streams, list) {
1699                 if (stream->vdev == NULL)
1700                         continue;
1701
1702                 video_unregister_device(stream->vdev);
1703                 stream->vdev = NULL;
1704
1705                 uvc_debugfs_cleanup_stream(stream);
1706         }
1707
1708         /* Decrement the stream count and call uvc_delete explicitly if there
1709          * are no stream left.
1710          */
1711         if (atomic_dec_and_test(&dev->nstreams))
1712                 uvc_delete(dev);
1713 }
1714
1715 static int uvc_register_video(struct uvc_device *dev,
1716                 struct uvc_streaming *stream)
1717 {
1718         struct video_device *vdev;
1719         int ret;
1720
1721         /* Initialize the streaming interface with default streaming
1722          * parameters.
1723          */
1724         ret = uvc_video_init(stream);
1725         if (ret < 0) {
1726                 uvc_printk(KERN_ERR, "Failed to initialize the device "
1727                         "(%d).\n", ret);
1728                 return ret;
1729         }
1730
1731         uvc_debugfs_init_stream(stream);
1732
1733         /* Register the device with V4L. */
1734         vdev = video_device_alloc();
1735         if (vdev == NULL) {
1736                 uvc_printk(KERN_ERR, "Failed to allocate video device (%d).\n",
1737                            ret);
1738                 return -ENOMEM;
1739         }
1740
1741         /* We already hold a reference to dev->udev. The video device will be
1742          * unregistered before the reference is released, so we don't need to
1743          * get another one.
1744          */
1745         vdev->v4l2_dev = &dev->vdev;
1746         vdev->fops = &uvc_fops;
1747         vdev->release = uvc_release;
1748         vdev->prio = &stream->chain->prio;
1749         if (stream->type == V4L2_BUF_TYPE_VIDEO_OUTPUT)
1750                 vdev->vfl_dir = VFL_DIR_TX;
1751         strlcpy(vdev->name, dev->name, sizeof vdev->name);
1752
1753         /* Set the driver data before calling video_register_device, otherwise
1754          * uvc_v4l2_open might race us.
1755          */
1756         stream->vdev = vdev;
1757         video_set_drvdata(vdev, stream);
1758
1759         ret = video_register_device(vdev, VFL_TYPE_GRABBER, -1);
1760         if (ret < 0) {
1761                 uvc_printk(KERN_ERR, "Failed to register video device (%d).\n",
1762                            ret);
1763                 stream->vdev = NULL;
1764                 video_device_release(vdev);
1765                 return ret;
1766         }
1767
1768         if (stream->type == V4L2_BUF_TYPE_VIDEO_CAPTURE)
1769                 stream->chain->caps |= V4L2_CAP_VIDEO_CAPTURE;
1770         else
1771                 stream->chain->caps |= V4L2_CAP_VIDEO_OUTPUT;
1772
1773         atomic_inc(&dev->nstreams);
1774         return 0;
1775 }
1776
1777 /*
1778  * Register all video devices in all chains.
1779  */
1780 static int uvc_register_terms(struct uvc_device *dev,
1781         struct uvc_video_chain *chain)
1782 {
1783         struct uvc_streaming *stream;
1784         struct uvc_entity *term;
1785         int ret;
1786
1787         list_for_each_entry(term, &chain->entities, chain) {
1788                 if (UVC_ENTITY_TYPE(term) != UVC_TT_STREAMING)
1789                         continue;
1790
1791                 stream = uvc_stream_by_id(dev, term->id);
1792                 if (stream == NULL) {
1793                         uvc_printk(KERN_INFO, "No streaming interface found "
1794                                    "for terminal %u.", term->id);
1795                         continue;
1796                 }
1797
1798                 stream->chain = chain;
1799                 ret = uvc_register_video(dev, stream);
1800                 if (ret < 0)
1801                         return ret;
1802
1803                 term->vdev = stream->vdev;
1804         }
1805
1806         return 0;
1807 }
1808
1809 static int uvc_register_chains(struct uvc_device *dev)
1810 {
1811         struct uvc_video_chain *chain;
1812         int ret;
1813
1814         list_for_each_entry(chain, &dev->chains, list) {
1815                 ret = uvc_register_terms(dev, chain);
1816                 if (ret < 0)
1817                         return ret;
1818
1819 #ifdef CONFIG_MEDIA_CONTROLLER
1820                 ret = uvc_mc_register_entities(chain);
1821                 if (ret < 0) {
1822                         uvc_printk(KERN_INFO, "Failed to register entites "
1823                                 "(%d).\n", ret);
1824                 }
1825 #endif
1826         }
1827
1828         return 0;
1829 }
1830
1831 /* ------------------------------------------------------------------------
1832  * USB probe, disconnect, suspend and resume
1833  */
1834
1835 static int uvc_probe(struct usb_interface *intf,
1836                      const struct usb_device_id *id)
1837 {
1838         struct usb_device *udev = interface_to_usbdev(intf);
1839         struct uvc_device *dev;
1840         int ret;
1841
1842         if (id->idVendor && id->idProduct)
1843                 uvc_trace(UVC_TRACE_PROBE, "Probing known UVC device %s "
1844                                 "(%04x:%04x)\n", udev->devpath, id->idVendor,
1845                                 id->idProduct);
1846         else
1847                 uvc_trace(UVC_TRACE_PROBE, "Probing generic UVC device %s\n",
1848                                 udev->devpath);
1849
1850         /* Allocate memory for the device and initialize it. */
1851         if ((dev = kzalloc(sizeof *dev, GFP_KERNEL)) == NULL)
1852                 return -ENOMEM;
1853
1854         INIT_LIST_HEAD(&dev->entities);
1855         INIT_LIST_HEAD(&dev->chains);
1856         INIT_LIST_HEAD(&dev->streams);
1857         atomic_set(&dev->nstreams, 0);
1858         atomic_set(&dev->nmappings, 0);
1859         mutex_init(&dev->lock);
1860
1861         dev->udev = usb_get_dev(udev);
1862         dev->intf = usb_get_intf(intf);
1863         dev->intfnum = intf->cur_altsetting->desc.bInterfaceNumber;
1864         dev->quirks = (uvc_quirks_param == -1)
1865                     ? id->driver_info : uvc_quirks_param;
1866
1867         if (udev->product != NULL)
1868                 strlcpy(dev->name, udev->product, sizeof dev->name);
1869         else
1870                 snprintf(dev->name, sizeof dev->name,
1871                         "UVC Camera (%04x:%04x)",
1872                         le16_to_cpu(udev->descriptor.idVendor),
1873                         le16_to_cpu(udev->descriptor.idProduct));
1874
1875         /* Parse the Video Class control descriptor. */
1876         if (uvc_parse_control(dev) < 0) {
1877                 uvc_trace(UVC_TRACE_PROBE, "Unable to parse UVC "
1878                         "descriptors.\n");
1879                 goto error;
1880         }
1881
1882         uvc_printk(KERN_INFO, "Found UVC %u.%02x device %s (%04x:%04x)\n",
1883                 dev->uvc_version >> 8, dev->uvc_version & 0xff,
1884                 udev->product ? udev->product : "<unnamed>",
1885                 le16_to_cpu(udev->descriptor.idVendor),
1886                 le16_to_cpu(udev->descriptor.idProduct));
1887
1888         if (dev->quirks != id->driver_info) {
1889                 uvc_printk(KERN_INFO, "Forcing device quirks to 0x%x by module "
1890                         "parameter for testing purpose.\n", dev->quirks);
1891                 uvc_printk(KERN_INFO, "Please report required quirks to the "
1892                         "linux-uvc-devel mailing list.\n");
1893         }
1894
1895         /* Register the media and V4L2 devices. */
1896 #ifdef CONFIG_MEDIA_CONTROLLER
1897         dev->mdev.dev = &intf->dev;
1898         strlcpy(dev->mdev.model, dev->name, sizeof(dev->mdev.model));
1899         if (udev->serial)
1900                 strlcpy(dev->mdev.serial, udev->serial,
1901                         sizeof(dev->mdev.serial));
1902         strcpy(dev->mdev.bus_info, udev->devpath);
1903         dev->mdev.hw_revision = le16_to_cpu(udev->descriptor.bcdDevice);
1904         dev->mdev.driver_version = LINUX_VERSION_CODE;
1905         if (media_device_register(&dev->mdev) < 0)
1906                 goto error;
1907
1908         dev->vdev.mdev = &dev->mdev;
1909 #endif
1910         if (v4l2_device_register(&intf->dev, &dev->vdev) < 0)
1911                 goto error;
1912
1913         /* Initialize controls. */
1914         if (uvc_ctrl_init_device(dev) < 0)
1915                 goto error;
1916
1917         /* Scan the device for video chains. */
1918         if (uvc_scan_device(dev) < 0)
1919                 goto error;
1920
1921         /* Register video device nodes. */
1922         if (uvc_register_chains(dev) < 0)
1923                 goto error;
1924
1925         /* Save our data pointer in the interface data. */
1926         usb_set_intfdata(intf, dev);
1927
1928         /* Initialize the interrupt URB. */
1929         if ((ret = uvc_status_init(dev)) < 0) {
1930                 uvc_printk(KERN_INFO, "Unable to initialize the status "
1931                         "endpoint (%d), status interrupt will not be "
1932                         "supported.\n", ret);
1933         }
1934
1935         uvc_trace(UVC_TRACE_PROBE, "UVC device initialized.\n");
1936         usb_enable_autosuspend(udev);
1937         return 0;
1938
1939 error:
1940         uvc_unregister_video(dev);
1941         return -ENODEV;
1942 }
1943
1944 static void uvc_disconnect(struct usb_interface *intf)
1945 {
1946         struct uvc_device *dev = usb_get_intfdata(intf);
1947
1948         /* Set the USB interface data to NULL. This can be done outside the
1949          * lock, as there's no other reader.
1950          */
1951         usb_set_intfdata(intf, NULL);
1952
1953         if (intf->cur_altsetting->desc.bInterfaceSubClass ==
1954             UVC_SC_VIDEOSTREAMING)
1955                 return;
1956
1957         dev->state |= UVC_DEV_DISCONNECTED;
1958
1959         uvc_unregister_video(dev);
1960 }
1961
1962 static int uvc_suspend(struct usb_interface *intf, pm_message_t message)
1963 {
1964         struct uvc_device *dev = usb_get_intfdata(intf);
1965         struct uvc_streaming *stream;
1966
1967         uvc_trace(UVC_TRACE_SUSPEND, "Suspending interface %u\n",
1968                 intf->cur_altsetting->desc.bInterfaceNumber);
1969
1970         /* Controls are cached on the fly so they don't need to be saved. */
1971         if (intf->cur_altsetting->desc.bInterfaceSubClass ==
1972             UVC_SC_VIDEOCONTROL) {
1973                 mutex_lock(&dev->lock);
1974                 if (dev->users)
1975                         uvc_status_stop(dev);
1976                 mutex_unlock(&dev->lock);
1977                 return 0;
1978         }
1979
1980         list_for_each_entry(stream, &dev->streams, list) {
1981                 if (stream->intf == intf)
1982                         return uvc_video_suspend(stream);
1983         }
1984
1985         uvc_trace(UVC_TRACE_SUSPEND, "Suspend: video streaming USB interface "
1986                         "mismatch.\n");
1987         return -EINVAL;
1988 }
1989
1990 static int __uvc_resume(struct usb_interface *intf, int reset)
1991 {
1992         struct uvc_device *dev = usb_get_intfdata(intf);
1993         struct uvc_streaming *stream;
1994
1995         uvc_trace(UVC_TRACE_SUSPEND, "Resuming interface %u\n",
1996                 intf->cur_altsetting->desc.bInterfaceNumber);
1997
1998         if (intf->cur_altsetting->desc.bInterfaceSubClass ==
1999             UVC_SC_VIDEOCONTROL) {
2000                 int ret = 0;
2001
2002                 if (reset) {
2003                         ret = uvc_ctrl_resume_device(dev);
2004                         if (ret < 0)
2005                                 return ret;
2006                 }
2007
2008                 mutex_lock(&dev->lock);
2009                 if (dev->users)
2010                         ret = uvc_status_start(dev, GFP_NOIO);
2011                 mutex_unlock(&dev->lock);
2012
2013                 return ret;
2014         }
2015
2016         list_for_each_entry(stream, &dev->streams, list) {
2017                 if (stream->intf == intf)
2018                         return uvc_video_resume(stream, reset);
2019         }
2020
2021         uvc_trace(UVC_TRACE_SUSPEND, "Resume: video streaming USB interface "
2022                         "mismatch.\n");
2023         return -EINVAL;
2024 }
2025
2026 static int uvc_resume(struct usb_interface *intf)
2027 {
2028         return __uvc_resume(intf, 0);
2029 }
2030
2031 static int uvc_reset_resume(struct usb_interface *intf)
2032 {
2033         return __uvc_resume(intf, 1);
2034 }
2035
2036 /* ------------------------------------------------------------------------
2037  * Module parameters
2038  */
2039
2040 static int uvc_clock_param_get(char *buffer, struct kernel_param *kp)
2041 {
2042         if (uvc_clock_param == CLOCK_MONOTONIC)
2043                 return sprintf(buffer, "CLOCK_MONOTONIC");
2044         else
2045                 return sprintf(buffer, "CLOCK_REALTIME");
2046 }
2047
2048 static int uvc_clock_param_set(const char *val, struct kernel_param *kp)
2049 {
2050         if (strncasecmp(val, "clock_", strlen("clock_")) == 0)
2051                 val += strlen("clock_");
2052
2053         if (strcasecmp(val, "monotonic") == 0)
2054                 uvc_clock_param = CLOCK_MONOTONIC;
2055         else if (strcasecmp(val, "realtime") == 0)
2056                 uvc_clock_param = CLOCK_REALTIME;
2057         else
2058                 return -EINVAL;
2059
2060         return 0;
2061 }
2062
2063 module_param_call(clock, uvc_clock_param_set, uvc_clock_param_get,
2064                   &uvc_clock_param, S_IRUGO|S_IWUSR);
2065 MODULE_PARM_DESC(clock, "Video buffers timestamp clock");
2066 module_param_named(nodrop, uvc_no_drop_param, uint, S_IRUGO|S_IWUSR);
2067 MODULE_PARM_DESC(nodrop, "Don't drop incomplete frames");
2068 module_param_named(quirks, uvc_quirks_param, uint, S_IRUGO|S_IWUSR);
2069 MODULE_PARM_DESC(quirks, "Forced device quirks");
2070 module_param_named(trace, uvc_trace_param, uint, S_IRUGO|S_IWUSR);
2071 MODULE_PARM_DESC(trace, "Trace level bitmask");
2072 module_param_named(timeout, uvc_timeout_param, uint, S_IRUGO|S_IWUSR);
2073 MODULE_PARM_DESC(timeout, "Streaming control requests timeout");
2074
2075 /* ------------------------------------------------------------------------
2076  * Driver initialization and cleanup
2077  */
2078
2079 /*
2080  * The Logitech cameras listed below have their interface class set to
2081  * VENDOR_SPEC because they don't announce themselves as UVC devices, even
2082  * though they are compliant.
2083  */
2084 static struct usb_device_id uvc_ids[] = {
2085         /* LogiLink Wireless Webcam */
2086         { .match_flags          = USB_DEVICE_ID_MATCH_DEVICE
2087                                 | USB_DEVICE_ID_MATCH_INT_INFO,
2088           .idVendor             = 0x0416,
2089           .idProduct            = 0xa91a,
2090           .bInterfaceClass      = USB_CLASS_VIDEO,
2091           .bInterfaceSubClass   = 1,
2092           .bInterfaceProtocol   = 0,
2093           .driver_info          = UVC_QUIRK_PROBE_MINMAX },
2094         /* Genius eFace 2025 */
2095         { .match_flags          = USB_DEVICE_ID_MATCH_DEVICE
2096                                 | USB_DEVICE_ID_MATCH_INT_INFO,
2097           .idVendor             = 0x0458,
2098           .idProduct            = 0x706e,
2099           .bInterfaceClass      = USB_CLASS_VIDEO,
2100           .bInterfaceSubClass   = 1,
2101           .bInterfaceProtocol   = 0,
2102           .driver_info          = UVC_QUIRK_PROBE_MINMAX },
2103         /* Microsoft Lifecam NX-6000 */
2104         { .match_flags          = USB_DEVICE_ID_MATCH_DEVICE
2105                                 | USB_DEVICE_ID_MATCH_INT_INFO,
2106           .idVendor             = 0x045e,
2107           .idProduct            = 0x00f8,
2108           .bInterfaceClass      = USB_CLASS_VIDEO,
2109           .bInterfaceSubClass   = 1,
2110           .bInterfaceProtocol   = 0,
2111           .driver_info          = UVC_QUIRK_PROBE_MINMAX },
2112         /* Microsoft Lifecam NX-3000 */
2113         { .match_flags          = USB_DEVICE_ID_MATCH_DEVICE
2114                                 | USB_DEVICE_ID_MATCH_INT_INFO,
2115           .idVendor             = 0x045e,
2116           .idProduct            = 0x0721,
2117           .bInterfaceClass      = USB_CLASS_VIDEO,
2118           .bInterfaceSubClass   = 1,
2119           .bInterfaceProtocol   = 0,
2120           .driver_info          = UVC_QUIRK_PROBE_DEF },
2121         /* Microsoft Lifecam VX-7000 */
2122         { .match_flags          = USB_DEVICE_ID_MATCH_DEVICE
2123                                 | USB_DEVICE_ID_MATCH_INT_INFO,
2124           .idVendor             = 0x045e,
2125           .idProduct            = 0x0723,
2126           .bInterfaceClass      = USB_CLASS_VIDEO,
2127           .bInterfaceSubClass   = 1,
2128           .bInterfaceProtocol   = 0,
2129           .driver_info          = UVC_QUIRK_PROBE_MINMAX },
2130         /* Logitech Quickcam Fusion */
2131         { .match_flags          = USB_DEVICE_ID_MATCH_DEVICE
2132                                 | USB_DEVICE_ID_MATCH_INT_INFO,
2133           .idVendor             = 0x046d,
2134           .idProduct            = 0x08c1,
2135           .bInterfaceClass      = USB_CLASS_VENDOR_SPEC,
2136           .bInterfaceSubClass   = 1,
2137           .bInterfaceProtocol   = 0 },
2138         /* Logitech Quickcam Orbit MP */
2139         { .match_flags          = USB_DEVICE_ID_MATCH_DEVICE
2140                                 | USB_DEVICE_ID_MATCH_INT_INFO,
2141           .idVendor             = 0x046d,
2142           .idProduct            = 0x08c2,
2143           .bInterfaceClass      = USB_CLASS_VENDOR_SPEC,
2144           .bInterfaceSubClass   = 1,
2145           .bInterfaceProtocol   = 0 },
2146         /* Logitech Quickcam Pro for Notebook */
2147         { .match_flags          = USB_DEVICE_ID_MATCH_DEVICE
2148                                 | USB_DEVICE_ID_MATCH_INT_INFO,
2149           .idVendor             = 0x046d,
2150           .idProduct            = 0x08c3,
2151           .bInterfaceClass      = USB_CLASS_VENDOR_SPEC,
2152           .bInterfaceSubClass   = 1,
2153           .bInterfaceProtocol   = 0 },
2154         /* Logitech Quickcam Pro 5000 */
2155         { .match_flags          = USB_DEVICE_ID_MATCH_DEVICE
2156                                 | USB_DEVICE_ID_MATCH_INT_INFO,
2157           .idVendor             = 0x046d,
2158           .idProduct            = 0x08c5,
2159           .bInterfaceClass      = USB_CLASS_VENDOR_SPEC,
2160           .bInterfaceSubClass   = 1,
2161           .bInterfaceProtocol   = 0 },
2162         /* Logitech Quickcam OEM Dell Notebook */
2163         { .match_flags          = USB_DEVICE_ID_MATCH_DEVICE
2164                                 | USB_DEVICE_ID_MATCH_INT_INFO,
2165           .idVendor             = 0x046d,
2166           .idProduct            = 0x08c6,
2167           .bInterfaceClass      = USB_CLASS_VENDOR_SPEC,
2168           .bInterfaceSubClass   = 1,
2169           .bInterfaceProtocol   = 0 },
2170         /* Logitech Quickcam OEM Cisco VT Camera II */
2171         { .match_flags          = USB_DEVICE_ID_MATCH_DEVICE
2172                                 | USB_DEVICE_ID_MATCH_INT_INFO,
2173           .idVendor             = 0x046d,
2174           .idProduct            = 0x08c7,
2175           .bInterfaceClass      = USB_CLASS_VENDOR_SPEC,
2176           .bInterfaceSubClass   = 1,
2177           .bInterfaceProtocol   = 0 },
2178         /* Chicony CNF7129 (Asus EEE 100HE) */
2179         { .match_flags          = USB_DEVICE_ID_MATCH_DEVICE
2180                                 | USB_DEVICE_ID_MATCH_INT_INFO,
2181           .idVendor             = 0x04f2,
2182           .idProduct            = 0xb071,
2183           .bInterfaceClass      = USB_CLASS_VIDEO,
2184           .bInterfaceSubClass   = 1,
2185           .bInterfaceProtocol   = 0,
2186           .driver_info          = UVC_QUIRK_RESTRICT_FRAME_RATE },
2187         /* Alcor Micro AU3820 (Future Boy PC USB Webcam) */
2188         { .match_flags          = USB_DEVICE_ID_MATCH_DEVICE
2189                                 | USB_DEVICE_ID_MATCH_INT_INFO,
2190           .idVendor             = 0x058f,
2191           .idProduct            = 0x3820,
2192           .bInterfaceClass      = USB_CLASS_VIDEO,
2193           .bInterfaceSubClass   = 1,
2194           .bInterfaceProtocol   = 0,
2195           .driver_info          = UVC_QUIRK_PROBE_MINMAX },
2196         /* Dell XPS m1530 */
2197         { .match_flags          = USB_DEVICE_ID_MATCH_DEVICE
2198                                 | USB_DEVICE_ID_MATCH_INT_INFO,
2199           .idVendor             = 0x05a9,
2200           .idProduct            = 0x2640,
2201           .bInterfaceClass      = USB_CLASS_VIDEO,
2202           .bInterfaceSubClass   = 1,
2203           .bInterfaceProtocol   = 0,
2204           .driver_info          = UVC_QUIRK_PROBE_DEF },
2205         /* Dell SP2008WFP Monitor */
2206         { .match_flags          = USB_DEVICE_ID_MATCH_DEVICE
2207                                 | USB_DEVICE_ID_MATCH_INT_INFO,
2208           .idVendor             = 0x05a9,
2209           .idProduct            = 0x2641,
2210           .bInterfaceClass      = USB_CLASS_VIDEO,
2211           .bInterfaceSubClass   = 1,
2212           .bInterfaceProtocol   = 0,
2213           .driver_info          = UVC_QUIRK_PROBE_DEF },
2214         /* Dell Alienware X51 */
2215         { .match_flags          = USB_DEVICE_ID_MATCH_DEVICE
2216                                 | USB_DEVICE_ID_MATCH_INT_INFO,
2217           .idVendor             = 0x05a9,
2218           .idProduct            = 0x2643,
2219           .bInterfaceClass      = USB_CLASS_VIDEO,
2220           .bInterfaceSubClass   = 1,
2221           .bInterfaceProtocol   = 0,
2222           .driver_info  = UVC_QUIRK_PROBE_DEF },
2223         /* Dell Studio Hybrid 140g (OmniVision webcam) */
2224         { .match_flags          = USB_DEVICE_ID_MATCH_DEVICE
2225                                 | USB_DEVICE_ID_MATCH_INT_INFO,
2226           .idVendor             = 0x05a9,
2227           .idProduct            = 0x264a,
2228           .bInterfaceClass      = USB_CLASS_VIDEO,
2229           .bInterfaceSubClass   = 1,
2230           .bInterfaceProtocol   = 0,
2231           .driver_info          = UVC_QUIRK_PROBE_DEF },
2232         /* Apple Built-In iSight */
2233         { .match_flags          = USB_DEVICE_ID_MATCH_DEVICE
2234                                 | USB_DEVICE_ID_MATCH_INT_INFO,
2235           .idVendor             = 0x05ac,
2236           .idProduct            = 0x8501,
2237           .bInterfaceClass      = USB_CLASS_VIDEO,
2238           .bInterfaceSubClass   = 1,
2239           .bInterfaceProtocol   = 0,
2240           .driver_info          = UVC_QUIRK_PROBE_MINMAX
2241                                 | UVC_QUIRK_BUILTIN_ISIGHT },
2242         /* Foxlink ("HP Webcam" on HP Mini 5103) */
2243         { .match_flags          = USB_DEVICE_ID_MATCH_DEVICE
2244                                 | USB_DEVICE_ID_MATCH_INT_INFO,
2245           .idVendor             = 0x05c8,
2246           .idProduct            = 0x0403,
2247           .bInterfaceClass      = USB_CLASS_VIDEO,
2248           .bInterfaceSubClass   = 1,
2249           .bInterfaceProtocol   = 0,
2250           .driver_info          = UVC_QUIRK_FIX_BANDWIDTH },
2251         /* Genesys Logic USB 2.0 PC Camera */
2252         { .match_flags          = USB_DEVICE_ID_MATCH_DEVICE
2253                                 | USB_DEVICE_ID_MATCH_INT_INFO,
2254           .idVendor             = 0x05e3,
2255           .idProduct            = 0x0505,
2256           .bInterfaceClass      = USB_CLASS_VIDEO,
2257           .bInterfaceSubClass   = 1,
2258           .bInterfaceProtocol   = 0,
2259           .driver_info          = UVC_QUIRK_STREAM_NO_FID },
2260         /* Hercules Classic Silver */
2261         { .match_flags          = USB_DEVICE_ID_MATCH_DEVICE
2262                                 | USB_DEVICE_ID_MATCH_INT_INFO,
2263           .idVendor             = 0x06f8,
2264           .idProduct            = 0x300c,
2265           .bInterfaceClass      = USB_CLASS_VIDEO,
2266           .bInterfaceSubClass   = 1,
2267           .bInterfaceProtocol   = 0,
2268           .driver_info          = UVC_QUIRK_FIX_BANDWIDTH },
2269         /* ViMicro Vega */
2270         { .match_flags          = USB_DEVICE_ID_MATCH_DEVICE
2271                                 | USB_DEVICE_ID_MATCH_INT_INFO,
2272           .idVendor             = 0x0ac8,
2273           .idProduct            = 0x332d,
2274           .bInterfaceClass      = USB_CLASS_VIDEO,
2275           .bInterfaceSubClass   = 1,
2276           .bInterfaceProtocol   = 0,
2277           .driver_info          = UVC_QUIRK_FIX_BANDWIDTH },
2278         /* ViMicro - Minoru3D */
2279         { .match_flags          = USB_DEVICE_ID_MATCH_DEVICE
2280                                 | USB_DEVICE_ID_MATCH_INT_INFO,
2281           .idVendor             = 0x0ac8,
2282           .idProduct            = 0x3410,
2283           .bInterfaceClass      = USB_CLASS_VIDEO,
2284           .bInterfaceSubClass   = 1,
2285           .bInterfaceProtocol   = 0,
2286           .driver_info          = UVC_QUIRK_FIX_BANDWIDTH },
2287         /* ViMicro Venus - Minoru3D */
2288         { .match_flags          = USB_DEVICE_ID_MATCH_DEVICE
2289                                 | USB_DEVICE_ID_MATCH_INT_INFO,
2290           .idVendor             = 0x0ac8,
2291           .idProduct            = 0x3420,
2292           .bInterfaceClass      = USB_CLASS_VIDEO,
2293           .bInterfaceSubClass   = 1,
2294           .bInterfaceProtocol   = 0,
2295           .driver_info          = UVC_QUIRK_FIX_BANDWIDTH },
2296         /* Ophir Optronics - SPCAM 620U */
2297         { .match_flags          = USB_DEVICE_ID_MATCH_DEVICE
2298                                 | USB_DEVICE_ID_MATCH_INT_INFO,
2299           .idVendor             = 0x0bd3,
2300           .idProduct            = 0x0555,
2301           .bInterfaceClass      = USB_CLASS_VIDEO,
2302           .bInterfaceSubClass   = 1,
2303           .bInterfaceProtocol   = 0,
2304           .driver_info          = UVC_QUIRK_PROBE_MINMAX },
2305         /* MT6227 */
2306         { .match_flags          = USB_DEVICE_ID_MATCH_DEVICE
2307                                 | USB_DEVICE_ID_MATCH_INT_INFO,
2308           .idVendor             = 0x0e8d,
2309           .idProduct            = 0x0004,
2310           .bInterfaceClass      = USB_CLASS_VIDEO,
2311           .bInterfaceSubClass   = 1,
2312           .bInterfaceProtocol   = 0,
2313           .driver_info          = UVC_QUIRK_PROBE_MINMAX
2314                                 | UVC_QUIRK_PROBE_DEF },
2315         /* IMC Networks (Medion Akoya) */
2316         { .match_flags          = USB_DEVICE_ID_MATCH_DEVICE
2317                                 | USB_DEVICE_ID_MATCH_INT_INFO,
2318           .idVendor             = 0x13d3,
2319           .idProduct            = 0x5103,
2320           .bInterfaceClass      = USB_CLASS_VIDEO,
2321           .bInterfaceSubClass   = 1,
2322           .bInterfaceProtocol   = 0,
2323           .driver_info          = UVC_QUIRK_STREAM_NO_FID },
2324         /* JMicron USB2.0 XGA WebCam */
2325         { .match_flags          = USB_DEVICE_ID_MATCH_DEVICE
2326                                 | USB_DEVICE_ID_MATCH_INT_INFO,
2327           .idVendor             = 0x152d,
2328           .idProduct            = 0x0310,
2329           .bInterfaceClass      = USB_CLASS_VIDEO,
2330           .bInterfaceSubClass   = 1,
2331           .bInterfaceProtocol   = 0,
2332           .driver_info          = UVC_QUIRK_PROBE_MINMAX },
2333         /* Syntek (HP Spartan) */
2334         { .match_flags          = USB_DEVICE_ID_MATCH_DEVICE
2335                                 | USB_DEVICE_ID_MATCH_INT_INFO,
2336           .idVendor             = 0x174f,
2337           .idProduct            = 0x5212,
2338           .bInterfaceClass      = USB_CLASS_VIDEO,
2339           .bInterfaceSubClass   = 1,
2340           .bInterfaceProtocol   = 0,
2341           .driver_info          = UVC_QUIRK_STREAM_NO_FID },
2342         /* Syntek (Samsung Q310) */
2343         { .match_flags          = USB_DEVICE_ID_MATCH_DEVICE
2344                                 | USB_DEVICE_ID_MATCH_INT_INFO,
2345           .idVendor             = 0x174f,
2346           .idProduct            = 0x5931,
2347           .bInterfaceClass      = USB_CLASS_VIDEO,
2348           .bInterfaceSubClass   = 1,
2349           .bInterfaceProtocol   = 0,
2350           .driver_info          = UVC_QUIRK_STREAM_NO_FID },
2351         /* Syntek (Packard Bell EasyNote MX52 */
2352         { .match_flags          = USB_DEVICE_ID_MATCH_DEVICE
2353                                 | USB_DEVICE_ID_MATCH_INT_INFO,
2354           .idVendor             = 0x174f,
2355           .idProduct            = 0x8a12,
2356           .bInterfaceClass      = USB_CLASS_VIDEO,
2357           .bInterfaceSubClass   = 1,
2358           .bInterfaceProtocol   = 0,
2359           .driver_info          = UVC_QUIRK_STREAM_NO_FID },
2360         /* Syntek (Asus F9SG) */
2361         { .match_flags          = USB_DEVICE_ID_MATCH_DEVICE
2362                                 | USB_DEVICE_ID_MATCH_INT_INFO,
2363           .idVendor             = 0x174f,
2364           .idProduct            = 0x8a31,
2365           .bInterfaceClass      = USB_CLASS_VIDEO,
2366           .bInterfaceSubClass   = 1,
2367           .bInterfaceProtocol   = 0,
2368           .driver_info          = UVC_QUIRK_STREAM_NO_FID },
2369         /* Syntek (Asus U3S) */
2370         { .match_flags          = USB_DEVICE_ID_MATCH_DEVICE
2371                                 | USB_DEVICE_ID_MATCH_INT_INFO,
2372           .idVendor             = 0x174f,
2373           .idProduct            = 0x8a33,
2374           .bInterfaceClass      = USB_CLASS_VIDEO,
2375           .bInterfaceSubClass   = 1,
2376           .bInterfaceProtocol   = 0,
2377           .driver_info          = UVC_QUIRK_STREAM_NO_FID },
2378         /* Syntek (JAOtech Smart Terminal) */
2379         { .match_flags          = USB_DEVICE_ID_MATCH_DEVICE
2380                                 | USB_DEVICE_ID_MATCH_INT_INFO,
2381           .idVendor             = 0x174f,
2382           .idProduct            = 0x8a34,
2383           .bInterfaceClass      = USB_CLASS_VIDEO,
2384           .bInterfaceSubClass   = 1,
2385           .bInterfaceProtocol   = 0,
2386           .driver_info          = UVC_QUIRK_STREAM_NO_FID },
2387         /* Miricle 307K */
2388         { .match_flags          = USB_DEVICE_ID_MATCH_DEVICE
2389                                 | USB_DEVICE_ID_MATCH_INT_INFO,
2390           .idVendor             = 0x17dc,
2391           .idProduct            = 0x0202,
2392           .bInterfaceClass      = USB_CLASS_VIDEO,
2393           .bInterfaceSubClass   = 1,
2394           .bInterfaceProtocol   = 0,
2395           .driver_info          = UVC_QUIRK_STREAM_NO_FID },
2396         /* Lenovo Thinkpad SL400/SL500 */
2397         { .match_flags          = USB_DEVICE_ID_MATCH_DEVICE
2398                                 | USB_DEVICE_ID_MATCH_INT_INFO,
2399           .idVendor             = 0x17ef,
2400           .idProduct            = 0x480b,
2401           .bInterfaceClass      = USB_CLASS_VIDEO,
2402           .bInterfaceSubClass   = 1,
2403           .bInterfaceProtocol   = 0,
2404           .driver_info          = UVC_QUIRK_STREAM_NO_FID },
2405         /* Aveo Technology USB 2.0 Camera */
2406         { .match_flags          = USB_DEVICE_ID_MATCH_DEVICE
2407                                 | USB_DEVICE_ID_MATCH_INT_INFO,
2408           .idVendor             = 0x1871,
2409           .idProduct            = 0x0306,
2410           .bInterfaceClass      = USB_CLASS_VIDEO,
2411           .bInterfaceSubClass   = 1,
2412           .bInterfaceProtocol   = 0,
2413           .driver_info          = UVC_QUIRK_PROBE_MINMAX
2414                                 | UVC_QUIRK_PROBE_EXTRAFIELDS },
2415         /* Ecamm Pico iMage */
2416         { .match_flags          = USB_DEVICE_ID_MATCH_DEVICE
2417                                 | USB_DEVICE_ID_MATCH_INT_INFO,
2418           .idVendor             = 0x18cd,
2419           .idProduct            = 0xcafe,
2420           .bInterfaceClass      = USB_CLASS_VIDEO,
2421           .bInterfaceSubClass   = 1,
2422           .bInterfaceProtocol   = 0,
2423           .driver_info          = UVC_QUIRK_PROBE_EXTRAFIELDS },
2424         /* Manta MM-353 Plako */
2425         { .match_flags          = USB_DEVICE_ID_MATCH_DEVICE
2426                                 | USB_DEVICE_ID_MATCH_INT_INFO,
2427           .idVendor             = 0x18ec,
2428           .idProduct            = 0x3188,
2429           .bInterfaceClass      = USB_CLASS_VIDEO,
2430           .bInterfaceSubClass   = 1,
2431           .bInterfaceProtocol   = 0,
2432           .driver_info          = UVC_QUIRK_PROBE_MINMAX },
2433         /* FSC WebCam V30S */
2434         { .match_flags          = USB_DEVICE_ID_MATCH_DEVICE
2435                                 | USB_DEVICE_ID_MATCH_INT_INFO,
2436           .idVendor             = 0x18ec,
2437           .idProduct            = 0x3288,
2438           .bInterfaceClass      = USB_CLASS_VIDEO,
2439           .bInterfaceSubClass   = 1,
2440           .bInterfaceProtocol   = 0,
2441           .driver_info          = UVC_QUIRK_PROBE_MINMAX },
2442         /* Arkmicro unbranded */
2443         { .match_flags          = USB_DEVICE_ID_MATCH_DEVICE
2444                                 | USB_DEVICE_ID_MATCH_INT_INFO,
2445           .idVendor             = 0x18ec,
2446           .idProduct            = 0x3290,
2447           .bInterfaceClass      = USB_CLASS_VIDEO,
2448           .bInterfaceSubClass   = 1,
2449           .bInterfaceProtocol   = 0,
2450           .driver_info          = UVC_QUIRK_PROBE_DEF },
2451         /* The Imaging Source USB CCD cameras */
2452         { .match_flags          = USB_DEVICE_ID_MATCH_DEVICE
2453                                 | USB_DEVICE_ID_MATCH_INT_INFO,
2454           .idVendor             = 0x199e,
2455           .idProduct            = 0x8102,
2456           .bInterfaceClass      = USB_CLASS_VENDOR_SPEC,
2457           .bInterfaceSubClass   = 1,
2458           .bInterfaceProtocol   = 0 },
2459         /* Bodelin ProScopeHR */
2460         { .match_flags          = USB_DEVICE_ID_MATCH_DEVICE
2461                                 | USB_DEVICE_ID_MATCH_DEV_HI
2462                                 | USB_DEVICE_ID_MATCH_INT_INFO,
2463           .idVendor             = 0x19ab,
2464           .idProduct            = 0x1000,
2465           .bcdDevice_hi         = 0x0126,
2466           .bInterfaceClass      = USB_CLASS_VIDEO,
2467           .bInterfaceSubClass   = 1,
2468           .bInterfaceProtocol   = 0,
2469           .driver_info          = UVC_QUIRK_STATUS_INTERVAL },
2470         /* MSI StarCam 370i */
2471         { .match_flags          = USB_DEVICE_ID_MATCH_DEVICE
2472                                 | USB_DEVICE_ID_MATCH_INT_INFO,
2473           .idVendor             = 0x1b3b,
2474           .idProduct            = 0x2951,
2475           .bInterfaceClass      = USB_CLASS_VIDEO,
2476           .bInterfaceSubClass   = 1,
2477           .bInterfaceProtocol   = 0,
2478           .driver_info          = UVC_QUIRK_PROBE_MINMAX },
2479         /* SiGma Micro USB Web Camera */
2480         { .match_flags          = USB_DEVICE_ID_MATCH_DEVICE
2481                                 | USB_DEVICE_ID_MATCH_INT_INFO,
2482           .idVendor             = 0x1c4f,
2483           .idProduct            = 0x3000,
2484           .bInterfaceClass      = USB_CLASS_VIDEO,
2485           .bInterfaceSubClass   = 1,
2486           .bInterfaceProtocol   = 0,
2487           .driver_info          = UVC_QUIRK_PROBE_MINMAX
2488                                 | UVC_QUIRK_IGNORE_SELECTOR_UNIT },
2489         /* Generic USB Video Class */
2490         { USB_INTERFACE_INFO(USB_CLASS_VIDEO, 1, 0) },
2491         {}
2492 };
2493
2494 MODULE_DEVICE_TABLE(usb, uvc_ids);
2495
2496 struct uvc_driver uvc_driver = {
2497         .driver = {
2498                 .name           = "uvcvideo",
2499                 .probe          = uvc_probe,
2500                 .disconnect     = uvc_disconnect,
2501                 .suspend        = uvc_suspend,
2502                 .resume         = uvc_resume,
2503                 .reset_resume   = uvc_reset_resume,
2504                 .id_table       = uvc_ids,
2505                 .supports_autosuspend = 1,
2506         },
2507 };
2508
2509 static int __init uvc_init(void)
2510 {
2511         int ret;
2512
2513         uvc_debugfs_init();
2514
2515         ret = usb_register(&uvc_driver.driver);
2516         if (ret < 0) {
2517                 uvc_debugfs_cleanup();
2518                 return ret;
2519         }
2520
2521         printk(KERN_INFO DRIVER_DESC " (" DRIVER_VERSION ")\n");
2522         return 0;
2523 }
2524
2525 static void __exit uvc_cleanup(void)
2526 {
2527         usb_deregister(&uvc_driver.driver);
2528         uvc_debugfs_cleanup();
2529 }
2530
2531 module_init(uvc_init);
2532 module_exit(uvc_cleanup);
2533
2534 MODULE_AUTHOR(DRIVER_AUTHOR);
2535 MODULE_DESCRIPTION(DRIVER_DESC);
2536 MODULE_LICENSE("GPL");
2537 MODULE_VERSION(DRIVER_VERSION);
2538