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