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