FILE
uvc_driver.c
File preview with syntax highlighting.
linux-6.19.14/drivers/media/usb/uvc/uvc_driver.c
1// SPDX-License-Identifier: GPL-2.0-or-later 2/* 3 * uvc_driver.c -- USB Video Class driver 4 * 5 * Copyright (C) 2005-2010 6 * Laurent Pinchart (laurent.pinchart@ideasonboard.com) 7 */ 8 9#include <linux/atomic.h> 10#include <linux/bits.h> 11#include <linux/gpio/consumer.h> 12#include <linux/kernel.h> 13#include <linux/list.h> 14#include <linux/module.h> 15#include <linux/slab.h> 16#include <linux/usb.h> 17#include <linux/usb/quirks.h> 18#include <linux/usb/uvc.h> 19#include <linux/videodev2.h> 20#include <linux/vmalloc.h> 21#include <linux/wait.h> 22#include <linux/unaligned.h> 23 24#include <media/v4l2-common.h> 25#include <media/v4l2-ioctl.h> 26 27#include "uvcvideo.h" 28 29#define DRIVER_AUTHOR "Laurent Pinchart " \ 30 "<laurent.pinchart@ideasonboard.com>" 31#define DRIVER_DESC "USB Video Class driver" 32 33unsigned int uvc_clock_param = CLOCK_MONOTONIC; 34unsigned int uvc_hw_timestamps_param; 35unsigned int uvc_no_drop_param = 1; 36static unsigned int uvc_quirks_param = -1; 37unsigned int uvc_dbg_param; 38unsigned int uvc_timeout_param = UVC_CTRL_STREAMING_TIMEOUT; 39 40static struct usb_driver uvc_driver; 41 42/* ------------------------------------------------------------------------ 43 * Utility functions 44 */ 45 46struct usb_host_endpoint *uvc_find_endpoint(struct usb_host_interface *alts, 47 u8 epaddr) 48{ 49 struct usb_host_endpoint *ep; 50 unsigned int i; 51 52 for (i = 0; i < alts->desc.bNumEndpoints; ++i) { 53 ep = &alts->endpoint[i]; 54 if (ep->desc.bEndpointAddress == epaddr) 55 return ep; 56 } 57 58 return NULL; 59} 60 61static enum v4l2_colorspace uvc_colorspace(const u8 primaries) 62{ 63 static const enum v4l2_colorspace colorprimaries[] = { 64 V4L2_COLORSPACE_SRGB, /* Unspecified */ 65 V4L2_COLORSPACE_SRGB, 66 V4L2_COLORSPACE_470_SYSTEM_M, 67 V4L2_COLORSPACE_470_SYSTEM_BG, 68 V4L2_COLORSPACE_SMPTE170M, 69 V4L2_COLORSPACE_SMPTE240M, 70 }; 71 72 if (primaries < ARRAY_SIZE(colorprimaries)) 73 return colorprimaries[primaries]; 74 75 return V4L2_COLORSPACE_SRGB; /* Reserved */ 76} 77 78static enum v4l2_xfer_func uvc_xfer_func(const u8 transfer_characteristics) 79{ 80 /* 81 * V4L2 does not currently have definitions for all possible values of 82 * UVC transfer characteristics. If v4l2_xfer_func is extended with new 83 * values, the mapping below should be updated. 84 * 85 * Substitutions are taken from the mapping given for 86 * V4L2_XFER_FUNC_DEFAULT documented in videodev2.h. 87 */ 88 static const enum v4l2_xfer_func xfer_funcs[] = { 89 V4L2_XFER_FUNC_DEFAULT, /* Unspecified */ 90 V4L2_XFER_FUNC_709, 91 V4L2_XFER_FUNC_709, /* Substitution for BT.470-2 M */ 92 V4L2_XFER_FUNC_709, /* Substitution for BT.470-2 B, G */ 93 V4L2_XFER_FUNC_709, /* Substitution for SMPTE 170M */ 94 V4L2_XFER_FUNC_SMPTE240M, 95 V4L2_XFER_FUNC_NONE, 96 V4L2_XFER_FUNC_SRGB, 97 }; 98 99 if (transfer_characteristics < ARRAY_SIZE(xfer_funcs)) 100 return xfer_funcs[transfer_characteristics]; 101 102 return V4L2_XFER_FUNC_DEFAULT; /* Reserved */ 103} 104 105static enum v4l2_ycbcr_encoding uvc_ycbcr_enc(const u8 matrix_coefficients) 106{ 107 /* 108 * V4L2 does not currently have definitions for all possible values of 109 * UVC matrix coefficients. If v4l2_ycbcr_encoding is extended with new 110 * values, the mapping below should be updated. 111 * 112 * Substitutions are taken from the mapping given for 113 * V4L2_YCBCR_ENC_DEFAULT documented in videodev2.h. 114 * 115 * FCC is assumed to be close enough to 601. 116 */ 117 static const enum v4l2_ycbcr_encoding ycbcr_encs[] = { 118 V4L2_YCBCR_ENC_DEFAULT, /* Unspecified */ 119 V4L2_YCBCR_ENC_709, 120 V4L2_YCBCR_ENC_601, /* Substitution for FCC */ 121 V4L2_YCBCR_ENC_601, /* Substitution for BT.470-2 B, G */ 122 V4L2_YCBCR_ENC_601, 123 V4L2_YCBCR_ENC_SMPTE240M, 124 }; 125 126 if (matrix_coefficients < ARRAY_SIZE(ycbcr_encs)) 127 return ycbcr_encs[matrix_coefficients]; 128 129 return V4L2_YCBCR_ENC_DEFAULT; /* Reserved */ 130} 131 132/* ------------------------------------------------------------------------ 133 * Terminal and unit management 134 */ 135 136struct uvc_entity *uvc_entity_by_id(struct uvc_device *dev, int id) 137{ 138 struct uvc_entity *entity; 139 140 if (id == UVC_INVALID_ENTITY_ID) 141 return NULL; 142 143 list_for_each_entry(entity, &dev->entities, list) { 144 if (entity->id == id) 145 return entity; 146 } 147 148 return NULL; 149} 150 151static struct uvc_entity *uvc_entity_by_reference(struct uvc_device *dev, 152 int id, struct uvc_entity *entity) 153{ 154 unsigned int i; 155 156 if (entity == NULL) 157 entity = list_entry(&dev->entities, struct uvc_entity, list); 158 159 list_for_each_entry_continue(entity, &dev->entities, list) { 160 for (i = 0; i < entity->bNrInPins; ++i) 161 if (entity->baSourceID[i] == id) 162 return entity; 163 } 164 165 return NULL; 166} 167 168static struct uvc_streaming *uvc_stream_for_terminal(struct uvc_device *dev, 169 struct uvc_entity *term) 170{ 171 u16 id = UVC_HARDWARE_ENTITY_ID(term->id); 172 struct uvc_streaming *stream; 173 174 list_for_each_entry(stream, &dev->streams, list) { 175 if (stream->header.bTerminalLink == id) 176 return stream; 177 } 178 179 return NULL; 180} 181 182/* ------------------------------------------------------------------------ 183 * Streaming Object Management 184 */ 185 186static void uvc_stream_delete(struct uvc_streaming *stream) 187{ 188 if (stream->async_wq) 189 destroy_workqueue(stream->async_wq); 190 191 usb_put_intf(stream->intf); 192 193 kfree(stream->formats); 194 kfree(stream->header.bmaControls); 195 kfree(stream); 196} 197 198static struct uvc_streaming *uvc_stream_new(struct uvc_device *dev, 199 struct usb_interface *intf) 200{ 201 struct uvc_streaming *stream; 202 203 stream = kzalloc(sizeof(*stream), GFP_KERNEL); 204 if (stream == NULL) 205 return NULL; 206 207 stream->dev = dev; 208 stream->intf = usb_get_intf(intf); 209 stream->intfnum = intf->cur_altsetting->desc.bInterfaceNumber; 210 211 /* Allocate a stream specific work queue for asynchronous tasks. */ 212 stream->async_wq = alloc_workqueue("uvcvideo", WQ_UNBOUND | WQ_HIGHPRI, 213 0); 214 if (!stream->async_wq) { 215 uvc_stream_delete(stream); 216 return NULL; 217 } 218 219 return stream; 220} 221 222/* ------------------------------------------------------------------------ 223 * Descriptors parsing 224 */ 225 226static int uvc_parse_frame(struct uvc_device *dev, 227 struct uvc_streaming *streaming, 228 struct uvc_format *format, struct uvc_frame *frame, 229 u32 **intervals, u8 ftype, int width_multiplier, 230 const unsigned char *buffer, int buflen) 231{ 232 struct usb_host_interface *alts = streaming->intf->cur_altsetting; 233 unsigned int maxIntervalIndex; 234 unsigned int interval; 235 unsigned int i, n; 236 237 if (ftype != UVC_VS_FRAME_FRAME_BASED) 238 n = buflen > 25 ? buffer[25] : 0; 239 else 240 n = buflen > 21 ? buffer[21] : 0; 241 242 n = n ? n : 3; 243 244 if (buflen < 26 + 4 * n) { 245 uvc_dbg(dev, DESCR, 246 "device %d videostreaming interface %d FRAME error\n", 247 dev->udev->devnum, alts->desc.bInterfaceNumber); 248 return -EINVAL; 249 } 250 251 frame->bFrameIndex = buffer[3]; 252 frame->bmCapabilities = buffer[4]; 253 frame->wWidth = get_unaligned_le16(&buffer[5]) * width_multiplier; 254 frame->wHeight = get_unaligned_le16(&buffer[7]); 255 frame->dwMinBitRate = get_unaligned_le32(&buffer[9]); 256 frame->dwMaxBitRate = get_unaligned_le32(&buffer[13]); 257 if (ftype != UVC_VS_FRAME_FRAME_BASED) { 258 frame->dwMaxVideoFrameBufferSize = 259 get_unaligned_le32(&buffer[17]); 260 frame->dwDefaultFrameInterval = 261 get_unaligned_le32(&buffer[21]); 262 frame->bFrameIntervalType = buffer[25]; 263 } else { 264 frame->dwMaxVideoFrameBufferSize = 0; 265 frame->dwDefaultFrameInterval = 266 get_unaligned_le32(&buffer[17]); 267 frame->bFrameIntervalType = buffer[21]; 268 } 269 270 /* 271 * Copy the frame intervals. 272 * 273 * Some bogus devices report dwMinFrameInterval equal to 274 * dwMaxFrameInterval and have dwFrameIntervalStep set to zero. Setting 275 * all null intervals to 1 fixes the problem and some other divisions 276 * by zero that could happen. 277 */ 278 frame->dwFrameInterval = *intervals; 279 280 for (i = 0; i < n; ++i) { 281 interval = get_unaligned_le32(&buffer[26 + 4 * i]); 282 (*intervals)[i] = interval ? interval : 1; 283 } 284 285 /* 286 * Apply more fixes, quirks and workarounds to handle incorrect or 287 * broken descriptors. 288 */ 289 290 /* 291 * Several UVC chipsets screw up dwMaxVideoFrameBufferSize completely. 292 * Observed behaviours range from setting the value to 1.1x the actual 293 * frame size to hardwiring the 16 low bits to 0. This results in a 294 * higher than necessary memory usage as well as a wrong image size 295 * information. For uncompressed formats this can be fixed by computing 296 * the value from the frame size. 297 */ 298 if (!(format->flags & UVC_FMT_FLAG_COMPRESSED)) 299 frame->dwMaxVideoFrameBufferSize = format->bpp * frame->wWidth 300 * frame->wHeight / 8; 301 302 /* 303 * Clamp the default frame interval to the boundaries. A zero 304 * bFrameIntervalType value indicates a continuous frame interval 305 * range, with dwFrameInterval[0] storing the minimum value and 306 * dwFrameInterval[1] storing the maximum value. 307 */ 308 maxIntervalIndex = frame->bFrameIntervalType ? n - 1 : 1; 309 frame->dwDefaultFrameInterval = 310 clamp(frame->dwDefaultFrameInterval, 311 frame->dwFrameInterval[0], 312 frame->dwFrameInterval[maxIntervalIndex]); 313 314 /* 315 * Some devices report frame intervals that are not functional. If the 316 * corresponding quirk is set, restrict operation to the first interval 317 * only. 318 */ 319 if (dev->quirks & UVC_QUIRK_RESTRICT_FRAME_RATE) { 320 frame->bFrameIntervalType = 1; 321 (*intervals)[0] = frame->dwDefaultFrameInterval; 322 } 323 324 uvc_dbg(dev, DESCR, "- %ux%u (%u.%u fps)\n", 325 frame->wWidth, frame->wHeight, 326 10000000 / frame->dwDefaultFrameInterval, 327 (100000000 / frame->dwDefaultFrameInterval) % 10); 328 329 *intervals += n; 330 331 return buffer[0]; 332} 333 334static int uvc_parse_format(struct uvc_device *dev, 335 struct uvc_streaming *streaming, struct uvc_format *format, 336 struct uvc_frame *frames, u32 **intervals, const unsigned char *buffer, 337 int buflen) 338{ 339 struct usb_host_interface *alts = streaming->intf->cur_altsetting; 340 const struct uvc_format_desc *fmtdesc; 341 struct uvc_frame *frame; 342 const unsigned char *start = buffer; 343 unsigned int width_multiplier = 1; 344 unsigned int i, n; 345 u8 ftype; 346 int ret; 347 348 if (buflen < 4) 349 return -EINVAL; 350 351 format->type = buffer[2]; 352 format->index = buffer[3]; 353 format->frames = frames; 354 355 switch (buffer[2]) { 356 case UVC_VS_FORMAT_UNCOMPRESSED: 357 case UVC_VS_FORMAT_FRAME_BASED: 358 n = buffer[2] == UVC_VS_FORMAT_UNCOMPRESSED ? 27 : 28; 359 if (buflen < n) { 360 uvc_dbg(dev, DESCR, 361 "device %d videostreaming interface %d FORMAT error\n", 362 dev->udev->devnum, 363 alts->desc.bInterfaceNumber); 364 return -EINVAL; 365 } 366 367 /* Find the format descriptor from its GUID. */ 368 fmtdesc = uvc_format_by_guid(&buffer[5]); 369 370 if (!fmtdesc) { 371 /* 372 * Unknown video formats are not fatal errors, the 373 * caller will skip this descriptor. 374 */ 375 dev_info(&streaming->intf->dev, 376 "Unknown video format %pUl\n", &buffer[5]); 377 return 0; 378 } 379 380 format->fcc = fmtdesc->fcc; 381 format->bpp = buffer[21]; 382 383 /* 384 * Some devices report a format that doesn't match what they 385 * really send. 386 */ 387 if (dev->quirks & UVC_QUIRK_FORCE_Y8) { 388 if (format->fcc == V4L2_PIX_FMT_YUYV) { 389 format->fcc = V4L2_PIX_FMT_GREY; 390 format->bpp = 8; 391 width_multiplier = 2; 392 } 393 } 394 395 /* Some devices report bpp that doesn't match the format. */ 396 if (dev->quirks & UVC_QUIRK_FORCE_BPP) { 397 const struct v4l2_format_info *info = 398 v4l2_format_info(format->fcc); 399 400 if (info) { 401 unsigned int div = info->hdiv * info->vdiv; 402 403 n = info->bpp[0] * div; 404 for (i = 1; i < info->comp_planes; i++) 405 n += info->bpp[i]; 406 407 format->bpp = DIV_ROUND_UP(8 * n, div); 408 } 409 } 410 411 if (buffer[2] == UVC_VS_FORMAT_UNCOMPRESSED) { 412 ftype = UVC_VS_FRAME_UNCOMPRESSED; 413 } else { 414 ftype = UVC_VS_FRAME_FRAME_BASED; 415 if (buffer[27]) 416 format->flags = UVC_FMT_FLAG_COMPRESSED; 417 } 418 break; 419 420 case UVC_VS_FORMAT_MJPEG: 421 if (buflen < 11) { 422 uvc_dbg(dev, DESCR, 423 "device %d videostreaming interface %d FORMAT error\n", 424 dev->udev->devnum, 425 alts->desc.bInterfaceNumber); 426 return -EINVAL; 427 } 428 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_dbg(dev, DESCR, 438 "device %d videostreaming interface %d FORMAT error\n", 439 dev->udev->devnum, 440 alts->desc.bInterfaceNumber); 441 return -EINVAL; 442 } 443 444 if ((buffer[8] & 0x7f) > 2) { 445 uvc_dbg(dev, DESCR, 446 "device %d videostreaming interface %d: unknown DV format %u\n", 447 dev->udev->devnum, 448 alts->desc.bInterfaceNumber, buffer[8]); 449 return -EINVAL; 450 } 451 452 format->fcc = V4L2_PIX_FMT_DV; 453 format->flags = UVC_FMT_FLAG_COMPRESSED | UVC_FMT_FLAG_STREAM; 454 format->bpp = 0; 455 ftype = 0; 456 457 /* Create a dummy frame descriptor. */ 458 frame = &frames[0]; 459 memset(frame, 0, sizeof(*frame)); 460 frame->bFrameIntervalType = 1; 461 frame->dwDefaultFrameInterval = 1; 462 frame->dwFrameInterval = *intervals; 463 *(*intervals)++ = 1; 464 format->nframes = 1; 465 break; 466 467 case UVC_VS_FORMAT_MPEG2TS: 468 case UVC_VS_FORMAT_STREAM_BASED: 469 /* Not supported yet. */ 470 default: 471 uvc_dbg(dev, DESCR, 472 "device %d videostreaming interface %d unsupported format %u\n", 473 dev->udev->devnum, alts->desc.bInterfaceNumber, 474 buffer[2]); 475 return -EINVAL; 476 } 477 478 uvc_dbg(dev, DESCR, "Found format %p4cc", &format->fcc); 479 480 buflen -= buffer[0]; 481 buffer += buffer[0]; 482 483 /* 484 * Parse the frame descriptors. Only uncompressed, MJPEG and frame 485 * based formats have frame descriptors. 486 */ 487 if (ftype) { 488 while (buflen > 2 && buffer[1] == USB_DT_CS_INTERFACE && 489 buffer[2] == ftype) { 490 frame = &frames[format->nframes]; 491 ret = uvc_parse_frame(dev, streaming, format, frame, 492 intervals, ftype, width_multiplier, 493 buffer, buflen); 494 if (ret < 0) 495 return ret; 496 format->nframes++; 497 buflen -= ret; 498 buffer += ret; 499 } 500 } 501 502 if (buflen > 2 && buffer[1] == USB_DT_CS_INTERFACE && 503 buffer[2] == UVC_VS_STILL_IMAGE_FRAME) { 504 buflen -= buffer[0]; 505 buffer += buffer[0]; 506 } 507 508 if (buflen > 2 && buffer[1] == USB_DT_CS_INTERFACE && 509 buffer[2] == UVC_VS_COLORFORMAT) { 510 if (buflen < 6) { 511 uvc_dbg(dev, DESCR, 512 "device %d videostreaming interface %d COLORFORMAT error\n", 513 dev->udev->devnum, 514 alts->desc.bInterfaceNumber); 515 return -EINVAL; 516 } 517 518 format->colorspace = uvc_colorspace(buffer[3]); 519 format->xfer_func = uvc_xfer_func(buffer[4]); 520 format->ycbcr_enc = uvc_ycbcr_enc(buffer[5]); 521 522 buflen -= buffer[0]; 523 buffer += buffer[0]; 524 } else { 525 format->colorspace = V4L2_COLORSPACE_SRGB; 526 } 527 528 return buffer - start; 529} 530 531static int uvc_parse_streaming(struct uvc_device *dev, 532 struct usb_interface *intf) 533{ 534 struct uvc_streaming *streaming = NULL; 535 struct uvc_format *format; 536 struct uvc_frame *frame; 537 struct usb_host_interface *alts = &intf->altsetting[0]; 538 const unsigned char *_buffer, *buffer = alts->extra; 539 int _buflen, buflen = alts->extralen; 540 unsigned int nformats = 0, nframes = 0, nintervals = 0; 541 unsigned int size, i, n, p; 542 u32 *interval; 543 u32 psize; 544 int ret = -EINVAL; 545 546 if (intf->cur_altsetting->desc.bInterfaceSubClass 547 != UVC_SC_VIDEOSTREAMING) { 548 uvc_dbg(dev, DESCR, 549 "device %d interface %d isn't a video streaming interface\n", 550 dev->udev->devnum, 551 intf->altsetting[0].desc.bInterfaceNumber); 552 return -EINVAL; 553 } 554 555 if (usb_driver_claim_interface(&uvc_driver, intf, dev)) { 556 uvc_dbg(dev, DESCR, 557 "device %d interface %d is already claimed\n", 558 dev->udev->devnum, 559 intf->altsetting[0].desc.bInterfaceNumber); 560 return -EINVAL; 561 } 562 563 streaming = uvc_stream_new(dev, intf); 564 if (streaming == NULL) { 565 usb_driver_release_interface(&uvc_driver, intf); 566 return -ENOMEM; 567 } 568 569 /* 570 * The Pico iMage webcam has its class-specific interface descriptors 571 * after the endpoint descriptors. 572 */ 573 if (buflen == 0) { 574 for (i = 0; i < alts->desc.bNumEndpoints; ++i) { 575 struct usb_host_endpoint *ep = &alts->endpoint[i]; 576 577 if (ep->extralen == 0) 578 continue; 579 580 if (ep->extralen > 2 && 581 ep->extra[1] == USB_DT_CS_INTERFACE) { 582 uvc_dbg(dev, DESCR, 583 "trying extra data from endpoint %u\n", 584 i); 585 buffer = alts->endpoint[i].extra; 586 buflen = alts->endpoint[i].extralen; 587 break; 588 } 589 } 590 } 591 592 /* Skip the standard interface descriptors. */ 593 while (buflen > 2 && buffer[1] != USB_DT_CS_INTERFACE) { 594 buflen -= buffer[0]; 595 buffer += buffer[0]; 596 } 597 598 if (buflen <= 2) { 599 uvc_dbg(dev, DESCR, 600 "no class-specific streaming interface descriptors found\n"); 601 goto error; 602 } 603 604 /* Parse the header descriptor. */ 605 switch (buffer[2]) { 606 case UVC_VS_OUTPUT_HEADER: 607 streaming->type = V4L2_BUF_TYPE_VIDEO_OUTPUT; 608 size = 9; 609 break; 610 611 case UVC_VS_INPUT_HEADER: 612 streaming->type = V4L2_BUF_TYPE_VIDEO_CAPTURE; 613 size = 13; 614 break; 615 616 default: 617 uvc_dbg(dev, DESCR, 618 "device %d videostreaming interface %d HEADER descriptor not found\n", 619 dev->udev->devnum, alts->desc.bInterfaceNumber); 620 goto error; 621 } 622 623 p = buflen >= 4 ? buffer[3] : 0; 624 n = buflen >= size ? buffer[size-1] : 0; 625 626 if (buflen < size + p*n) { 627 uvc_dbg(dev, DESCR, 628 "device %d videostreaming interface %d HEADER descriptor is invalid\n", 629 dev->udev->devnum, alts->desc.bInterfaceNumber); 630 goto error; 631 } 632 633 streaming->header.bNumFormats = p; 634 streaming->header.bEndpointAddress = buffer[6]; 635 if (buffer[2] == UVC_VS_INPUT_HEADER) { 636 streaming->header.bmInfo = buffer[7]; 637 streaming->header.bTerminalLink = buffer[8]; 638 streaming->header.bStillCaptureMethod = buffer[9]; 639 streaming->header.bTriggerSupport = buffer[10]; 640 streaming->header.bTriggerUsage = buffer[11]; 641 } else { 642 streaming->header.bTerminalLink = buffer[7]; 643 } 644 streaming->header.bControlSize = n; 645 646 streaming->header.bmaControls = kmemdup(&buffer[size], p * n, 647 GFP_KERNEL); 648 if (streaming->header.bmaControls == NULL) { 649 ret = -ENOMEM; 650 goto error; 651 } 652 653 buflen -= buffer[0]; 654 buffer += buffer[0]; 655 656 _buffer = buffer; 657 _buflen = buflen; 658 659 /* Count the format and frame descriptors. */ 660 while (_buflen > 2 && _buffer[1] == USB_DT_CS_INTERFACE) { 661 switch (_buffer[2]) { 662 case UVC_VS_FORMAT_UNCOMPRESSED: 663 case UVC_VS_FORMAT_MJPEG: 664 case UVC_VS_FORMAT_FRAME_BASED: 665 nformats++; 666 break; 667 668 case UVC_VS_FORMAT_DV: 669 /* 670 * DV format has no frame descriptor. We will create a 671 * dummy frame descriptor with a dummy frame interval. 672 */ 673 nformats++; 674 nframes++; 675 nintervals++; 676 break; 677 678 case UVC_VS_FORMAT_MPEG2TS: 679 case UVC_VS_FORMAT_STREAM_BASED: 680 uvc_dbg(dev, DESCR, 681 "device %d videostreaming interface %d FORMAT %u is not supported\n", 682 dev->udev->devnum, 683 alts->desc.bInterfaceNumber, _buffer[2]); 684 break; 685 686 case UVC_VS_FRAME_UNCOMPRESSED: 687 case UVC_VS_FRAME_MJPEG: 688 nframes++; 689 if (_buflen > 25) 690 nintervals += _buffer[25] ? _buffer[25] : 3; 691 break; 692 693 case UVC_VS_FRAME_FRAME_BASED: 694 nframes++; 695 if (_buflen > 21) 696 nintervals += _buffer[21] ? _buffer[21] : 3; 697 break; 698 } 699 700 _buflen -= _buffer[0]; 701 _buffer += _buffer[0]; 702 } 703 704 if (nformats == 0) { 705 uvc_dbg(dev, DESCR, 706 "device %d videostreaming interface %d has no supported formats defined\n", 707 dev->udev->devnum, alts->desc.bInterfaceNumber); 708 goto error; 709 } 710 711 /* 712 * Allocate memory for the formats, the frames and the intervals, 713 * plus any required padding to guarantee that everything has the 714 * correct alignment. 715 */ 716 size = nformats * sizeof(*format); 717 size = ALIGN(size, __alignof__(*frame)) + nframes * sizeof(*frame); 718 size = ALIGN(size, __alignof__(*interval)) 719 + nintervals * sizeof(*interval); 720 721 format = kzalloc(size, GFP_KERNEL); 722 if (!format) { 723 ret = -ENOMEM; 724 goto error; 725 } 726 727 frame = (void *)format + nformats * sizeof(*format); 728 frame = PTR_ALIGN(frame, __alignof__(*frame)); 729 interval = (void *)frame + nframes * sizeof(*frame); 730 interval = PTR_ALIGN(interval, __alignof__(*interval)); 731 732 streaming->formats = format; 733 streaming->nformats = 0; 734 735 /* Parse the format descriptors. */ 736 while (buflen > 2 && buffer[1] == USB_DT_CS_INTERFACE) { 737 switch (buffer[2]) { 738 case UVC_VS_FORMAT_UNCOMPRESSED: 739 case UVC_VS_FORMAT_MJPEG: 740 case UVC_VS_FORMAT_DV: 741 case UVC_VS_FORMAT_FRAME_BASED: 742 ret = uvc_parse_format(dev, streaming, format, frame, 743 &interval, buffer, buflen); 744 if (ret < 0) 745 goto error; 746 if (!ret) 747 break; 748 749 streaming->nformats++; 750 frame += format->nframes; 751 format++; 752 753 buflen -= ret; 754 buffer += ret; 755 continue; 756 757 default: 758 break; 759 } 760 761 buflen -= buffer[0]; 762 buffer += buffer[0]; 763 } 764 765 if (buflen) 766 uvc_dbg(dev, DESCR, 767 "device %d videostreaming interface %d has %u bytes of trailing descriptor garbage\n", 768 dev->udev->devnum, alts->desc.bInterfaceNumber, buflen); 769 770 /* Parse the alternate settings to find the maximum bandwidth. */ 771 for (i = 0; i < intf->num_altsetting; ++i) { 772 struct usb_host_endpoint *ep; 773 774 alts = &intf->altsetting[i]; 775 ep = uvc_find_endpoint(alts, 776 streaming->header.bEndpointAddress); 777 if (ep == NULL) 778 continue; 779 psize = usb_endpoint_max_periodic_payload(dev->udev, ep); 780 if (psize > streaming->maxpsize) 781 streaming->maxpsize = psize; 782 } 783 784 list_add_tail(&streaming->list, &dev->streams); 785 return 0; 786 787error: 788 usb_driver_release_interface(&uvc_driver, intf); 789 uvc_stream_delete(streaming); 790 return ret; 791} 792 793static const u8 uvc_camera_guid[16] = UVC_GUID_UVC_CAMERA; 794static const u8 uvc_gpio_guid[16] = UVC_GUID_EXT_GPIO_CONTROLLER; 795static const u8 uvc_media_transport_input_guid[16] = 796 UVC_GUID_UVC_MEDIA_TRANSPORT_INPUT; 797static const u8 uvc_processing_guid[16] = UVC_GUID_UVC_PROCESSING; 798 799static struct uvc_entity *uvc_alloc_new_entity(struct uvc_device *dev, u16 type, 800 u16 id, unsigned int num_pads, 801 unsigned int extra_size) 802{ 803 struct uvc_entity *entity; 804 unsigned int num_inputs; 805 unsigned int size; 806 unsigned int i; 807 808 /* Per UVC 1.1+ spec 3.7.2, the ID should be non-zero. */ 809 if (id == 0) { 810 dev_err(&dev->intf->dev, "Found Unit with invalid ID 0\n"); 811 id = UVC_INVALID_ENTITY_ID; 812 } 813 814 /* Per UVC 1.1+ spec 3.7.2, the ID is unique. */ 815 if (uvc_entity_by_id(dev, UVC_HARDWARE_ENTITY_ID(id))) 816 dev_err(&dev->intf->dev, "Found multiple Units with ID %u\n", 817 UVC_HARDWARE_ENTITY_ID(id)); 818 819 if (uvc_entity_by_id(dev, id)) 820 id = UVC_INVALID_ENTITY_ID; 821 822 extra_size = roundup(extra_size, sizeof(*entity->pads)); 823 if (num_pads) 824 num_inputs = type & UVC_TERM_OUTPUT ? num_pads : num_pads - 1; 825 else 826 num_inputs = 0; 827 size = sizeof(*entity) + extra_size + sizeof(*entity->pads) * num_pads 828 + num_inputs; 829 entity = kzalloc(size, GFP_KERNEL); 830 if (entity == NULL) 831 return ERR_PTR(-ENOMEM); 832 833 entity->id = id; 834 entity->type = type; 835 836 /* 837 * Set the GUID for standard entity types. For extension units, the GUID 838 * is initialized by the caller. 839 */ 840 switch (type) { 841 case UVC_EXT_GPIO_UNIT: 842 memcpy(entity->guid, uvc_gpio_guid, 16); 843 break; 844 case UVC_ITT_CAMERA: 845 memcpy(entity->guid, uvc_camera_guid, 16); 846 break; 847 case UVC_ITT_MEDIA_TRANSPORT_INPUT: 848 memcpy(entity->guid, uvc_media_transport_input_guid, 16); 849 break; 850 case UVC_VC_PROCESSING_UNIT: 851 memcpy(entity->guid, uvc_processing_guid, 16); 852 break; 853 } 854 855 entity->num_links = 0; 856 entity->num_pads = num_pads; 857 entity->pads = ((void *)(entity + 1)) + extra_size; 858 859 for (i = 0; i < num_inputs; ++i) 860 entity->pads[i].flags = MEDIA_PAD_FL_SINK; 861 if (!UVC_ENTITY_IS_OTERM(entity) && num_pads) 862 entity->pads[num_pads-1].flags = MEDIA_PAD_FL_SOURCE; 863 864 entity->bNrInPins = num_inputs; 865 entity->baSourceID = (u8 *)(&entity->pads[num_pads]); 866 867 return entity; 868} 869 870static void uvc_entity_set_name(struct uvc_device *dev, struct uvc_entity *entity, 871 const char *type_name, u8 string_id) 872{ 873 int ret; 874 875 /* 876 * First attempt to read the entity name from the device. If the entity 877 * has no associated string, or if reading the string fails (most 878 * likely due to a buggy firmware), fall back to default names based on 879 * the entity type. 880 */ 881 if (string_id) { 882 ret = usb_string(dev->udev, string_id, entity->name, 883 sizeof(entity->name)); 884 if (!ret) 885 return; 886 } 887 888 sprintf(entity->name, "%s %u", type_name, entity->id); 889} 890 891/* Parse vendor-specific extensions. */ 892static int uvc_parse_vendor_control(struct uvc_device *dev, 893 const unsigned char *buffer, int buflen) 894{ 895 struct usb_device *udev = dev->udev; 896 struct usb_host_interface *alts = dev->intf->cur_altsetting; 897 struct uvc_entity *unit; 898 unsigned int n, p; 899 int handled = 0; 900 901 switch (le16_to_cpu(udev->descriptor.idVendor)) { 902 case 0x046d: /* Logitech */ 903 if (buffer[1] != 0x41 || buffer[2] != 0x01) 904 break; 905 906 /* 907 * Logitech implements several vendor specific functions 908 * through vendor specific extension units (LXU). 909 * 910 * The LXU descriptors are similar to XU descriptors 911 * (see "USB Device Video Class for Video Devices", section 912 * 3.7.2.6 "Extension Unit Descriptor") with the following 913 * differences: 914 * 915 * ---------------------------------------------------------- 916 * 0 bLength 1 Number 917 * Size of this descriptor, in bytes: 24+p+n*2 918 * ---------------------------------------------------------- 919 * 23+p+n bmControlsType N Bitmap 920 * Individual bits in the set are defined: 921 * 0: Absolute 922 * 1: Relative 923 * 924 * This bitset is mapped exactly the same as bmControls. 925 * ---------------------------------------------------------- 926 * 23+p+n*2 bReserved 1 Boolean 927 * ---------------------------------------------------------- 928 * 24+p+n*2 iExtension 1 Index 929 * Index of a string descriptor that describes this 930 * extension unit. 931 * ---------------------------------------------------------- 932 */ 933 p = buflen >= 22 ? buffer[21] : 0; 934 n = buflen >= 25 + p ? buffer[22+p] : 0; 935 936 if (buflen < 25 + p + 2*n) { 937 uvc_dbg(dev, DESCR, 938 "device %d videocontrol interface %d EXTENSION_UNIT error\n", 939 udev->devnum, alts->desc.bInterfaceNumber); 940 break; 941 } 942 943 unit = uvc_alloc_new_entity(dev, UVC_VC_EXTENSION_UNIT, 944 buffer[3], p + 1, 2 * n); 945 if (IS_ERR(unit)) 946 return PTR_ERR(unit); 947 948 memcpy(unit->guid, &buffer[4], 16); 949 unit->extension.bNumControls = buffer[20]; 950 memcpy(unit->baSourceID, &buffer[22], p); 951 unit->extension.bControlSize = buffer[22+p]; 952 unit->extension.bmControls = (u8 *)unit + sizeof(*unit); 953 unit->extension.bmControlsType = (u8 *)unit + sizeof(*unit) 954 + n; 955 memcpy(unit->extension.bmControls, &buffer[23+p], 2*n); 956 957 uvc_entity_set_name(dev, unit, "Extension", buffer[24+p+2*n]); 958 959 list_add_tail(&unit->list, &dev->entities); 960 handled = 1; 961 break; 962 } 963 964 return handled; 965} 966 967static int uvc_parse_standard_control(struct uvc_device *dev, 968 const unsigned char *buffer, int buflen) 969{ 970 struct usb_device *udev = dev->udev; 971 struct uvc_entity *unit, *term; 972 struct usb_interface *intf; 973 struct usb_host_interface *alts = dev->intf->cur_altsetting; 974 unsigned int i, n, p, len; 975 const char *type_name; 976 unsigned int id; 977 u16 type; 978 979 switch (buffer[2]) { 980 case UVC_VC_HEADER: 981 n = buflen >= 12 ? buffer[11] : 0; 982 983 if (buflen < 12 + n) { 984 uvc_dbg(dev, DESCR, 985 "device %d videocontrol interface %d HEADER error\n", 986 udev->devnum, alts->desc.bInterfaceNumber); 987 return -EINVAL; 988 } 989 990 dev->uvc_version = get_unaligned_le16(&buffer[3]); 991 dev->clock_frequency = get_unaligned_le32(&buffer[7]); 992 993 /* Parse all USB Video Streaming interfaces. */ 994 for (i = 0; i < n; ++i) { 995 intf = usb_ifnum_to_if(udev, buffer[12+i]); 996 if (intf == NULL) { 997 uvc_dbg(dev, DESCR, 998 "device %d interface %d doesn't exists\n", 999 udev->devnum, i); 1000 continue; 1001 } 1002 1003 uvc_parse_streaming(dev, intf); 1004 } 1005 break; 1006 1007 case UVC_VC_INPUT_TERMINAL: 1008 if (buflen < 8) { 1009 uvc_dbg(dev, DESCR, 1010 "device %d videocontrol interface %d INPUT_TERMINAL error\n", 1011 udev->devnum, alts->desc.bInterfaceNumber); 1012 return -EINVAL; 1013 } 1014 1015 /* 1016 * Reject invalid terminal types that would cause issues: 1017 * 1018 * - The high byte must be non-zero, otherwise it would be 1019 * confused with a unit. 1020 * 1021 * - Bit 15 must be 0, as we use it internally as a terminal 1022 * direction flag. 1023 * 1024 * Other unknown types are accepted. 1025 */ 1026 type = get_unaligned_le16(&buffer[4]); 1027 if ((type & 0x7f00) == 0 || (type & 0x8000) != 0) { 1028 uvc_dbg(dev, DESCR, 1029 "device %d videocontrol interface %d INPUT_TERMINAL %d has invalid type 0x%04x, skipping\n", 1030 udev->devnum, 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_dbg(dev, DESCR, 1051 "device %d videocontrol interface %d INPUT_TERMINAL error\n", 1052 udev->devnum, alts->desc.bInterfaceNumber); 1053 return -EINVAL; 1054 } 1055 1056 term = uvc_alloc_new_entity(dev, type | UVC_TERM_INPUT, 1057 buffer[3], 1, n + p); 1058 if (IS_ERR(term)) 1059 return PTR_ERR(term); 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 (UVC_ENTITY_TYPE(term) == UVC_ITT_CAMERA) 1083 type_name = "Camera"; 1084 else if (UVC_ENTITY_TYPE(term) == UVC_ITT_MEDIA_TRANSPORT_INPUT) 1085 type_name = "Media"; 1086 else 1087 type_name = "Input"; 1088 1089 uvc_entity_set_name(dev, term, type_name, buffer[7]); 1090 1091 list_add_tail(&term->list, &dev->entities); 1092 break; 1093 1094 case UVC_VC_OUTPUT_TERMINAL: 1095 if (buflen < 9) { 1096 uvc_dbg(dev, DESCR, 1097 "device %d videocontrol interface %d OUTPUT_TERMINAL error\n", 1098 udev->devnum, alts->desc.bInterfaceNumber); 1099 return -EINVAL; 1100 } 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_dbg(dev, DESCR, 1109 "device %d videocontrol interface %d OUTPUT_TERMINAL %d has invalid type 0x%04x, skipping\n", 1110 udev->devnum, alts->desc.bInterfaceNumber, 1111 buffer[3], type); 1112 return 0; 1113 } 1114 1115 id = buffer[3]; 1116 1117 /* 1118 * Some devices, such as the Grandstream GUV3100, exhibit entity 1119 * ID collisions between units and streaming output terminals. 1120 * Move streaming output terminals to their own ID namespace by 1121 * setting bit UVC_TERM_OUTPUT (15), above the ID's 8-bit value. 1122 * The bit is ignored in uvc_stream_for_terminal() when looking 1123 * up the streaming interface for the terminal. 1124 * 1125 * This hack is safe to enable unconditionally, as the ID is not 1126 * used for any other purpose (streaming output terminals have 1127 * no controls and are never referenced as sources in UVC 1128 * descriptors). Other types output terminals can have controls, 1129 * so limit usage of this separate namespace to streaming output 1130 * terminals. 1131 */ 1132 if (type & UVC_TT_STREAMING) 1133 id |= UVC_TERM_OUTPUT; 1134 1135 term = uvc_alloc_new_entity(dev, type | UVC_TERM_OUTPUT, 1136 id, 1, 0); 1137 if (IS_ERR(term)) 1138 return PTR_ERR(term); 1139 1140 memcpy(term->baSourceID, &buffer[7], 1); 1141 1142 uvc_entity_set_name(dev, term, "Output", buffer[8]); 1143 1144 list_add_tail(&term->list, &dev->entities); 1145 break; 1146 1147 case UVC_VC_SELECTOR_UNIT: 1148 p = buflen >= 5 ? buffer[4] : 0; 1149 1150 if (buflen < 5 || buflen < 6 + p) { 1151 uvc_dbg(dev, DESCR, 1152 "device %d videocontrol interface %d SELECTOR_UNIT error\n", 1153 udev->devnum, alts->desc.bInterfaceNumber); 1154 return -EINVAL; 1155 } 1156 1157 unit = uvc_alloc_new_entity(dev, buffer[2], buffer[3], 1158 p + 1, 0); 1159 if (IS_ERR(unit)) 1160 return PTR_ERR(unit); 1161 1162 memcpy(unit->baSourceID, &buffer[5], p); 1163 1164 uvc_entity_set_name(dev, unit, "Selector", buffer[5+p]); 1165 1166 list_add_tail(&unit->list, &dev->entities); 1167 break; 1168 1169 case UVC_VC_PROCESSING_UNIT: 1170 n = buflen >= 8 ? buffer[7] : 0; 1171 p = dev->uvc_version >= 0x0110 ? 10 : 9; 1172 1173 if (buflen < p + n) { 1174 uvc_dbg(dev, DESCR, 1175 "device %d videocontrol interface %d PROCESSING_UNIT error\n", 1176 udev->devnum, alts->desc.bInterfaceNumber); 1177 return -EINVAL; 1178 } 1179 1180 unit = uvc_alloc_new_entity(dev, buffer[2], buffer[3], 2, n); 1181 if (IS_ERR(unit)) 1182 return PTR_ERR(unit); 1183 1184 memcpy(unit->baSourceID, &buffer[4], 1); 1185 unit->processing.wMaxMultiplier = 1186 get_unaligned_le16(&buffer[5]); 1187 unit->processing.bControlSize = buffer[7]; 1188 unit->processing.bmControls = (u8 *)unit + sizeof(*unit); 1189 memcpy(unit->processing.bmControls, &buffer[8], n); 1190 if (dev->uvc_version >= 0x0110) 1191 unit->processing.bmVideoStandards = buffer[9+n]; 1192 1193 uvc_entity_set_name(dev, unit, "Processing", buffer[8+n]); 1194 1195 list_add_tail(&unit->list, &dev->entities); 1196 break; 1197 1198 case UVC_VC_EXTENSION_UNIT: 1199 p = buflen >= 22 ? buffer[21] : 0; 1200 n = buflen >= 24 + p ? buffer[22+p] : 0; 1201 1202 if (buflen < 24 + p + n) { 1203 uvc_dbg(dev, DESCR, 1204 "device %d videocontrol interface %d EXTENSION_UNIT error\n", 1205 udev->devnum, alts->desc.bInterfaceNumber); 1206 return -EINVAL; 1207 } 1208 1209 unit = uvc_alloc_new_entity(dev, buffer[2], buffer[3], 1210 p + 1, n); 1211 if (IS_ERR(unit)) 1212 return PTR_ERR(unit); 1213 1214 memcpy(unit->guid, &buffer[4], 16); 1215 unit->extension.bNumControls = buffer[20]; 1216 memcpy(unit->baSourceID, &buffer[22], p); 1217 unit->extension.bControlSize = buffer[22+p]; 1218 unit->extension.bmControls = (u8 *)unit + sizeof(*unit); 1219 memcpy(unit->extension.bmControls, &buffer[23+p], n); 1220 1221 uvc_entity_set_name(dev, unit, "Extension", buffer[23+p+n]); 1222 1223 list_add_tail(&unit->list, &dev->entities); 1224 break; 1225 1226 default: 1227 uvc_dbg(dev, DESCR, 1228 "Found an unknown CS_INTERFACE descriptor (%u)\n", 1229 buffer[2]); 1230 break; 1231 } 1232 1233 return 0; 1234} 1235 1236static int uvc_parse_control(struct uvc_device *dev) 1237{ 1238 struct usb_host_interface *alts = dev->intf->cur_altsetting; 1239 const unsigned char *buffer = alts->extra; 1240 int buflen = alts->extralen; 1241 int ret; 1242 1243 /* 1244 * Parse the default alternate setting only, as the UVC specification 1245 * defines a single alternate setting, the default alternate setting 1246 * zero. 1247 */ 1248 1249 while (buflen > 2) { 1250 if (uvc_parse_vendor_control(dev, buffer, buflen) || 1251 buffer[1] != USB_DT_CS_INTERFACE) 1252 goto next_descriptor; 1253 1254 ret = uvc_parse_standard_control(dev, buffer, buflen); 1255 if (ret < 0) 1256 return ret; 1257 1258next_descriptor: 1259 buflen -= buffer[0]; 1260 buffer += buffer[0]; 1261 } 1262 1263 /* 1264 * Check if the optional status endpoint is present. Built-in iSight 1265 * webcams have an interrupt endpoint but spit proprietary data that 1266 * don't conform to the UVC status endpoint messages. Don't try to 1267 * handle the interrupt endpoint for those cameras. 1268 */ 1269 if (alts->desc.bNumEndpoints == 1 && 1270 !(dev->quirks & UVC_QUIRK_BUILTIN_ISIGHT)) { 1271 struct usb_host_endpoint *ep = &alts->endpoint[0]; 1272 struct usb_endpoint_descriptor *desc = &ep->desc; 1273 1274 if (usb_endpoint_is_int_in(desc) && 1275 le16_to_cpu(desc->wMaxPacketSize) >= 8 && 1276 desc->bInterval != 0) { 1277 uvc_dbg(dev, DESCR, 1278 "Found a Status endpoint (addr %02x)\n", 1279 desc->bEndpointAddress); 1280 dev->int_ep = ep; 1281 } 1282 } 1283 1284 return 0; 1285} 1286 1287/* ----------------------------------------------------------------------------- 1288 * Privacy GPIO 1289 */ 1290 1291static void uvc_gpio_event(struct uvc_device *dev) 1292{ 1293 struct uvc_entity *unit = dev->gpio_unit; 1294 struct uvc_video_chain *chain; 1295 u8 new_val; 1296 1297 if (!unit) 1298 return; 1299 1300 new_val = gpiod_get_value_cansleep(unit->gpio.gpio_privacy); 1301 1302 /* GPIO entities are always on the first chain. */ 1303 chain = list_first_entry(&dev->chains, struct uvc_video_chain, list); 1304 uvc_ctrl_status_event(chain, unit->controls, &new_val); 1305} 1306 1307static int uvc_gpio_get_cur(struct uvc_device *dev, struct uvc_entity *entity, 1308 u8 cs, void *data, u16 size) 1309{ 1310 if (cs != UVC_CT_PRIVACY_CONTROL || size < 1) 1311 return -EINVAL; 1312 1313 *(u8 *)data = gpiod_get_value_cansleep(entity->gpio.gpio_privacy); 1314 1315 return 0; 1316} 1317 1318static int uvc_gpio_get_info(struct uvc_device *dev, struct uvc_entity *entity, 1319 u8 cs, u8 *caps) 1320{ 1321 if (cs != UVC_CT_PRIVACY_CONTROL) 1322 return -EINVAL; 1323 1324 *caps = UVC_CONTROL_CAP_GET | UVC_CONTROL_CAP_AUTOUPDATE; 1325 return 0; 1326} 1327 1328static irqreturn_t uvc_gpio_irq(int irq, void *data) 1329{ 1330 struct uvc_device *dev = data; 1331 1332 uvc_gpio_event(dev); 1333 return IRQ_HANDLED; 1334} 1335 1336static int uvc_gpio_parse(struct uvc_device *dev) 1337{ 1338 struct uvc_entity *unit; 1339 struct gpio_desc *gpio_privacy; 1340 int irq; 1341 1342 gpio_privacy = devm_gpiod_get_optional(&dev->intf->dev, "privacy", 1343 GPIOD_IN); 1344 if (!gpio_privacy) 1345 return 0; 1346 1347 if (IS_ERR(gpio_privacy)) 1348 return dev_err_probe(&dev->intf->dev, 1349 PTR_ERR(gpio_privacy), 1350 "Can't get privacy GPIO\n"); 1351 1352 irq = gpiod_to_irq(gpio_privacy); 1353 if (irq < 0) 1354 return dev_err_probe(&dev->intf->dev, irq, 1355 "No IRQ for privacy GPIO\n"); 1356 1357 unit = uvc_alloc_new_entity(dev, UVC_EXT_GPIO_UNIT, 1358 UVC_EXT_GPIO_UNIT_ID, 0, 1); 1359 if (IS_ERR(unit)) 1360 return PTR_ERR(unit); 1361 1362 unit->gpio.gpio_privacy = gpio_privacy; 1363 unit->gpio.irq = irq; 1364 unit->gpio.bControlSize = 1; 1365 unit->gpio.bmControls = (u8 *)unit + sizeof(*unit); 1366 unit->gpio.bmControls[0] = 1; 1367 unit->get_cur = uvc_gpio_get_cur; 1368 unit->get_info = uvc_gpio_get_info; 1369 strscpy(unit->name, "GPIO", sizeof(unit->name)); 1370 1371 list_add_tail(&unit->list, &dev->entities); 1372 1373 dev->gpio_unit = unit; 1374 1375 return 0; 1376} 1377 1378static int uvc_gpio_init_irq(struct uvc_device *dev) 1379{ 1380 struct uvc_entity *unit = dev->gpio_unit; 1381 int ret; 1382 1383 if (!unit || unit->gpio.irq < 0) 1384 return 0; 1385 1386 ret = request_threaded_irq(unit->gpio.irq, NULL, uvc_gpio_irq, 1387 IRQF_ONESHOT | IRQF_TRIGGER_FALLING | 1388 IRQF_TRIGGER_RISING, 1389 "uvc_privacy_gpio", dev); 1390 1391 unit->gpio.initialized = !ret; 1392 1393 return ret; 1394} 1395 1396static void uvc_gpio_deinit(struct uvc_device *dev) 1397{ 1398 if (!dev->gpio_unit || !dev->gpio_unit->gpio.initialized) 1399 return; 1400 1401 free_irq(dev->gpio_unit->gpio.irq, dev); 1402} 1403 1404/* ------------------------------------------------------------------------ 1405 * UVC device scan 1406 */ 1407 1408/* 1409 * Scan the UVC descriptors to locate a chain starting at an Output Terminal 1410 * and containing the following units: 1411 * 1412 * - one or more Output Terminals (USB Streaming or Display) 1413 * - zero or one Processing Unit 1414 * - zero, one or more single-input Selector Units 1415 * - zero or one multiple-input Selector Units, provided all inputs are 1416 * connected to input terminals 1417 * - zero, one or mode single-input Extension Units 1418 * - one or more Input Terminals (Camera, External or USB Streaming) 1419 * 1420 * The terminal and units must match on of the following structures: 1421 * 1422 * ITT_*(0) -> +---------+ +---------+ +---------+ -> TT_STREAMING(0) 1423 * ... | SU{0,1} | -> | PU{0,1} | -> | XU{0,n} | ... 1424 * ITT_*(n) -> +---------+ +---------+ +---------+ -> TT_STREAMING(n) 1425 * 1426 * +---------+ +---------+ -> OTT_*(0) 1427 * TT_STREAMING -> | PU{0,1} | -> | XU{0,n} | ... 1428 * +---------+ +---------+ -> OTT_*(n) 1429 * 1430 * The Processing Unit and Extension Units can be in any order. Additional 1431 * Extension Units connected to the main chain as single-unit branches are 1432 * also supported. Single-input Selector Units are ignored. 1433 */ 1434static int uvc_scan_chain_entity(struct uvc_video_chain *chain, 1435 struct uvc_entity *entity) 1436{ 1437 switch (UVC_ENTITY_TYPE(entity)) { 1438 case UVC_VC_EXTENSION_UNIT: 1439 uvc_dbg_cont(PROBE, " <- XU %d", entity->id); 1440 1441 if (entity->bNrInPins != 1) { 1442 uvc_dbg(chain->dev, DESCR, 1443 "Extension unit %d has more than 1 input pin\n", 1444 entity->id); 1445 return -1; 1446 } 1447 1448 break; 1449 1450 case UVC_VC_PROCESSING_UNIT: 1451 uvc_dbg_cont(PROBE, " <- PU %d", entity->id); 1452 1453 if (chain->processing != NULL) { 1454 uvc_dbg(chain->dev, DESCR, 1455 "Found multiple Processing Units in chain\n"); 1456 return -1; 1457 } 1458 1459 chain->processing = entity; 1460 break; 1461 1462 case UVC_VC_SELECTOR_UNIT: 1463 uvc_dbg_cont(PROBE, " <- SU %d", entity->id); 1464 1465 /* Single-input selector units are ignored. */ 1466 if (entity->bNrInPins == 1) 1467 break; 1468 1469 if (chain->selector != NULL) { 1470 uvc_dbg(chain->dev, DESCR, 1471 "Found multiple Selector Units in chain\n"); 1472 return -1; 1473 } 1474 1475 chain->selector = entity; 1476 break; 1477 1478 case UVC_ITT_VENDOR_SPECIFIC: 1479 case UVC_ITT_CAMERA: 1480 case UVC_ITT_MEDIA_TRANSPORT_INPUT: 1481 uvc_dbg_cont(PROBE, " <- IT %d\n", entity->id); 1482 1483 break; 1484 1485 case UVC_OTT_VENDOR_SPECIFIC: 1486 case UVC_OTT_DISPLAY: 1487 case UVC_OTT_MEDIA_TRANSPORT_OUTPUT: 1488 uvc_dbg_cont(PROBE, " OT %d", entity->id); 1489 1490 break; 1491 1492 case UVC_TT_STREAMING: 1493 if (UVC_ENTITY_IS_ITERM(entity)) 1494 uvc_dbg_cont(PROBE, " <- IT %d\n", entity->id); 1495 else 1496 uvc_dbg_cont(PROBE, " OT %d", entity->id); 1497 1498 break; 1499 1500 default: 1501 uvc_dbg(chain->dev, DESCR, 1502 "Unsupported entity type 0x%04x found in chain\n", 1503 UVC_ENTITY_TYPE(entity)); 1504 return -1; 1505 } 1506 1507 list_add_tail(&entity->chain, &chain->entities); 1508 return 0; 1509} 1510 1511static int uvc_scan_chain_forward(struct uvc_video_chain *chain, 1512 struct uvc_entity *entity, struct uvc_entity *prev) 1513{ 1514 struct uvc_entity *forward; 1515 int found; 1516 1517 /* Forward scan */ 1518 forward = NULL; 1519 found = 0; 1520 1521 while (1) { 1522 forward = uvc_entity_by_reference(chain->dev, entity->id, 1523 forward); 1524 if (forward == NULL) 1525 break; 1526 if (forward == prev) 1527 continue; 1528 if (forward->chain.next || forward->chain.prev) { 1529 uvc_dbg(chain->dev, DESCR, 1530 "Found reference to entity %d already in chain\n", 1531 forward->id); 1532 return -EINVAL; 1533 } 1534 1535 switch (UVC_ENTITY_TYPE(forward)) { 1536 case UVC_VC_EXTENSION_UNIT: 1537 if (forward->bNrInPins != 1) { 1538 uvc_dbg(chain->dev, DESCR, 1539 "Extension unit %d has more than 1 input pin\n", 1540 forward->id); 1541 return -EINVAL; 1542 } 1543 1544 /* 1545 * Some devices reference an output terminal as the 1546 * source of extension units. This is incorrect, as 1547 * output terminals only have an input pin, and thus 1548 * can't be connected to any entity in the forward 1549 * direction. The resulting topology would cause issues 1550 * when registering the media controller graph. To 1551 * avoid this problem, connect the extension unit to 1552 * the source of the output terminal instead. 1553 */ 1554 if (UVC_ENTITY_IS_OTERM(entity)) { 1555 struct uvc_entity *source; 1556 1557 source = uvc_entity_by_id(chain->dev, 1558 entity->baSourceID[0]); 1559 if (!source) { 1560 uvc_dbg(chain->dev, DESCR, 1561 "Can't connect extension unit %u in chain\n", 1562 forward->id); 1563 break; 1564 } 1565 1566 forward->baSourceID[0] = source->id; 1567 } 1568 1569 list_add_tail(&forward->chain, &chain->entities); 1570 if (!found) 1571 uvc_dbg_cont(PROBE, " (->"); 1572 1573 uvc_dbg_cont(PROBE, " XU %d", forward->id); 1574 found = 1; 1575 break; 1576 1577 case UVC_OTT_VENDOR_SPECIFIC: 1578 case UVC_OTT_DISPLAY: 1579 case UVC_OTT_MEDIA_TRANSPORT_OUTPUT: 1580 case UVC_TT_STREAMING: 1581 if (UVC_ENTITY_IS_ITERM(forward)) { 1582 uvc_dbg(chain->dev, DESCR, 1583 "Unsupported input terminal %u\n", 1584 forward->id); 1585 return -EINVAL; 1586 } 1587 1588 if (UVC_ENTITY_IS_OTERM(entity)) { 1589 uvc_dbg(chain->dev, DESCR, 1590 "Unsupported connection between output terminals %u and %u\n", 1591 entity->id, forward->id); 1592 break; 1593 } 1594 1595 list_add_tail(&forward->chain, &chain->entities); 1596 if (!found) 1597 uvc_dbg_cont(PROBE, " (->"); 1598 1599 uvc_dbg_cont(PROBE, " OT %d", forward->id); 1600 found = 1; 1601 break; 1602 } 1603 } 1604 if (found) 1605 uvc_dbg_cont(PROBE, ")"); 1606 1607 return 0; 1608} 1609 1610static int uvc_scan_chain_backward(struct uvc_video_chain *chain, 1611 struct uvc_entity **_entity) 1612{ 1613 struct uvc_entity *entity = *_entity; 1614 struct uvc_entity *term; 1615 int id = -EINVAL, i; 1616 1617 switch (UVC_ENTITY_TYPE(entity)) { 1618 case UVC_VC_EXTENSION_UNIT: 1619 case UVC_VC_PROCESSING_UNIT: 1620 id = entity->baSourceID[0]; 1621 break; 1622 1623 case UVC_VC_SELECTOR_UNIT: 1624 /* Single-input selector units are ignored. */ 1625 if (entity->bNrInPins == 1) { 1626 id = entity->baSourceID[0]; 1627 break; 1628 } 1629 1630 uvc_dbg_cont(PROBE, " <- IT"); 1631 1632 chain->selector = entity; 1633 for (i = 0; i < entity->bNrInPins; ++i) { 1634 id = entity->baSourceID[i]; 1635 term = uvc_entity_by_id(chain->dev, id); 1636 if (term == NULL || !UVC_ENTITY_IS_ITERM(term)) { 1637 uvc_dbg(chain->dev, DESCR, 1638 "Selector unit %d input %d isn't connected to an input terminal\n", 1639 entity->id, i); 1640 return -1; 1641 } 1642 1643 if (term->chain.next || term->chain.prev) { 1644 uvc_dbg(chain->dev, DESCR, 1645 "Found reference to entity %d already in chain\n", 1646 term->id); 1647 return -EINVAL; 1648 } 1649 1650 uvc_dbg_cont(PROBE, " %d", term->id); 1651 1652 list_add_tail(&term->chain, &chain->entities); 1653 uvc_scan_chain_forward(chain, term, entity); 1654 } 1655 1656 uvc_dbg_cont(PROBE, "\n"); 1657 1658 id = 0; 1659 break; 1660 1661 case UVC_ITT_VENDOR_SPECIFIC: 1662 case UVC_ITT_CAMERA: 1663 case UVC_ITT_MEDIA_TRANSPORT_INPUT: 1664 case UVC_OTT_VENDOR_SPECIFIC: 1665 case UVC_OTT_DISPLAY: 1666 case UVC_OTT_MEDIA_TRANSPORT_OUTPUT: 1667 case UVC_TT_STREAMING: 1668 id = UVC_ENTITY_IS_OTERM(entity) ? entity->baSourceID[0] : 0; 1669 break; 1670 } 1671 1672 if (id <= 0) { 1673 *_entity = NULL; 1674 return id; 1675 } 1676 1677 entity = uvc_entity_by_id(chain->dev, id); 1678 if (entity == NULL) { 1679 uvc_dbg(chain->dev, DESCR, 1680 "Found reference to unknown entity %d\n", id); 1681 return -EINVAL; 1682 } 1683 1684 *_entity = entity; 1685 return 0; 1686} 1687 1688static int uvc_scan_chain(struct uvc_video_chain *chain, 1689 struct uvc_entity *term) 1690{ 1691 struct uvc_entity *entity, *prev; 1692 1693 uvc_dbg(chain->dev, PROBE, "Scanning UVC chain:"); 1694 1695 entity = term; 1696 prev = NULL; 1697 1698 while (entity != NULL) { 1699 /* Entity must not be part of an existing chain */ 1700 if (entity->chain.next || entity->chain.prev) { 1701 uvc_dbg(chain->dev, DESCR, 1702 "Found reference to entity %d already in chain\n", 1703 entity->id); 1704 return -EINVAL; 1705 } 1706 1707 /* Process entity */ 1708 if (uvc_scan_chain_entity(chain, entity) < 0) 1709 return -EINVAL; 1710 1711 /* Forward scan */ 1712 if (uvc_scan_chain_forward(chain, entity, prev) < 0) 1713 return -EINVAL; 1714 1715 /* Backward scan */ 1716 prev = entity; 1717 if (uvc_scan_chain_backward(chain, &entity) < 0) 1718 return -EINVAL; 1719 } 1720 1721 return 0; 1722} 1723 1724static unsigned int uvc_print_terms(struct list_head *terms, u16 dir, 1725 char *buffer) 1726{ 1727 struct uvc_entity *term; 1728 unsigned int nterms = 0; 1729 char *p = buffer; 1730 1731 list_for_each_entry(term, terms, chain) { 1732 if (!UVC_ENTITY_IS_TERM(term) || 1733 UVC_TERM_DIRECTION(term) != dir) 1734 continue; 1735 1736 if (nterms) 1737 p += sprintf(p, ","); 1738 if (++nterms >= 4) { 1739 p += sprintf(p, "..."); 1740 break; 1741 } 1742 p += sprintf(p, "%u", term->id); 1743 } 1744 1745 return p - buffer; 1746} 1747 1748static const char *uvc_print_chain(struct uvc_video_chain *chain) 1749{ 1750 static char buffer[43]; 1751 char *p = buffer; 1752 1753 p += uvc_print_terms(&chain->entities, UVC_TERM_INPUT, p); 1754 p += sprintf(p, " -> "); 1755 uvc_print_terms(&chain->entities, UVC_TERM_OUTPUT, p); 1756 1757 return buffer; 1758} 1759 1760static struct uvc_video_chain *uvc_alloc_chain(struct uvc_device *dev) 1761{ 1762 struct uvc_video_chain *chain; 1763 1764 chain = kzalloc(sizeof(*chain), GFP_KERNEL); 1765 if (chain == NULL) 1766 return NULL; 1767 1768 INIT_LIST_HEAD(&chain->entities); 1769 mutex_init(&chain->ctrl_mutex); 1770 chain->dev = dev; 1771 v4l2_prio_init(&chain->prio); 1772 1773 return chain; 1774} 1775 1776/* 1777 * Fallback heuristic for devices that don't connect units and terminals in a 1778 * valid chain. 1779 * 1780 * Some devices have invalid baSourceID references, causing uvc_scan_chain() 1781 * to fail, but if we just take the entities we can find and put them together 1782 * in the most sensible chain we can think of, turns out they do work anyway. 1783 * Note: This heuristic assumes there is a single chain. 1784 * 1785 * At the time of writing, devices known to have such a broken chain are 1786 * - Acer Integrated Camera (5986:055a) 1787 * - Realtek rtl157a7 (0bda:57a7) 1788 */ 1789static int uvc_scan_fallback(struct uvc_device *dev) 1790{ 1791 struct uvc_video_chain *chain; 1792 struct uvc_entity *iterm = NULL; 1793 struct uvc_entity *oterm = NULL; 1794 struct uvc_entity *entity; 1795 struct uvc_entity *prev; 1796 1797 /* 1798 * Start by locating the input and output terminals. We only support 1799 * devices with exactly one of each for now. 1800 */ 1801 list_for_each_entry(entity, &dev->entities, list) { 1802 if (UVC_ENTITY_IS_ITERM(entity)) { 1803 if (iterm) 1804 return -EINVAL; 1805 iterm = entity; 1806 } 1807 1808 if (UVC_ENTITY_IS_OTERM(entity)) { 1809 if (oterm) 1810 return -EINVAL; 1811 oterm = entity; 1812 } 1813 } 1814 1815 if (iterm == NULL || oterm == NULL) 1816 return -EINVAL; 1817 1818 /* Allocate the chain and fill it. */ 1819 chain = uvc_alloc_chain(dev); 1820 if (chain == NULL) 1821 return -ENOMEM; 1822 1823 if (uvc_scan_chain_entity(chain, oterm) < 0) 1824 goto error; 1825 1826 prev = oterm; 1827 1828 /* 1829 * Add all Processing and Extension Units with two pads. The order 1830 * doesn't matter much, use reverse list traversal to connect units in 1831 * UVC descriptor order as we build the chain from output to input. This 1832 * leads to units appearing in the order meant by the manufacturer for 1833 * the cameras known to require this heuristic. 1834 */ 1835 list_for_each_entry_reverse(entity, &dev->entities, list) { 1836 if (entity->type != UVC_VC_PROCESSING_UNIT && 1837 entity->type != UVC_VC_EXTENSION_UNIT) 1838 continue; 1839 1840 if (entity->num_pads != 2) 1841 continue; 1842 1843 if (uvc_scan_chain_entity(chain, entity) < 0) 1844 goto error; 1845 1846 prev->baSourceID[0] = entity->id; 1847 prev = entity; 1848 } 1849 1850 if (uvc_scan_chain_entity(chain, iterm) < 0) 1851 goto error; 1852 1853 prev->baSourceID[0] = iterm->id; 1854 1855 list_add_tail(&chain->list, &dev->chains); 1856 1857 uvc_dbg(dev, PROBE, "Found a video chain by fallback heuristic (%s)\n", 1858 uvc_print_chain(chain)); 1859 1860 return 0; 1861 1862error: 1863 kfree(chain); 1864 return -EINVAL; 1865} 1866 1867/* 1868 * Scan the device for video chains and register video devices. 1869 * 1870 * Chains are scanned starting at their output terminals and walked backwards. 1871 */ 1872static int uvc_scan_device(struct uvc_device *dev) 1873{ 1874 struct uvc_video_chain *chain; 1875 struct uvc_entity *term; 1876 1877 list_for_each_entry(term, &dev->entities, list) { 1878 if (!UVC_ENTITY_IS_OTERM(term)) 1879 continue; 1880 1881 /* 1882 * If the terminal is already included in a chain, skip it. 1883 * This can happen for chains that have multiple output 1884 * terminals, where all output terminals beside the first one 1885 * will be inserted in the chain in forward scans. 1886 */ 1887 if (term->chain.next || term->chain.prev) 1888 continue; 1889 1890 chain = uvc_alloc_chain(dev); 1891 if (chain == NULL) 1892 return -ENOMEM; 1893 1894 term->flags |= UVC_ENTITY_FLAG_DEFAULT; 1895 1896 if (uvc_scan_chain(chain, term) < 0) { 1897 kfree(chain); 1898 continue; 1899 } 1900 1901 uvc_dbg(dev, PROBE, "Found a valid video chain (%s)\n", 1902 uvc_print_chain(chain)); 1903 1904 list_add_tail(&chain->list, &dev->chains); 1905 } 1906 1907 if (list_empty(&dev->chains)) 1908 uvc_scan_fallback(dev); 1909 1910 if (list_empty(&dev->chains)) { 1911 dev_info(&dev->intf->dev, "No valid video chain found.\n"); 1912 return -ENODEV; 1913 } 1914 1915 /* Add GPIO entity to the first chain. */ 1916 if (dev->gpio_unit) { 1917 chain = list_first_entry(&dev->chains, 1918 struct uvc_video_chain, list); 1919 list_add_tail(&dev->gpio_unit->chain, &chain->entities); 1920 } 1921 1922 return 0; 1923} 1924 1925/* ------------------------------------------------------------------------ 1926 * Video device registration and unregistration 1927 */ 1928 1929/* 1930 * Delete the UVC device. 1931 * 1932 * Called by the kernel when the last reference to the uvc_device structure 1933 * is released. 1934 * 1935 * As this function is called after or during disconnect(), all URBs have 1936 * already been cancelled by the USB core. There is no need to kill the 1937 * interrupt URB manually. 1938 */ 1939static void uvc_delete(struct kref *kref) 1940{ 1941 struct uvc_device *dev = container_of(kref, struct uvc_device, ref); 1942 struct list_head *p, *n; 1943 1944 uvc_status_cleanup(dev); 1945 uvc_ctrl_cleanup_device(dev); 1946 1947 usb_put_intf(dev->intf); 1948 usb_put_dev(dev->udev); 1949 1950#ifdef CONFIG_MEDIA_CONTROLLER 1951 media_device_cleanup(&dev->mdev); 1952#endif 1953 1954 list_for_each_safe(p, n, &dev->chains) { 1955 struct uvc_video_chain *chain; 1956 1957 chain = list_entry(p, struct uvc_video_chain, list); 1958 kfree(chain); 1959 } 1960 1961 list_for_each_safe(p, n, &dev->entities) { 1962 struct uvc_entity *entity; 1963 1964 entity = list_entry(p, struct uvc_entity, list); 1965#ifdef CONFIG_MEDIA_CONTROLLER 1966 uvc_mc_cleanup_entity(entity); 1967#endif 1968 kfree(entity); 1969 } 1970 1971 list_for_each_safe(p, n, &dev->streams) { 1972 struct uvc_streaming *streaming; 1973 1974 streaming = list_entry(p, struct uvc_streaming, list); 1975 usb_driver_release_interface(&uvc_driver, streaming->intf); 1976 uvc_stream_delete(streaming); 1977 } 1978 1979 kfree(dev); 1980} 1981 1982static void uvc_release(struct video_device *vdev) 1983{ 1984 struct uvc_streaming *stream = video_get_drvdata(vdev); 1985 struct uvc_device *dev = stream->dev; 1986 1987 kref_put(&dev->ref, uvc_delete); 1988} 1989 1990/* 1991 * Unregister the video devices. 1992 */ 1993static void uvc_unregister_video(struct uvc_device *dev) 1994{ 1995 struct uvc_streaming *stream; 1996 1997 uvc_gpio_deinit(dev); 1998 1999 list_for_each_entry(stream, &dev->streams, list) { 2000 /* Nothing to do here, continue. */ 2001 if (!video_is_registered(&stream->queue.vdev)) 2002 continue; 2003 2004 vb2_video_unregister_device(&stream->queue.vdev); 2005 vb2_video_unregister_device(&stream->meta.queue.vdev); 2006 2007 /* 2008 * Now both vdevs are not streaming and all the ioctls will 2009 * return -ENODEV. 2010 */ 2011 2012 uvc_debugfs_cleanup_stream(stream); 2013 } 2014 2015 uvc_status_unregister(dev); 2016 2017 if (dev->vdev.dev) 2018 v4l2_device_unregister(&dev->vdev); 2019#ifdef CONFIG_MEDIA_CONTROLLER 2020 if (media_devnode_is_registered(dev->mdev.devnode)) 2021 media_device_unregister(&dev->mdev); 2022#endif 2023} 2024 2025int uvc_register_video_device(struct uvc_device *dev, 2026 struct uvc_streaming *stream, 2027 struct uvc_video_queue *queue, 2028 enum v4l2_buf_type type, 2029 const struct v4l2_file_operations *fops, 2030 const struct v4l2_ioctl_ops *ioctl_ops) 2031{ 2032 struct video_device *vdev = &queue->vdev; 2033 int ret; 2034 2035 /* Initialize the video buffers queue. */ 2036 ret = uvc_queue_init(queue, type); 2037 if (ret) 2038 return ret; 2039 2040 /* Register the device with V4L. */ 2041 2042 /* 2043 * We already hold a reference to dev->udev. The video device will be 2044 * unregistered before the reference is released, so we don't need to 2045 * get another one. 2046 */ 2047 vdev->v4l2_dev = &dev->vdev; 2048 vdev->fops = fops; 2049 vdev->ioctl_ops = ioctl_ops; 2050 vdev->release = uvc_release; 2051 vdev->prio = &stream->chain->prio; 2052 vdev->queue = &queue->queue; 2053 vdev->lock = &queue->mutex; 2054 if (type == V4L2_BUF_TYPE_VIDEO_OUTPUT) 2055 vdev->vfl_dir = VFL_DIR_TX; 2056 else 2057 vdev->vfl_dir = VFL_DIR_RX; 2058 2059 switch (type) { 2060 case V4L2_BUF_TYPE_VIDEO_CAPTURE: 2061 default: 2062 vdev->device_caps = V4L2_CAP_VIDEO_CAPTURE | V4L2_CAP_STREAMING; 2063 break; 2064 case V4L2_BUF_TYPE_VIDEO_OUTPUT: 2065 vdev->device_caps = V4L2_CAP_VIDEO_OUTPUT | V4L2_CAP_STREAMING; 2066 break; 2067 case V4L2_BUF_TYPE_META_CAPTURE: 2068 vdev->device_caps = V4L2_CAP_META_CAPTURE | V4L2_CAP_STREAMING; 2069 break; 2070 } 2071 2072 strscpy(vdev->name, dev->name, sizeof(vdev->name)); 2073 2074 /* 2075 * Set the driver data before calling video_register_device, otherwise 2076 * the file open() handler might race us. 2077 */ 2078 video_set_drvdata(vdev, stream); 2079 2080 ret = video_register_device(vdev, VFL_TYPE_VIDEO, -1); 2081 if (ret < 0) { 2082 dev_err(&stream->intf->dev, 2083 "Failed to register %s device (%d).\n", 2084 v4l2_type_names[type], ret); 2085 return ret; 2086 } 2087 2088 kref_get(&dev->ref); 2089 return 0; 2090} 2091 2092static int uvc_register_video(struct uvc_device *dev, 2093 struct uvc_streaming *stream) 2094{ 2095 int ret; 2096 2097 /* Initialize the streaming interface with default parameters. */ 2098 ret = uvc_video_init(stream); 2099 if (ret < 0) { 2100 dev_err(&stream->intf->dev, 2101 "Failed to initialize the device (%d).\n", ret); 2102 return ret; 2103 } 2104 2105 if (stream->type == V4L2_BUF_TYPE_VIDEO_CAPTURE) 2106 stream->chain->caps |= V4L2_CAP_VIDEO_CAPTURE 2107 | V4L2_CAP_META_CAPTURE; 2108 else 2109 stream->chain->caps |= V4L2_CAP_VIDEO_OUTPUT; 2110 2111 uvc_debugfs_init_stream(stream); 2112 2113 /* Register the device with V4L. */ 2114 return uvc_register_video_device(dev, stream, &stream->queue, 2115 stream->type, &uvc_fops, 2116 &uvc_ioctl_ops); 2117} 2118 2119/* 2120 * Register all video devices in all chains. 2121 */ 2122static int uvc_register_terms(struct uvc_device *dev, 2123 struct uvc_video_chain *chain) 2124{ 2125 struct uvc_streaming *stream; 2126 struct uvc_entity *term; 2127 int ret; 2128 2129 list_for_each_entry(term, &chain->entities, chain) { 2130 if (UVC_ENTITY_TYPE(term) != UVC_TT_STREAMING) 2131 continue; 2132 2133 stream = uvc_stream_for_terminal(dev, term); 2134 if (!stream) { 2135 dev_info(&dev->intf->dev, 2136 "No streaming interface found for terminal %u.", 2137 term->id); 2138 continue; 2139 } 2140 2141 stream->chain = chain; 2142 ret = uvc_register_video(dev, stream); 2143 if (ret < 0) 2144 return ret; 2145 2146 /* 2147 * Register a metadata node, but ignore a possible failure, 2148 * complete registration of video nodes anyway. 2149 */ 2150 uvc_meta_register(stream); 2151 2152 term->vdev = &stream->queue.vdev; 2153 } 2154 2155 return 0; 2156} 2157 2158static int uvc_register_chains(struct uvc_device *dev) 2159{ 2160 struct uvc_video_chain *chain; 2161 int ret; 2162 2163 list_for_each_entry(chain, &dev->chains, list) { 2164 ret = uvc_register_terms(dev, chain); 2165 if (ret < 0) 2166 return ret; 2167 2168#ifdef CONFIG_MEDIA_CONTROLLER 2169 ret = uvc_mc_register_entities(chain); 2170 if (ret < 0) 2171 dev_info(&dev->intf->dev, 2172 "Failed to register entities (%d).\n", ret); 2173#endif 2174 } 2175 2176 return 0; 2177} 2178 2179/* ------------------------------------------------------------------------ 2180 * USB probe, disconnect, suspend and resume 2181 */ 2182 2183static const struct uvc_device_info uvc_quirk_none = { 0 }; 2184 2185static int uvc_probe(struct usb_interface *intf, 2186 const struct usb_device_id *id) 2187{ 2188 struct usb_device *udev = interface_to_usbdev(intf); 2189 struct uvc_device *dev; 2190 const struct uvc_device_info *info = 2191 (const struct uvc_device_info *)id->driver_info; 2192 int function; 2193 int ret; 2194 2195 /* Allocate memory for the device and initialize it. */ 2196 dev = kzalloc(sizeof(*dev), GFP_KERNEL); 2197 if (dev == NULL) 2198 return -ENOMEM; 2199 2200 INIT_LIST_HEAD(&dev->entities); 2201 INIT_LIST_HEAD(&dev->chains); 2202 INIT_LIST_HEAD(&dev->streams); 2203 kref_init(&dev->ref); 2204 atomic_set(&dev->nmappings, 0); 2205 2206 dev->udev = usb_get_dev(udev); 2207 dev->intf = usb_get_intf(intf); 2208 dev->intfnum = intf->cur_altsetting->desc.bInterfaceNumber; 2209 dev->info = info ? info : &uvc_quirk_none; 2210 dev->quirks = uvc_quirks_param == -1 2211 ? dev->info->quirks : uvc_quirks_param; 2212 2213 if (id->idVendor && id->idProduct) 2214 uvc_dbg(dev, PROBE, "Probing known UVC device %s (%04x:%04x)\n", 2215 udev->devpath, id->idVendor, id->idProduct); 2216 else 2217 uvc_dbg(dev, PROBE, "Probing generic UVC device %s\n", 2218 udev->devpath); 2219 2220 if (udev->product != NULL) 2221 strscpy(dev->name, udev->product, sizeof(dev->name)); 2222 else 2223 snprintf(dev->name, sizeof(dev->name), 2224 "UVC Camera (%04x:%04x)", 2225 le16_to_cpu(udev->descriptor.idVendor), 2226 le16_to_cpu(udev->descriptor.idProduct)); 2227 2228 /* 2229 * Add iFunction or iInterface to names when available as additional 2230 * distinguishers between interfaces. iFunction is prioritized over 2231 * iInterface which matches Windows behavior at the point of writing. 2232 */ 2233 if (intf->intf_assoc && intf->intf_assoc->iFunction != 0) 2234 function = intf->intf_assoc->iFunction; 2235 else 2236 function = intf->cur_altsetting->desc.iInterface; 2237 if (function != 0) { 2238 size_t len; 2239 2240 strlcat(dev->name, ": ", sizeof(dev->name)); 2241 len = strlen(dev->name); 2242 usb_string(udev, function, dev->name + len, 2243 sizeof(dev->name) - len); 2244 } 2245 2246 /* Initialize the media device. */ 2247#ifdef CONFIG_MEDIA_CONTROLLER 2248 dev->mdev.dev = &intf->dev; 2249 strscpy(dev->mdev.model, dev->name, sizeof(dev->mdev.model)); 2250 if (udev->serial) 2251 strscpy(dev->mdev.serial, udev->serial, 2252 sizeof(dev->mdev.serial)); 2253 usb_make_path(udev, dev->mdev.bus_info, sizeof(dev->mdev.bus_info)); 2254 dev->mdev.hw_revision = le16_to_cpu(udev->descriptor.bcdDevice); 2255 media_device_init(&dev->mdev); 2256 2257 dev->vdev.mdev = &dev->mdev; 2258#endif 2259 2260 /* Parse the Video Class control descriptor. */ 2261 ret = uvc_parse_control(dev); 2262 if (ret < 0) { 2263 uvc_dbg(dev, PROBE, "Unable to parse UVC descriptors\n"); 2264 goto error; 2265 } 2266 2267 /* Parse the associated GPIOs. */ 2268 ret = uvc_gpio_parse(dev); 2269 if (ret < 0) 2270 goto error; 2271 2272 dev_info(&dev->intf->dev, "Found UVC %u.%02x device %s (%04x:%04x)\n", 2273 dev->uvc_version >> 8, dev->uvc_version & 0xff, 2274 udev->product ? udev->product : "<unnamed>", 2275 le16_to_cpu(udev->descriptor.idVendor), 2276 le16_to_cpu(udev->descriptor.idProduct)); 2277 2278 if (dev->quirks != dev->info->quirks) { 2279 dev_info(&dev->intf->dev, 2280 "Forcing device quirks to 0x%x by module parameter for testing purpose.\n", 2281 dev->quirks); 2282 dev_info(&dev->intf->dev, 2283 "Please report required quirks to the linux-media mailing list.\n"); 2284 } 2285 2286 if (dev->info->uvc_version) { 2287 dev->uvc_version = dev->info->uvc_version; 2288 dev_info(&dev->intf->dev, "Forcing UVC version to %u.%02x\n", 2289 dev->uvc_version >> 8, dev->uvc_version & 0xff); 2290 } 2291 2292 /* Register the V4L2 device. */ 2293 ret = v4l2_device_register(&intf->dev, &dev->vdev); 2294 if (ret < 0) 2295 goto error; 2296 2297 /* Scan the device for video chains. */ 2298 ret = uvc_scan_device(dev); 2299 if (ret < 0) 2300 goto error; 2301 2302 /* Initialize controls. */ 2303 ret = uvc_ctrl_init_device(dev); 2304 if (ret < 0) 2305 goto error; 2306 2307 /* Register video device nodes. */ 2308 ret = uvc_register_chains(dev); 2309 if (ret < 0) 2310 goto error; 2311 2312#ifdef CONFIG_MEDIA_CONTROLLER 2313 /* Register the media device node */ 2314 ret = media_device_register(&dev->mdev); 2315 if (ret < 0) 2316 goto error; 2317#endif 2318 /* Save our data pointer in the interface data. */ 2319 usb_set_intfdata(intf, dev); 2320 2321 /* Initialize the interrupt URB. */ 2322 ret = uvc_status_init(dev); 2323 if (ret < 0) { 2324 dev_info(&dev->intf->dev, 2325 "Unable to initialize the status endpoint (%d), status interrupt will not be supported.\n", 2326 ret); 2327 } 2328 2329 ret = uvc_gpio_init_irq(dev); 2330 if (ret < 0) { 2331 dev_err(&dev->intf->dev, 2332 "Unable to request privacy GPIO IRQ (%d)\n", ret); 2333 goto error; 2334 } 2335 2336 ret = uvc_meta_init(dev); 2337 if (ret < 0) { 2338 dev_err(&dev->intf->dev, 2339 "Error initializing the metadata formats (%d)\n", ret); 2340 goto error; 2341 } 2342 2343 if (dev->quirks & UVC_QUIRK_NO_RESET_RESUME) 2344 udev->quirks &= ~USB_QUIRK_RESET_RESUME; 2345 2346 if (!(dev->quirks & UVC_QUIRK_DISABLE_AUTOSUSPEND)) 2347 usb_enable_autosuspend(udev); 2348 2349 uvc_dbg(dev, PROBE, "UVC device initialized\n"); 2350 2351 return 0; 2352 2353error: 2354 uvc_unregister_video(dev); 2355 kref_put(&dev->ref, uvc_delete); 2356 return ret; 2357} 2358 2359static void uvc_disconnect(struct usb_interface *intf) 2360{ 2361 struct uvc_device *dev = usb_get_intfdata(intf); 2362 2363 /* 2364 * Set the USB interface data to NULL. This can be done outside the 2365 * lock, as there's no other reader. 2366 */ 2367 usb_set_intfdata(intf, NULL); 2368 2369 if (intf->cur_altsetting->desc.bInterfaceSubClass == 2370 UVC_SC_VIDEOSTREAMING) 2371 return; 2372 2373 uvc_unregister_video(dev); 2374 kref_put(&dev->ref, uvc_delete); 2375} 2376 2377static int uvc_suspend(struct usb_interface *intf, pm_message_t message) 2378{ 2379 struct uvc_device *dev = usb_get_intfdata(intf); 2380 struct uvc_streaming *stream; 2381 2382 uvc_dbg(dev, SUSPEND, "Suspending interface %u\n", 2383 intf->cur_altsetting->desc.bInterfaceNumber); 2384 2385 /* Controls are cached on the fly so they don't need to be saved. */ 2386 if (intf->cur_altsetting->desc.bInterfaceSubClass == 2387 UVC_SC_VIDEOCONTROL) { 2388 uvc_status_suspend(dev); 2389 return 0; 2390 } 2391 2392 list_for_each_entry(stream, &dev->streams, list) { 2393 if (stream->intf == intf) 2394 return uvc_video_suspend(stream); 2395 } 2396 2397 uvc_dbg(dev, SUSPEND, 2398 "Suspend: video streaming USB interface mismatch\n"); 2399 return -EINVAL; 2400} 2401 2402static int __uvc_resume(struct usb_interface *intf, int reset) 2403{ 2404 struct uvc_device *dev = usb_get_intfdata(intf); 2405 struct uvc_streaming *stream; 2406 int ret = 0; 2407 2408 uvc_dbg(dev, SUSPEND, "Resuming interface %u\n", 2409 intf->cur_altsetting->desc.bInterfaceNumber); 2410 2411 if (intf->cur_altsetting->desc.bInterfaceSubClass == 2412 UVC_SC_VIDEOCONTROL) { 2413 if (reset) { 2414 ret = uvc_ctrl_restore_values(dev); 2415 if (ret < 0) 2416 return ret; 2417 } 2418 2419 return uvc_status_resume(dev); 2420 } 2421 2422 list_for_each_entry(stream, &dev->streams, list) { 2423 if (stream->intf == intf) { 2424 ret = uvc_video_resume(stream, reset); 2425 if (ret < 0) { 2426 mutex_lock(&stream->queue.mutex); 2427 vb2_streamoff(&stream->queue.queue, 2428 stream->queue.queue.type); 2429 mutex_unlock(&stream->queue.mutex); 2430 } 2431 return ret; 2432 } 2433 } 2434 2435 uvc_dbg(dev, SUSPEND, 2436 "Resume: video streaming USB interface mismatch\n"); 2437 return -EINVAL; 2438} 2439 2440static int uvc_resume(struct usb_interface *intf) 2441{ 2442 return __uvc_resume(intf, 0); 2443} 2444 2445static int uvc_reset_resume(struct usb_interface *intf) 2446{ 2447 return __uvc_resume(intf, 1); 2448} 2449 2450/* ------------------------------------------------------------------------ 2451 * Module parameters 2452 */ 2453 2454static int uvc_clock_param_get(char *buffer, const struct kernel_param *kp) 2455{ 2456 if (uvc_clock_param == CLOCK_MONOTONIC) 2457 return sprintf(buffer, "CLOCK_MONOTONIC"); 2458 else 2459 return sprintf(buffer, "CLOCK_REALTIME"); 2460} 2461 2462static int uvc_clock_param_set(const char *val, const struct kernel_param *kp) 2463{ 2464 if (strncasecmp(val, "clock_", strlen("clock_")) == 0) 2465 val += strlen("clock_"); 2466 2467 if (strcasecmp(val, "monotonic") == 0) 2468 uvc_clock_param = CLOCK_MONOTONIC; 2469 else if (strcasecmp(val, "realtime") == 0) 2470 uvc_clock_param = CLOCK_REALTIME; 2471 else 2472 return -EINVAL; 2473 2474 return 0; 2475} 2476 2477module_param_call(clock, uvc_clock_param_set, uvc_clock_param_get, 2478 &uvc_clock_param, 0644); 2479MODULE_PARM_DESC(clock, "Video buffers timestamp clock"); 2480module_param_named(hwtimestamps, uvc_hw_timestamps_param, uint, 0644); 2481MODULE_PARM_DESC(hwtimestamps, "Use hardware timestamps"); 2482 2483static int param_set_nodrop(const char *val, const struct kernel_param *kp) 2484{ 2485 pr_warn_once("uvcvideo: " 2486 DEPRECATED 2487 "nodrop parameter will be eventually removed.\n"); 2488 return param_set_bool(val, kp); 2489} 2490 2491static const struct kernel_param_ops param_ops_nodrop = { 2492 .set = param_set_nodrop, 2493 .get = param_get_uint, 2494}; 2495 2496param_check_uint(nodrop, &uvc_no_drop_param); 2497module_param_cb(nodrop, ¶m_ops_nodrop, &uvc_no_drop_param, 0644); 2498__MODULE_PARM_TYPE(nodrop, "uint"); 2499MODULE_PARM_DESC(nodrop, "Don't drop incomplete frames"); 2500 2501module_param_named(quirks, uvc_quirks_param, uint, 0644); 2502MODULE_PARM_DESC(quirks, "Forced device quirks"); 2503module_param_named(trace, uvc_dbg_param, uint, 0644); 2504MODULE_PARM_DESC(trace, "Trace level bitmask"); 2505module_param_named(timeout, uvc_timeout_param, uint, 0644); 2506MODULE_PARM_DESC(timeout, "Streaming control requests timeout"); 2507 2508/* ------------------------------------------------------------------------ 2509 * Driver initialization and cleanup 2510 */ 2511 2512static const struct uvc_device_info uvc_quirk_probe_minmax = { 2513 .quirks = UVC_QUIRK_PROBE_MINMAX, 2514}; 2515 2516static const struct uvc_device_info uvc_quirk_fix_bandwidth = { 2517 .quirks = UVC_QUIRK_FIX_BANDWIDTH, 2518}; 2519 2520static const struct uvc_device_info uvc_quirk_probe_def = { 2521 .quirks = UVC_QUIRK_PROBE_DEF, 2522}; 2523 2524static const struct uvc_device_info uvc_quirk_stream_no_fid = { 2525 .quirks = UVC_QUIRK_STREAM_NO_FID, 2526}; 2527 2528static const struct uvc_device_info uvc_quirk_force_y8 = { 2529 .quirks = UVC_QUIRK_FORCE_Y8, 2530}; 2531 2532#define UVC_INFO_QUIRK(q) (kernel_ulong_t)&(struct uvc_device_info){.quirks = q} 2533#define UVC_INFO_META(m) (kernel_ulong_t)&(struct uvc_device_info) \ 2534 {.meta_format = m} 2535 2536/* 2537 * The Logitech cameras listed below have their interface class set to 2538 * VENDOR_SPEC because they don't announce themselves as UVC devices, even 2539 * though they are compliant. 2540 * 2541 * Sort these by vendor/product ID. 2542 */ 2543static const struct usb_device_id uvc_ids[] = { 2544 /* HP Webcam HD 2300 */ 2545 { .match_flags = USB_DEVICE_ID_MATCH_DEVICE 2546 | USB_DEVICE_ID_MATCH_INT_INFO, 2547 .idVendor = 0x03f0, 2548 .idProduct = 0xe207, 2549 .bInterfaceClass = USB_CLASS_VIDEO, 2550 .bInterfaceSubClass = 1, 2551 .bInterfaceProtocol = 0, 2552 .driver_info = (kernel_ulong_t)&uvc_quirk_stream_no_fid }, 2553 /* Quanta ACER HD User Facing */ 2554 { .match_flags = USB_DEVICE_ID_MATCH_DEVICE 2555 | USB_DEVICE_ID_MATCH_INT_INFO, 2556 .idVendor = 0x0408, 2557 .idProduct = 0x4033, 2558 .bInterfaceClass = USB_CLASS_VIDEO, 2559 .bInterfaceSubClass = 1, 2560 .bInterfaceProtocol = UVC_PC_PROTOCOL_15, 2561 .driver_info = (kernel_ulong_t)&(const struct uvc_device_info){ 2562 .uvc_version = 0x010a, 2563 } }, 2564 /* Quanta ACER HD User Facing */ 2565 { .match_flags = USB_DEVICE_ID_MATCH_DEVICE 2566 | USB_DEVICE_ID_MATCH_INT_INFO, 2567 .idVendor = 0x0408, 2568 .idProduct = 0x4035, 2569 .bInterfaceClass = USB_CLASS_VIDEO, 2570 .bInterfaceSubClass = 1, 2571 .bInterfaceProtocol = UVC_PC_PROTOCOL_15, 2572 .driver_info = (kernel_ulong_t)&(const struct uvc_device_info){ 2573 .uvc_version = 0x010a, 2574 } }, 2575 /* LogiLink Wireless Webcam */ 2576 { .match_flags = USB_DEVICE_ID_MATCH_DEVICE 2577 | USB_DEVICE_ID_MATCH_INT_INFO, 2578 .idVendor = 0x0416, 2579 .idProduct = 0xa91a, 2580 .bInterfaceClass = USB_CLASS_VIDEO, 2581 .bInterfaceSubClass = 1, 2582 .bInterfaceProtocol = 0, 2583 .driver_info = (kernel_ulong_t)&uvc_quirk_probe_minmax }, 2584 /* Genius eFace 2025 */ 2585 { .match_flags = USB_DEVICE_ID_MATCH_DEVICE 2586 | USB_DEVICE_ID_MATCH_INT_INFO, 2587 .idVendor = 0x0458, 2588 .idProduct = 0x706e, 2589 .bInterfaceClass = USB_CLASS_VIDEO, 2590 .bInterfaceSubClass = 1, 2591 .bInterfaceProtocol = 0, 2592 .driver_info = (kernel_ulong_t)&uvc_quirk_probe_minmax }, 2593 /* Microsoft Lifecam NX-6000 */ 2594 { .match_flags = USB_DEVICE_ID_MATCH_DEVICE 2595 | USB_DEVICE_ID_MATCH_INT_INFO, 2596 .idVendor = 0x045e, 2597 .idProduct = 0x00f8, 2598 .bInterfaceClass = USB_CLASS_VIDEO, 2599 .bInterfaceSubClass = 1, 2600 .bInterfaceProtocol = 0, 2601 .driver_info = (kernel_ulong_t)&uvc_quirk_probe_minmax }, 2602 /* Microsoft Lifecam NX-3000 */ 2603 { .match_flags = USB_DEVICE_ID_MATCH_DEVICE 2604 | USB_DEVICE_ID_MATCH_INT_INFO, 2605 .idVendor = 0x045e, 2606 .idProduct = 0x0721, 2607 .bInterfaceClass = USB_CLASS_VIDEO, 2608 .bInterfaceSubClass = 1, 2609 .bInterfaceProtocol = 0, 2610 .driver_info = (kernel_ulong_t)&uvc_quirk_probe_def }, 2611 /* Microsoft Lifecam VX-7000 */ 2612 { .match_flags = USB_DEVICE_ID_MATCH_DEVICE 2613 | USB_DEVICE_ID_MATCH_INT_INFO, 2614 .idVendor = 0x045e, 2615 .idProduct = 0x0723, 2616 .bInterfaceClass = USB_CLASS_VIDEO, 2617 .bInterfaceSubClass = 1, 2618 .bInterfaceProtocol = 0, 2619 .driver_info = (kernel_ulong_t)&uvc_quirk_probe_minmax }, 2620 /* Logitech, Webcam C910 */ 2621 { .match_flags = USB_DEVICE_ID_MATCH_DEVICE 2622 | USB_DEVICE_ID_MATCH_INT_INFO, 2623 .idVendor = 0x046d, 2624 .idProduct = 0x0821, 2625 .bInterfaceClass = USB_CLASS_VIDEO, 2626 .bInterfaceSubClass = 1, 2627 .bInterfaceProtocol = 0, 2628 .driver_info = UVC_INFO_QUIRK(UVC_QUIRK_WAKE_AUTOSUSPEND)}, 2629 /* Logitech, Webcam B910 */ 2630 { .match_flags = USB_DEVICE_ID_MATCH_DEVICE 2631 | USB_DEVICE_ID_MATCH_INT_INFO, 2632 .idVendor = 0x046d, 2633 .idProduct = 0x0823, 2634 .bInterfaceClass = USB_CLASS_VIDEO, 2635 .bInterfaceSubClass = 1, 2636 .bInterfaceProtocol = 0, 2637 .driver_info = UVC_INFO_QUIRK(UVC_QUIRK_WAKE_AUTOSUSPEND)}, 2638 /* Logitech Quickcam Fusion */ 2639 { .match_flags = USB_DEVICE_ID_MATCH_DEVICE 2640 | USB_DEVICE_ID_MATCH_INT_INFO, 2641 .idVendor = 0x046d, 2642 .idProduct = 0x08c1, 2643 .bInterfaceClass = USB_CLASS_VENDOR_SPEC, 2644 .bInterfaceSubClass = 1, 2645 .bInterfaceProtocol = 0 }, 2646 /* Logitech Quickcam Orbit MP */ 2647 { .match_flags = USB_DEVICE_ID_MATCH_DEVICE 2648 | USB_DEVICE_ID_MATCH_INT_INFO, 2649 .idVendor = 0x046d, 2650 .idProduct = 0x08c2, 2651 .bInterfaceClass = USB_CLASS_VENDOR_SPEC, 2652 .bInterfaceSubClass = 1, 2653 .bInterfaceProtocol = 0 }, 2654 /* Logitech Quickcam Pro for Notebook */ 2655 { .match_flags = USB_DEVICE_ID_MATCH_DEVICE 2656 | USB_DEVICE_ID_MATCH_INT_INFO, 2657 .idVendor = 0x046d, 2658 .idProduct = 0x08c3, 2659 .bInterfaceClass = USB_CLASS_VENDOR_SPEC, 2660 .bInterfaceSubClass = 1, 2661 .bInterfaceProtocol = 0 }, 2662 /* Logitech Quickcam Pro 5000 */ 2663 { .match_flags = USB_DEVICE_ID_MATCH_DEVICE 2664 | USB_DEVICE_ID_MATCH_INT_INFO, 2665 .idVendor = 0x046d, 2666 .idProduct = 0x08c5, 2667 .bInterfaceClass = USB_CLASS_VENDOR_SPEC, 2668 .bInterfaceSubClass = 1, 2669 .bInterfaceProtocol = 0 }, 2670 /* Logitech Quickcam OEM Dell Notebook */ 2671 { .match_flags = USB_DEVICE_ID_MATCH_DEVICE 2672 | USB_DEVICE_ID_MATCH_INT_INFO, 2673 .idVendor = 0x046d, 2674 .idProduct = 0x08c6, 2675 .bInterfaceClass = USB_CLASS_VENDOR_SPEC, 2676 .bInterfaceSubClass = 1, 2677 .bInterfaceProtocol = 0 }, 2678 /* Logitech Quickcam OEM Cisco VT Camera II */ 2679 { .match_flags = USB_DEVICE_ID_MATCH_DEVICE 2680 | USB_DEVICE_ID_MATCH_INT_INFO, 2681 .idVendor = 0x046d, 2682 .idProduct = 0x08c7, 2683 .bInterfaceClass = USB_CLASS_VENDOR_SPEC, 2684 .bInterfaceSubClass = 1, 2685 .bInterfaceProtocol = 0 }, 2686 /* Logitech HD Pro Webcam C920 */ 2687 { .match_flags = USB_DEVICE_ID_MATCH_DEVICE 2688 | USB_DEVICE_ID_MATCH_INT_INFO, 2689 .idVendor = 0x046d, 2690 .idProduct = 0x082d, 2691 .bInterfaceClass = USB_CLASS_VIDEO, 2692 .bInterfaceSubClass = 1, 2693 .bInterfaceProtocol = 0, 2694 .driver_info = UVC_INFO_QUIRK(UVC_QUIRK_RESTORE_CTRLS_ON_INIT 2695 | UVC_QUIRK_INVALID_DEVICE_SOF) }, 2696 /* Logitech HD Pro Webcam C922 */ 2697 { .match_flags = USB_DEVICE_ID_MATCH_DEVICE 2698 | USB_DEVICE_ID_MATCH_INT_INFO, 2699 .idVendor = 0x046d, 2700 .idProduct = 0x085c, 2701 .bInterfaceClass = USB_CLASS_VIDEO, 2702 .bInterfaceSubClass = 1, 2703 .bInterfaceProtocol = 0, 2704 .driver_info = UVC_INFO_QUIRK(UVC_QUIRK_INVALID_DEVICE_SOF) }, 2705 /* Logitech Rally Bar Huddle */ 2706 { .match_flags = USB_DEVICE_ID_MATCH_DEVICE 2707 | USB_DEVICE_ID_MATCH_INT_INFO, 2708 .idVendor = 0x046d, 2709 .idProduct = 0x087c, 2710 .bInterfaceClass = USB_CLASS_VIDEO, 2711 .bInterfaceSubClass = 1, 2712 .bInterfaceProtocol = 0, 2713 .driver_info = UVC_INFO_QUIRK(UVC_QUIRK_NO_RESET_RESUME) }, 2714 /* Logitech Rally Bar */ 2715 { .match_flags = USB_DEVICE_ID_MATCH_DEVICE 2716 | USB_DEVICE_ID_MATCH_INT_INFO, 2717 .idVendor = 0x046d, 2718 .idProduct = 0x089b, 2719 .bInterfaceClass = USB_CLASS_VIDEO, 2720 .bInterfaceSubClass = 1, 2721 .bInterfaceProtocol = 0, 2722 .driver_info = UVC_INFO_QUIRK(UVC_QUIRK_NO_RESET_RESUME) }, 2723 /* Logitech Rally Bar Mini */ 2724 { .match_flags = USB_DEVICE_ID_MATCH_DEVICE 2725 | USB_DEVICE_ID_MATCH_INT_INFO, 2726 .idVendor = 0x046d, 2727 .idProduct = 0x08d3, 2728 .bInterfaceClass = USB_CLASS_VIDEO, 2729 .bInterfaceSubClass = 1, 2730 .bInterfaceProtocol = 0, 2731 .driver_info = UVC_INFO_QUIRK(UVC_QUIRK_NO_RESET_RESUME) }, 2732 /* Chicony CNF7129 (Asus EEE 100HE) */ 2733 { .match_flags = USB_DEVICE_ID_MATCH_DEVICE 2734 | USB_DEVICE_ID_MATCH_INT_INFO, 2735 .idVendor = 0x04f2, 2736 .idProduct = 0xb071, 2737 .bInterfaceClass = USB_CLASS_VIDEO, 2738 .bInterfaceSubClass = 1, 2739 .bInterfaceProtocol = 0, 2740 .driver_info = UVC_INFO_QUIRK(UVC_QUIRK_RESTRICT_FRAME_RATE) }, 2741 /* Alcor Micro AU3820 (Future Boy PC USB Webcam) */ 2742 { .match_flags = USB_DEVICE_ID_MATCH_DEVICE 2743 | USB_DEVICE_ID_MATCH_INT_INFO, 2744 .idVendor = 0x058f, 2745 .idProduct = 0x3820, 2746 .bInterfaceClass = USB_CLASS_VIDEO, 2747 .bInterfaceSubClass = 1, 2748 .bInterfaceProtocol = 0, 2749 .driver_info = (kernel_ulong_t)&uvc_quirk_probe_minmax }, 2750 /* Dell XPS m1530 */ 2751 { .match_flags = USB_DEVICE_ID_MATCH_DEVICE 2752 | USB_DEVICE_ID_MATCH_INT_INFO, 2753 .idVendor = 0x05a9, 2754 .idProduct = 0x2640, 2755 .bInterfaceClass = USB_CLASS_VIDEO, 2756 .bInterfaceSubClass = 1, 2757 .bInterfaceProtocol = 0, 2758 .driver_info = (kernel_ulong_t)&uvc_quirk_probe_def }, 2759 /* Dell SP2008WFP Monitor */ 2760 { .match_flags = USB_DEVICE_ID_MATCH_DEVICE 2761 | USB_DEVICE_ID_MATCH_INT_INFO, 2762 .idVendor = 0x05a9, 2763 .idProduct = 0x2641, 2764 .bInterfaceClass = USB_CLASS_VIDEO, 2765 .bInterfaceSubClass = 1, 2766 .bInterfaceProtocol = 0, 2767 .driver_info = (kernel_ulong_t)&uvc_quirk_probe_def }, 2768 /* Dell Alienware X51 */ 2769 { .match_flags = USB_DEVICE_ID_MATCH_DEVICE 2770 | USB_DEVICE_ID_MATCH_INT_INFO, 2771 .idVendor = 0x05a9, 2772 .idProduct = 0x2643, 2773 .bInterfaceClass = USB_CLASS_VIDEO, 2774 .bInterfaceSubClass = 1, 2775 .bInterfaceProtocol = 0, 2776 .driver_info = (kernel_ulong_t)&uvc_quirk_probe_def }, 2777 /* Dell Studio Hybrid 140g (OmniVision webcam) */ 2778 { .match_flags = USB_DEVICE_ID_MATCH_DEVICE 2779 | USB_DEVICE_ID_MATCH_INT_INFO, 2780 .idVendor = 0x05a9, 2781 .idProduct = 0x264a, 2782 .bInterfaceClass = USB_CLASS_VIDEO, 2783 .bInterfaceSubClass = 1, 2784 .bInterfaceProtocol = 0, 2785 .driver_info = (kernel_ulong_t)&uvc_quirk_probe_def }, 2786 /* Dell XPS M1330 (OmniVision OV7670 webcam) */ 2787 { .match_flags = USB_DEVICE_ID_MATCH_DEVICE 2788 | USB_DEVICE_ID_MATCH_INT_INFO, 2789 .idVendor = 0x05a9, 2790 .idProduct = 0x7670, 2791 .bInterfaceClass = USB_CLASS_VIDEO, 2792 .bInterfaceSubClass = 1, 2793 .bInterfaceProtocol = 0, 2794 .driver_info = (kernel_ulong_t)&uvc_quirk_probe_def }, 2795 /* Apple Built-In iSight */ 2796 { .match_flags = USB_DEVICE_ID_MATCH_DEVICE 2797 | USB_DEVICE_ID_MATCH_INT_INFO, 2798 .idVendor = 0x05ac, 2799 .idProduct = 0x8501, 2800 .bInterfaceClass = USB_CLASS_VIDEO, 2801 .bInterfaceSubClass = 1, 2802 .bInterfaceProtocol = 0, 2803 .driver_info = UVC_INFO_QUIRK(UVC_QUIRK_PROBE_MINMAX 2804 | UVC_QUIRK_BUILTIN_ISIGHT) }, 2805 /* Apple FaceTime HD Camera (Built-In) */ 2806 { .match_flags = USB_DEVICE_ID_MATCH_DEVICE 2807 | USB_DEVICE_ID_MATCH_INT_INFO, 2808 .idVendor = 0x05ac, 2809 .idProduct = 0x8514, 2810 .bInterfaceClass = USB_CLASS_VIDEO, 2811 .bInterfaceSubClass = 1, 2812 .bInterfaceProtocol = 0, 2813 .driver_info = (kernel_ulong_t)&uvc_quirk_probe_def }, 2814 /* Apple Built-In iSight via iBridge */ 2815 { .match_flags = USB_DEVICE_ID_MATCH_DEVICE 2816 | USB_DEVICE_ID_MATCH_INT_INFO, 2817 .idVendor = 0x05ac, 2818 .idProduct = 0x8600, 2819 .bInterfaceClass = USB_CLASS_VIDEO, 2820 .bInterfaceSubClass = 1, 2821 .bInterfaceProtocol = 0, 2822 .driver_info = (kernel_ulong_t)&uvc_quirk_probe_def }, 2823 /* Foxlink ("HP Webcam" on HP Mini 5103) */ 2824 { .match_flags = USB_DEVICE_ID_MATCH_DEVICE 2825 | USB_DEVICE_ID_MATCH_INT_INFO, 2826 .idVendor = 0x05c8, 2827 .idProduct = 0x0403, 2828 .bInterfaceClass = USB_CLASS_VIDEO, 2829 .bInterfaceSubClass = 1, 2830 .bInterfaceProtocol = 0, 2831 .driver_info = (kernel_ulong_t)&uvc_quirk_fix_bandwidth }, 2832 /* Genesys Logic USB 2.0 PC Camera */ 2833 { .match_flags = USB_DEVICE_ID_MATCH_DEVICE 2834 | USB_DEVICE_ID_MATCH_INT_INFO, 2835 .idVendor = 0x05e3, 2836 .idProduct = 0x0505, 2837 .bInterfaceClass = USB_CLASS_VIDEO, 2838 .bInterfaceSubClass = 1, 2839 .bInterfaceProtocol = 0, 2840 .driver_info = (kernel_ulong_t)&uvc_quirk_stream_no_fid }, 2841 /* Hercules Classic Silver */ 2842 { .match_flags = USB_DEVICE_ID_MATCH_DEVICE 2843 | USB_DEVICE_ID_MATCH_INT_INFO, 2844 .idVendor = 0x06f8, 2845 .idProduct = 0x300c, 2846 .bInterfaceClass = USB_CLASS_VIDEO, 2847 .bInterfaceSubClass = 1, 2848 .bInterfaceProtocol = 0, 2849 .driver_info = (kernel_ulong_t)&uvc_quirk_fix_bandwidth }, 2850 /* ViMicro Vega */ 2851 { .match_flags = USB_DEVICE_ID_MATCH_DEVICE 2852 | USB_DEVICE_ID_MATCH_INT_INFO, 2853 .idVendor = 0x0ac8, 2854 .idProduct = 0x332d, 2855 .bInterfaceClass = USB_CLASS_VIDEO, 2856 .bInterfaceSubClass = 1, 2857 .bInterfaceProtocol = 0, 2858 .driver_info = (kernel_ulong_t)&uvc_quirk_fix_bandwidth }, 2859 /* ViMicro - Minoru3D */ 2860 { .match_flags = USB_DEVICE_ID_MATCH_DEVICE 2861 | USB_DEVICE_ID_MATCH_INT_INFO, 2862 .idVendor = 0x0ac8, 2863 .idProduct = 0x3410, 2864 .bInterfaceClass = USB_CLASS_VIDEO, 2865 .bInterfaceSubClass = 1, 2866 .bInterfaceProtocol = 0, 2867 .driver_info = (kernel_ulong_t)&uvc_quirk_fix_bandwidth }, 2868 /* ViMicro Venus - Minoru3D */ 2869 { .match_flags = USB_DEVICE_ID_MATCH_DEVICE 2870 | USB_DEVICE_ID_MATCH_INT_INFO, 2871 .idVendor = 0x0ac8, 2872 .idProduct = 0x3420, 2873 .bInterfaceClass = USB_CLASS_VIDEO, 2874 .bInterfaceSubClass = 1, 2875 .bInterfaceProtocol = 0, 2876 .driver_info = (kernel_ulong_t)&uvc_quirk_fix_bandwidth }, 2877 /* Ophir Optronics - SPCAM 620U */ 2878 { .match_flags = USB_DEVICE_ID_MATCH_DEVICE 2879 | USB_DEVICE_ID_MATCH_INT_INFO, 2880 .idVendor = 0x0bd3, 2881 .idProduct = 0x0555, 2882 .bInterfaceClass = USB_CLASS_VIDEO, 2883 .bInterfaceSubClass = 1, 2884 .bInterfaceProtocol = 0, 2885 .driver_info = (kernel_ulong_t)&uvc_quirk_probe_minmax }, 2886 /* Sonix Technology Co. Ltd. - 292A IPC AR0330 */ 2887 { .match_flags = USB_DEVICE_ID_MATCH_DEVICE 2888 | USB_DEVICE_ID_MATCH_INT_INFO, 2889 .idVendor = 0x0c45, 2890 .idProduct = 0x6366, 2891 .bInterfaceClass = USB_CLASS_VIDEO, 2892 .bInterfaceSubClass = 1, 2893 .bInterfaceProtocol = 0, 2894 .driver_info = UVC_INFO_QUIRK(UVC_QUIRK_MJPEG_NO_EOF) }, 2895 /* MT6227 */ 2896 { .match_flags = USB_DEVICE_ID_MATCH_DEVICE 2897 | USB_DEVICE_ID_MATCH_INT_INFO, 2898 .idVendor = 0x0e8d, 2899 .idProduct = 0x0004, 2900 .bInterfaceClass = USB_CLASS_VIDEO, 2901 .bInterfaceSubClass = 1, 2902 .bInterfaceProtocol = 0, 2903 .driver_info = UVC_INFO_QUIRK(UVC_QUIRK_PROBE_MINMAX 2904 | UVC_QUIRK_PROBE_DEF) }, 2905 /* IMC Networks (Medion Akoya) */ 2906 { .match_flags = USB_DEVICE_ID_MATCH_DEVICE 2907 | USB_DEVICE_ID_MATCH_INT_INFO, 2908 .idVendor = 0x13d3, 2909 .idProduct = 0x5103, 2910 .bInterfaceClass = USB_CLASS_VIDEO, 2911 .bInterfaceSubClass = 1, 2912 .bInterfaceProtocol = 0, 2913 .driver_info = (kernel_ulong_t)&uvc_quirk_stream_no_fid }, 2914 /* JMicron USB2.0 XGA WebCam */ 2915 { .match_flags = USB_DEVICE_ID_MATCH_DEVICE 2916 | USB_DEVICE_ID_MATCH_INT_INFO, 2917 .idVendor = 0x152d, 2918 .idProduct = 0x0310, 2919 .bInterfaceClass = USB_CLASS_VIDEO, 2920 .bInterfaceSubClass = 1, 2921 .bInterfaceProtocol = 0, 2922 .driver_info = (kernel_ulong_t)&uvc_quirk_probe_minmax }, 2923 /* Kurokesu C1 PRO */ 2924 { .match_flags = USB_DEVICE_ID_MATCH_DEVICE 2925 | USB_DEVICE_ID_MATCH_INT_INFO, 2926 .idVendor = 0x16d0, 2927 .idProduct = 0x0ed1, 2928 .bInterfaceClass = USB_CLASS_VIDEO, 2929 .bInterfaceSubClass = 1, 2930 .bInterfaceProtocol = 0, 2931 .driver_info = UVC_INFO_QUIRK(UVC_QUIRK_MJPEG_NO_EOF) }, 2932 /* Syntek (HP Spartan) */ 2933 { .match_flags = USB_DEVICE_ID_MATCH_DEVICE 2934 | USB_DEVICE_ID_MATCH_INT_INFO, 2935 .idVendor = 0x174f, 2936 .idProduct = 0x5212, 2937 .bInterfaceClass = USB_CLASS_VIDEO, 2938 .bInterfaceSubClass = 1, 2939 .bInterfaceProtocol = 0, 2940 .driver_info = (kernel_ulong_t)&uvc_quirk_stream_no_fid }, 2941 /* Syntek (Samsung Q310) */ 2942 { .match_flags = USB_DEVICE_ID_MATCH_DEVICE 2943 | USB_DEVICE_ID_MATCH_INT_INFO, 2944 .idVendor = 0x174f, 2945 .idProduct = 0x5931, 2946 .bInterfaceClass = USB_CLASS_VIDEO, 2947 .bInterfaceSubClass = 1, 2948 .bInterfaceProtocol = 0, 2949 .driver_info = (kernel_ulong_t)&uvc_quirk_stream_no_fid }, 2950 /* Syntek (Packard Bell EasyNote MX52 */ 2951 { .match_flags = USB_DEVICE_ID_MATCH_DEVICE 2952 | USB_DEVICE_ID_MATCH_INT_INFO, 2953 .idVendor = 0x174f, 2954 .idProduct = 0x8a12, 2955 .bInterfaceClass = USB_CLASS_VIDEO, 2956 .bInterfaceSubClass = 1, 2957 .bInterfaceProtocol = 0, 2958 .driver_info = (kernel_ulong_t)&uvc_quirk_stream_no_fid }, 2959 /* Syntek (Asus F9SG) */ 2960 { .match_flags = USB_DEVICE_ID_MATCH_DEVICE 2961 | USB_DEVICE_ID_MATCH_INT_INFO, 2962 .idVendor = 0x174f, 2963 .idProduct = 0x8a31, 2964 .bInterfaceClass = USB_CLASS_VIDEO, 2965 .bInterfaceSubClass = 1, 2966 .bInterfaceProtocol = 0, 2967 .driver_info = (kernel_ulong_t)&uvc_quirk_stream_no_fid }, 2968 /* Syntek (Asus U3S) */ 2969 { .match_flags = USB_DEVICE_ID_MATCH_DEVICE 2970 | USB_DEVICE_ID_MATCH_INT_INFO, 2971 .idVendor = 0x174f, 2972 .idProduct = 0x8a33, 2973 .bInterfaceClass = USB_CLASS_VIDEO, 2974 .bInterfaceSubClass = 1, 2975 .bInterfaceProtocol = 0, 2976 .driver_info = (kernel_ulong_t)&uvc_quirk_stream_no_fid }, 2977 /* Syntek (JAOtech Smart Terminal) */ 2978 { .match_flags = USB_DEVICE_ID_MATCH_DEVICE 2979 | USB_DEVICE_ID_MATCH_INT_INFO, 2980 .idVendor = 0x174f, 2981 .idProduct = 0x8a34, 2982 .bInterfaceClass = USB_CLASS_VIDEO, 2983 .bInterfaceSubClass = 1, 2984 .bInterfaceProtocol = 0, 2985 .driver_info = (kernel_ulong_t)&uvc_quirk_stream_no_fid }, 2986 /* Miricle 307K */ 2987 { .match_flags = USB_DEVICE_ID_MATCH_DEVICE 2988 | USB_DEVICE_ID_MATCH_INT_INFO, 2989 .idVendor = 0x17dc, 2990 .idProduct = 0x0202, 2991 .bInterfaceClass = USB_CLASS_VIDEO, 2992 .bInterfaceSubClass = 1, 2993 .bInterfaceProtocol = 0, 2994 .driver_info = (kernel_ulong_t)&uvc_quirk_stream_no_fid }, 2995 /* Lenovo Thinkpad SL400/SL500 */ 2996 { .match_flags = USB_DEVICE_ID_MATCH_DEVICE 2997 | USB_DEVICE_ID_MATCH_INT_INFO, 2998 .idVendor = 0x17ef, 2999 .idProduct = 0x480b, 3000 .bInterfaceClass = USB_CLASS_VIDEO, 3001 .bInterfaceSubClass = 1, 3002 .bInterfaceProtocol = 0, 3003 .driver_info = (kernel_ulong_t)&uvc_quirk_stream_no_fid }, 3004 /* Aveo Technology USB 2.0 Camera */ 3005 { .match_flags = USB_DEVICE_ID_MATCH_DEVICE 3006 | USB_DEVICE_ID_MATCH_INT_INFO, 3007 .idVendor = 0x1871, 3008 .idProduct = 0x0306, 3009 .bInterfaceClass = USB_CLASS_VIDEO, 3010 .bInterfaceSubClass = 1, 3011 .bInterfaceProtocol = 0, 3012 .driver_info = UVC_INFO_QUIRK(UVC_QUIRK_PROBE_MINMAX 3013 | UVC_QUIRK_PROBE_EXTRAFIELDS) }, 3014 /* Aveo Technology USB 2.0 Camera (Tasco USB Microscope) */ 3015 { .match_flags = USB_DEVICE_ID_MATCH_DEVICE 3016 | USB_DEVICE_ID_MATCH_INT_INFO, 3017 .idVendor = 0x1871, 3018 .idProduct = 0x0516, 3019 .bInterfaceClass = USB_CLASS_VENDOR_SPEC, 3020 .bInterfaceSubClass = 1, 3021 .bInterfaceProtocol = 0 }, 3022 /* Ecamm Pico iMage */ 3023 { .match_flags = USB_DEVICE_ID_MATCH_DEVICE 3024 | USB_DEVICE_ID_MATCH_INT_INFO, 3025 .idVendor = 0x18cd, 3026 .idProduct = 0xcafe, 3027 .bInterfaceClass = USB_CLASS_VIDEO, 3028 .bInterfaceSubClass = 1, 3029 .bInterfaceProtocol = 0, 3030 .driver_info = UVC_INFO_QUIRK(UVC_QUIRK_PROBE_EXTRAFIELDS) }, 3031 /* Manta MM-353 Plako */ 3032 { .match_flags = USB_DEVICE_ID_MATCH_DEVICE 3033 | USB_DEVICE_ID_MATCH_INT_INFO, 3034 .idVendor = 0x18ec, 3035 .idProduct = 0x3188, 3036 .bInterfaceClass = USB_CLASS_VIDEO, 3037 .bInterfaceSubClass = 1, 3038 .bInterfaceProtocol = 0, 3039 .driver_info = (kernel_ulong_t)&uvc_quirk_probe_minmax }, 3040 /* FSC WebCam V30S */ 3041 { .match_flags = USB_DEVICE_ID_MATCH_DEVICE 3042 | USB_DEVICE_ID_MATCH_INT_INFO, 3043 .idVendor = 0x18ec, 3044 .idProduct = 0x3288, 3045 .bInterfaceClass = USB_CLASS_VIDEO, 3046 .bInterfaceSubClass = 1, 3047 .bInterfaceProtocol = 0, 3048 .driver_info = (kernel_ulong_t)&uvc_quirk_probe_minmax }, 3049 /* Arkmicro unbranded */ 3050 { .match_flags = USB_DEVICE_ID_MATCH_DEVICE 3051 | USB_DEVICE_ID_MATCH_INT_INFO, 3052 .idVendor = 0x18ec, 3053 .idProduct = 0x3290, 3054 .bInterfaceClass = USB_CLASS_VIDEO, 3055 .bInterfaceSubClass = 1, 3056 .bInterfaceProtocol = 0, 3057 .driver_info = (kernel_ulong_t)&uvc_quirk_probe_def }, 3058 /* The Imaging Source USB CCD cameras */ 3059 { .match_flags = USB_DEVICE_ID_MATCH_DEVICE 3060 | USB_DEVICE_ID_MATCH_INT_INFO, 3061 .idVendor = 0x199e, 3062 .idProduct = 0x8102, 3063 .bInterfaceClass = USB_CLASS_VENDOR_SPEC, 3064 .bInterfaceSubClass = 1, 3065 .bInterfaceProtocol = 0 }, 3066 /* Bodelin ProScopeHR */ 3067 { .match_flags = USB_DEVICE_ID_MATCH_DEVICE 3068 | USB_DEVICE_ID_MATCH_DEV_HI 3069 | USB_DEVICE_ID_MATCH_INT_INFO, 3070 .idVendor = 0x19ab, 3071 .idProduct = 0x1000, 3072 .bcdDevice_hi = 0x0126, 3073 .bInterfaceClass = USB_CLASS_VIDEO, 3074 .bInterfaceSubClass = 1, 3075 .bInterfaceProtocol = 0, 3076 .driver_info = UVC_INFO_QUIRK(UVC_QUIRK_STATUS_INTERVAL) }, 3077 /* MSI StarCam 370i */ 3078 { .match_flags = USB_DEVICE_ID_MATCH_DEVICE 3079 | USB_DEVICE_ID_MATCH_INT_INFO, 3080 .idVendor = 0x1b3b, 3081 .idProduct = 0x2951, 3082 .bInterfaceClass = USB_CLASS_VIDEO, 3083 .bInterfaceSubClass = 1, 3084 .bInterfaceProtocol = 0, 3085 .driver_info = (kernel_ulong_t)&uvc_quirk_probe_minmax }, 3086 /* Generalplus Technology Inc. 808 Camera */ 3087 { .match_flags = USB_DEVICE_ID_MATCH_DEVICE 3088 | USB_DEVICE_ID_MATCH_INT_INFO, 3089 .idVendor = 0x1b3f, 3090 .idProduct = 0x2002, 3091 .bInterfaceClass = USB_CLASS_VIDEO, 3092 .bInterfaceSubClass = 1, 3093 .bInterfaceProtocol = 0, 3094 .driver_info = (kernel_ulong_t)&uvc_quirk_probe_minmax }, 3095 /* Shenzhen Aoni Electronic Co.,Ltd 2K FHD camera */ 3096 { .match_flags = USB_DEVICE_ID_MATCH_DEVICE 3097 | USB_DEVICE_ID_MATCH_INT_INFO, 3098 .idVendor = 0x1bcf, 3099 .idProduct = 0x0b40, 3100 .bInterfaceClass = USB_CLASS_VIDEO, 3101 .bInterfaceSubClass = 1, 3102 .bInterfaceProtocol = 0, 3103 .driver_info = (kernel_ulong_t)&(const struct uvc_device_info){ 3104 .uvc_version = 0x010a, 3105 } }, 3106 /* SiGma Micro USB Web Camera */ 3107 { .match_flags = USB_DEVICE_ID_MATCH_DEVICE 3108 | USB_DEVICE_ID_MATCH_INT_INFO, 3109 .idVendor = 0x1c4f, 3110 .idProduct = 0x3000, 3111 .bInterfaceClass = USB_CLASS_VIDEO, 3112 .bInterfaceSubClass = 1, 3113 .bInterfaceProtocol = 0, 3114 .driver_info = UVC_INFO_QUIRK(UVC_QUIRK_PROBE_MINMAX 3115 | UVC_QUIRK_IGNORE_SELECTOR_UNIT) }, 3116 /* Actions Microelectronics Co. Display capture-UVC05 */ 3117 { .match_flags = USB_DEVICE_ID_MATCH_DEVICE 3118 | USB_DEVICE_ID_MATCH_INT_INFO, 3119 .idVendor = 0x1de1, 3120 .idProduct = 0xf105, 3121 .bInterfaceClass = USB_CLASS_VIDEO, 3122 .bInterfaceSubClass = 1, 3123 .bInterfaceProtocol = 0, 3124 .driver_info = UVC_INFO_QUIRK(UVC_QUIRK_DISABLE_AUTOSUSPEND) }, 3125 /* NXP Semiconductors IR VIDEO */ 3126 { .match_flags = USB_DEVICE_ID_MATCH_DEVICE 3127 | USB_DEVICE_ID_MATCH_INT_INFO, 3128 .idVendor = 0x1fc9, 3129 .idProduct = 0x009b, 3130 .bInterfaceClass = USB_CLASS_VIDEO, 3131 .bInterfaceSubClass = 1, 3132 .bInterfaceProtocol = 0, 3133 .driver_info = (kernel_ulong_t)&uvc_quirk_probe_minmax }, 3134 /* Oculus VR Positional Tracker DK2 */ 3135 { .match_flags = USB_DEVICE_ID_MATCH_DEVICE 3136 | USB_DEVICE_ID_MATCH_INT_INFO, 3137 .idVendor = 0x2833, 3138 .idProduct = 0x0201, 3139 .bInterfaceClass = USB_CLASS_VIDEO, 3140 .bInterfaceSubClass = 1, 3141 .bInterfaceProtocol = 0, 3142 .driver_info = (kernel_ulong_t)&uvc_quirk_force_y8 }, 3143 /* Oculus VR Rift Sensor */ 3144 { .match_flags = USB_DEVICE_ID_MATCH_DEVICE 3145 | USB_DEVICE_ID_MATCH_INT_INFO, 3146 .idVendor = 0x2833, 3147 .idProduct = 0x0211, 3148 .bInterfaceClass = USB_CLASS_VENDOR_SPEC, 3149 .bInterfaceSubClass = 1, 3150 .bInterfaceProtocol = 0, 3151 .driver_info = (kernel_ulong_t)&uvc_quirk_force_y8 }, 3152 /* GEO Semiconductor GC6500 */ 3153 { .match_flags = USB_DEVICE_ID_MATCH_DEVICE 3154 | USB_DEVICE_ID_MATCH_INT_INFO, 3155 .idVendor = 0x29fe, 3156 .idProduct = 0x4d53, 3157 .bInterfaceClass = USB_CLASS_VIDEO, 3158 .bInterfaceSubClass = 1, 3159 .bInterfaceProtocol = 0, 3160 .driver_info = UVC_INFO_QUIRK(UVC_QUIRK_FORCE_BPP) }, 3161 /* Insta360 Link */ 3162 { .match_flags = USB_DEVICE_ID_MATCH_DEVICE 3163 | USB_DEVICE_ID_MATCH_INT_INFO, 3164 .idVendor = 0x2e1a, 3165 .idProduct = 0x4c01, 3166 .bInterfaceClass = USB_CLASS_VIDEO, 3167 .bInterfaceSubClass = 1, 3168 .bInterfaceProtocol = 0, 3169 .driver_info = UVC_INFO_QUIRK(UVC_QUIRK_DISABLE_AUTOSUSPEND) }, 3170 /* Intel D410/ASR depth camera */ 3171 { .match_flags = USB_DEVICE_ID_MATCH_DEVICE 3172 | USB_DEVICE_ID_MATCH_INT_INFO, 3173 .idVendor = 0x8086, 3174 .idProduct = 0x0ad2, 3175 .bInterfaceClass = USB_CLASS_VIDEO, 3176 .bInterfaceSubClass = 1, 3177 .bInterfaceProtocol = 0, 3178 .driver_info = UVC_INFO_META(V4L2_META_FMT_D4XX) }, 3179 /* Intel D415/ASRC depth camera */ 3180 { .match_flags = USB_DEVICE_ID_MATCH_DEVICE 3181 | USB_DEVICE_ID_MATCH_INT_INFO, 3182 .idVendor = 0x8086, 3183 .idProduct = 0x0ad3, 3184 .bInterfaceClass = USB_CLASS_VIDEO, 3185 .bInterfaceSubClass = 1, 3186 .bInterfaceProtocol = 0, 3187 .driver_info = UVC_INFO_META(V4L2_META_FMT_D4XX) }, 3188 /* Intel D430/AWG depth camera */ 3189 { .match_flags = USB_DEVICE_ID_MATCH_DEVICE 3190 | USB_DEVICE_ID_MATCH_INT_INFO, 3191 .idVendor = 0x8086, 3192 .idProduct = 0x0ad4, 3193 .bInterfaceClass = USB_CLASS_VIDEO, 3194 .bInterfaceSubClass = 1, 3195 .bInterfaceProtocol = 0, 3196 .driver_info = UVC_INFO_META(V4L2_META_FMT_D4XX) }, 3197 /* Intel RealSense D4M */ 3198 { .match_flags = USB_DEVICE_ID_MATCH_DEVICE 3199 | USB_DEVICE_ID_MATCH_INT_INFO, 3200 .idVendor = 0x8086, 3201 .idProduct = 0x0b03, 3202 .bInterfaceClass = USB_CLASS_VIDEO, 3203 .bInterfaceSubClass = 1, 3204 .bInterfaceProtocol = 0, 3205 .driver_info = UVC_INFO_META(V4L2_META_FMT_D4XX) }, 3206 /* Intel D435/AWGC depth camera */ 3207 { .match_flags = USB_DEVICE_ID_MATCH_DEVICE 3208 | USB_DEVICE_ID_MATCH_INT_INFO, 3209 .idVendor = 0x8086, 3210 .idProduct = 0x0b07, 3211 .bInterfaceClass = USB_CLASS_VIDEO, 3212 .bInterfaceSubClass = 1, 3213 .bInterfaceProtocol = 0, 3214 .driver_info = UVC_INFO_META(V4L2_META_FMT_D4XX) }, 3215 /* Intel D435i depth camera */ 3216 { .match_flags = USB_DEVICE_ID_MATCH_DEVICE 3217 | USB_DEVICE_ID_MATCH_INT_INFO, 3218 .idVendor = 0x8086, 3219 .idProduct = 0x0b3a, 3220 .bInterfaceClass = USB_CLASS_VIDEO, 3221 .bInterfaceSubClass = 1, 3222 .bInterfaceProtocol = 0, 3223 .driver_info = UVC_INFO_META(V4L2_META_FMT_D4XX) }, 3224 /* Intel D405 Depth Camera */ 3225 { .match_flags = USB_DEVICE_ID_MATCH_DEVICE 3226 | USB_DEVICE_ID_MATCH_INT_INFO, 3227 .idVendor = 0x8086, 3228 .idProduct = 0x0b5b, 3229 .bInterfaceClass = USB_CLASS_VIDEO, 3230 .bInterfaceSubClass = 1, 3231 .bInterfaceProtocol = 0, 3232 .driver_info = UVC_INFO_META(V4L2_META_FMT_D4XX) }, 3233 /* Intel D455 Depth Camera */ 3234 { .match_flags = USB_DEVICE_ID_MATCH_DEVICE 3235 | USB_DEVICE_ID_MATCH_INT_INFO, 3236 .idVendor = 0x8086, 3237 .idProduct = 0x0b5c, 3238 .bInterfaceClass = USB_CLASS_VIDEO, 3239 .bInterfaceSubClass = 1, 3240 .bInterfaceProtocol = 0, 3241 .driver_info = UVC_INFO_META(V4L2_META_FMT_D4XX) }, 3242 /* Intel D421 Depth Module */ 3243 { .match_flags = USB_DEVICE_ID_MATCH_DEVICE 3244 | USB_DEVICE_ID_MATCH_INT_INFO, 3245 .idVendor = 0x8086, 3246 .idProduct = 0x1155, 3247 .bInterfaceClass = USB_CLASS_VIDEO, 3248 .bInterfaceSubClass = 1, 3249 .bInterfaceProtocol = 0, 3250 .driver_info = UVC_INFO_META(V4L2_META_FMT_D4XX) }, 3251 /* Generic USB Video Class */ 3252 { USB_INTERFACE_INFO(USB_CLASS_VIDEO, 1, UVC_PC_PROTOCOL_UNDEFINED) }, 3253 { USB_INTERFACE_INFO(USB_CLASS_VIDEO, 1, UVC_PC_PROTOCOL_15) }, 3254 {} 3255}; 3256 3257MODULE_DEVICE_TABLE(usb, uvc_ids); 3258 3259static struct usb_driver uvc_driver = { 3260 .name = "uvcvideo", 3261 .probe = uvc_probe, 3262 .disconnect = uvc_disconnect, 3263 .suspend = uvc_suspend, 3264 .resume = uvc_resume, 3265 .reset_resume = uvc_reset_resume, 3266 .id_table = uvc_ids, 3267 .supports_autosuspend = 1, 3268}; 3269 3270static int __init uvc_init(void) 3271{ 3272 int ret; 3273 3274 uvc_debugfs_init(); 3275 3276 ret = usb_register(&uvc_driver); 3277 if (ret < 0) { 3278 uvc_debugfs_cleanup(); 3279 return ret; 3280 } 3281 3282 return 0; 3283} 3284 3285static void __exit uvc_cleanup(void) 3286{ 3287 usb_deregister(&uvc_driver); 3288 uvc_debugfs_cleanup(); 3289} 3290 3291module_init(uvc_init); 3292module_exit(uvc_cleanup); 3293 3294MODULE_AUTHOR(DRIVER_AUTHOR); 3295MODULE_DESCRIPTION(DRIVER_DESC); 3296MODULE_LICENSE("GPL"); 3297MODULE_VERSION(DRIVER_VERSION); 3298
~/
Read-only file preview.