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