1 /* 2 * uvc_v4l2.c -- USB Video Class driver - V4L2 API 3 * 4 * Copyright (C) 2005-2010 5 * Laurent Pinchart (laurent.pinchart@ideasonboard.com) 6 * 7 * This program is free software; you can redistribute it and/or modify 8 * it under the terms of the GNU General Public License as published by 9 * the Free Software Foundation; either version 2 of the License, or 10 * (at your option) any later version. 11 * 12 */ 13 14 #include <linux/compat.h> 15 #include <linux/kernel.h> 16 #include <linux/list.h> 17 #include <linux/module.h> 18 #include <linux/slab.h> 19 #include <linux/usb.h> 20 #include <linux/videodev2.h> 21 #include <linux/vmalloc.h> 22 #include <linux/mm.h> 23 #include <linux/wait.h> 24 #include <linux/atomic.h> 25 26 #include <media/v4l2-common.h> 27 #include <media/v4l2-ctrls.h> 28 #include <media/v4l2-event.h> 29 #include <media/v4l2-ioctl.h> 30 31 #include "uvcvideo.h" 32 33 /* ------------------------------------------------------------------------ 34 * UVC ioctls 35 */ 36 static int uvc_ioctl_ctrl_map(struct uvc_video_chain *chain, 37 struct uvc_xu_control_mapping *xmap) 38 { 39 struct uvc_control_mapping *map; 40 unsigned int size; 41 int ret; 42 43 map = kzalloc(sizeof(*map), GFP_KERNEL); 44 if (map == NULL) 45 return -ENOMEM; 46 47 map->id = xmap->id; 48 memcpy(map->name, xmap->name, sizeof(map->name)); 49 memcpy(map->entity, xmap->entity, sizeof(map->entity)); 50 map->selector = xmap->selector; 51 map->size = xmap->size; 52 map->offset = xmap->offset; 53 map->v4l2_type = xmap->v4l2_type; 54 map->data_type = xmap->data_type; 55 56 switch (xmap->v4l2_type) { 57 case V4L2_CTRL_TYPE_INTEGER: 58 case V4L2_CTRL_TYPE_BOOLEAN: 59 case V4L2_CTRL_TYPE_BUTTON: 60 break; 61 62 case V4L2_CTRL_TYPE_MENU: 63 /* Prevent excessive memory consumption, as well as integer 64 * overflows. 65 */ 66 if (xmap->menu_count == 0 || 67 xmap->menu_count > UVC_MAX_CONTROL_MENU_ENTRIES) { 68 ret = -EINVAL; 69 goto free_map; 70 } 71 72 size = xmap->menu_count * sizeof(*map->menu_info); 73 map->menu_info = memdup_user(xmap->menu_info, size); 74 if (IS_ERR(map->menu_info)) { 75 ret = PTR_ERR(map->menu_info); 76 goto free_map; 77 } 78 79 map->menu_count = xmap->menu_count; 80 break; 81 82 default: 83 uvc_trace(UVC_TRACE_CONTROL, "Unsupported V4L2 control type " 84 "%u.\n", xmap->v4l2_type); 85 ret = -ENOTTY; 86 goto free_map; 87 } 88 89 ret = uvc_ctrl_add_mapping(chain, map); 90 91 kfree(map->menu_info); 92 free_map: 93 kfree(map); 94 95 return ret; 96 } 97 98 /* ------------------------------------------------------------------------ 99 * V4L2 interface 100 */ 101 102 /* 103 * Find the frame interval closest to the requested frame interval for the 104 * given frame format and size. This should be done by the device as part of 105 * the Video Probe and Commit negotiation, but some hardware don't implement 106 * that feature. 107 */ 108 static u32 uvc_try_frame_interval(struct uvc_frame *frame, u32 interval) 109 { 110 unsigned int i; 111 112 if (frame->bFrameIntervalType) { 113 u32 best = -1, dist; 114 115 for (i = 0; i < frame->bFrameIntervalType; ++i) { 116 dist = interval > frame->dwFrameInterval[i] 117 ? interval - frame->dwFrameInterval[i] 118 : frame->dwFrameInterval[i] - interval; 119 120 if (dist > best) 121 break; 122 123 best = dist; 124 } 125 126 interval = frame->dwFrameInterval[i-1]; 127 } else { 128 const u32 min = frame->dwFrameInterval[0]; 129 const u32 max = frame->dwFrameInterval[1]; 130 const u32 step = frame->dwFrameInterval[2]; 131 132 interval = min + (interval - min + step/2) / step * step; 133 if (interval > max) 134 interval = max; 135 } 136 137 return interval; 138 } 139 140 static u32 uvc_v4l2_get_bytesperline(const struct uvc_format *format, 141 const struct uvc_frame *frame) 142 { 143 switch (format->fcc) { 144 case V4L2_PIX_FMT_NV12: 145 case V4L2_PIX_FMT_YVU420: 146 case V4L2_PIX_FMT_YUV420: 147 case V4L2_PIX_FMT_M420: 148 return frame->wWidth; 149 150 default: 151 return format->bpp * frame->wWidth / 8; 152 } 153 } 154 155 static int uvc_v4l2_try_format(struct uvc_streaming *stream, 156 struct v4l2_format *fmt, struct uvc_streaming_control *probe, 157 struct uvc_format **uvc_format, struct uvc_frame **uvc_frame) 158 { 159 struct uvc_format *format = NULL; 160 struct uvc_frame *frame = NULL; 161 u16 rw, rh; 162 unsigned int d, maxd; 163 unsigned int i; 164 u32 interval; 165 int ret = 0; 166 u8 *fcc; 167 168 if (fmt->type != stream->type) 169 return -EINVAL; 170 171 fcc = (u8 *)&fmt->fmt.pix.pixelformat; 172 uvc_trace(UVC_TRACE_FORMAT, "Trying format 0x%08x (%c%c%c%c): %ux%u.\n", 173 fmt->fmt.pix.pixelformat, 174 fcc[0], fcc[1], fcc[2], fcc[3], 175 fmt->fmt.pix.width, fmt->fmt.pix.height); 176 177 /* Check if the hardware supports the requested format, use the default 178 * format otherwise. 179 */ 180 for (i = 0; i < stream->nformats; ++i) { 181 format = &stream->format[i]; 182 if (format->fcc == fmt->fmt.pix.pixelformat) 183 break; 184 } 185 186 if (i == stream->nformats) { 187 format = stream->def_format; 188 fmt->fmt.pix.pixelformat = format->fcc; 189 } 190 191 /* Find the closest image size. The distance between image sizes is 192 * the size in pixels of the non-overlapping regions between the 193 * requested size and the frame-specified size. 194 */ 195 rw = fmt->fmt.pix.width; 196 rh = fmt->fmt.pix.height; 197 maxd = (unsigned int)-1; 198 199 for (i = 0; i < format->nframes; ++i) { 200 u16 w = format->frame[i].wWidth; 201 u16 h = format->frame[i].wHeight; 202 203 d = min(w, rw) * min(h, rh); 204 d = w*h + rw*rh - 2*d; 205 if (d < maxd) { 206 maxd = d; 207 frame = &format->frame[i]; 208 } 209 210 if (maxd == 0) 211 break; 212 } 213 214 if (frame == NULL) { 215 uvc_trace(UVC_TRACE_FORMAT, "Unsupported size %ux%u.\n", 216 fmt->fmt.pix.width, fmt->fmt.pix.height); 217 return -EINVAL; 218 } 219 220 /* Use the default frame interval. */ 221 interval = frame->dwDefaultFrameInterval; 222 uvc_trace(UVC_TRACE_FORMAT, "Using default frame interval %u.%u us " 223 "(%u.%u fps).\n", interval/10, interval%10, 10000000/interval, 224 (100000000/interval)%10); 225 226 /* Set the format index, frame index and frame interval. */ 227 memset(probe, 0, sizeof(*probe)); 228 probe->bmHint = 1; /* dwFrameInterval */ 229 probe->bFormatIndex = format->index; 230 probe->bFrameIndex = frame->bFrameIndex; 231 probe->dwFrameInterval = uvc_try_frame_interval(frame, interval); 232 /* Some webcams stall the probe control set request when the 233 * dwMaxVideoFrameSize field is set to zero. The UVC specification 234 * clearly states that the field is read-only from the host, so this 235 * is a webcam bug. Set dwMaxVideoFrameSize to the value reported by 236 * the webcam to work around the problem. 237 * 238 * The workaround could probably be enabled for all webcams, so the 239 * quirk can be removed if needed. It's currently useful to detect 240 * webcam bugs and fix them before they hit the market (providing 241 * developers test their webcams with the Linux driver as well as with 242 * the Windows driver). 243 */ 244 mutex_lock(&stream->mutex); 245 if (stream->dev->quirks & UVC_QUIRK_PROBE_EXTRAFIELDS) 246 probe->dwMaxVideoFrameSize = 247 stream->ctrl.dwMaxVideoFrameSize; 248 249 /* Probe the device. */ 250 ret = uvc_probe_video(stream, probe); 251 mutex_unlock(&stream->mutex); 252 if (ret < 0) 253 goto done; 254 255 fmt->fmt.pix.width = frame->wWidth; 256 fmt->fmt.pix.height = frame->wHeight; 257 fmt->fmt.pix.field = V4L2_FIELD_NONE; 258 fmt->fmt.pix.bytesperline = uvc_v4l2_get_bytesperline(format, frame); 259 fmt->fmt.pix.sizeimage = probe->dwMaxVideoFrameSize; 260 fmt->fmt.pix.colorspace = format->colorspace; 261 fmt->fmt.pix.priv = 0; 262 263 if (uvc_format != NULL) 264 *uvc_format = format; 265 if (uvc_frame != NULL) 266 *uvc_frame = frame; 267 268 done: 269 return ret; 270 } 271 272 static int uvc_v4l2_get_format(struct uvc_streaming *stream, 273 struct v4l2_format *fmt) 274 { 275 struct uvc_format *format; 276 struct uvc_frame *frame; 277 int ret = 0; 278 279 if (fmt->type != stream->type) 280 return -EINVAL; 281 282 mutex_lock(&stream->mutex); 283 format = stream->cur_format; 284 frame = stream->cur_frame; 285 286 if (format == NULL || frame == NULL) { 287 ret = -EINVAL; 288 goto done; 289 } 290 291 fmt->fmt.pix.pixelformat = format->fcc; 292 fmt->fmt.pix.width = frame->wWidth; 293 fmt->fmt.pix.height = frame->wHeight; 294 fmt->fmt.pix.field = V4L2_FIELD_NONE; 295 fmt->fmt.pix.bytesperline = uvc_v4l2_get_bytesperline(format, frame); 296 fmt->fmt.pix.sizeimage = stream->ctrl.dwMaxVideoFrameSize; 297 fmt->fmt.pix.colorspace = format->colorspace; 298 fmt->fmt.pix.priv = 0; 299 300 done: 301 mutex_unlock(&stream->mutex); 302 return ret; 303 } 304 305 static int uvc_v4l2_set_format(struct uvc_streaming *stream, 306 struct v4l2_format *fmt) 307 { 308 struct uvc_streaming_control probe; 309 struct uvc_format *format; 310 struct uvc_frame *frame; 311 int ret; 312 313 if (fmt->type != stream->type) 314 return -EINVAL; 315 316 ret = uvc_v4l2_try_format(stream, fmt, &probe, &format, &frame); 317 if (ret < 0) 318 return ret; 319 320 mutex_lock(&stream->mutex); 321 322 if (uvc_queue_allocated(&stream->queue)) { 323 ret = -EBUSY; 324 goto done; 325 } 326 327 stream->ctrl = probe; 328 stream->cur_format = format; 329 stream->cur_frame = frame; 330 331 done: 332 mutex_unlock(&stream->mutex); 333 return ret; 334 } 335 336 static int uvc_v4l2_get_streamparm(struct uvc_streaming *stream, 337 struct v4l2_streamparm *parm) 338 { 339 u32 numerator, denominator; 340 341 if (parm->type != stream->type) 342 return -EINVAL; 343 344 mutex_lock(&stream->mutex); 345 numerator = stream->ctrl.dwFrameInterval; 346 mutex_unlock(&stream->mutex); 347 348 denominator = 10000000; 349 uvc_simplify_fraction(&numerator, &denominator, 8, 333); 350 351 memset(parm, 0, sizeof(*parm)); 352 parm->type = stream->type; 353 354 if (stream->type == V4L2_BUF_TYPE_VIDEO_CAPTURE) { 355 parm->parm.capture.capability = V4L2_CAP_TIMEPERFRAME; 356 parm->parm.capture.capturemode = 0; 357 parm->parm.capture.timeperframe.numerator = numerator; 358 parm->parm.capture.timeperframe.denominator = denominator; 359 parm->parm.capture.extendedmode = 0; 360 parm->parm.capture.readbuffers = 0; 361 } else { 362 parm->parm.output.capability = V4L2_CAP_TIMEPERFRAME; 363 parm->parm.output.outputmode = 0; 364 parm->parm.output.timeperframe.numerator = numerator; 365 parm->parm.output.timeperframe.denominator = denominator; 366 } 367 368 return 0; 369 } 370 371 static int uvc_v4l2_set_streamparm(struct uvc_streaming *stream, 372 struct v4l2_streamparm *parm) 373 { 374 struct uvc_streaming_control probe; 375 struct v4l2_fract timeperframe; 376 struct uvc_format *format; 377 struct uvc_frame *frame; 378 u32 interval, maxd; 379 unsigned int i; 380 int ret; 381 382 if (parm->type != stream->type) 383 return -EINVAL; 384 385 if (parm->type == V4L2_BUF_TYPE_VIDEO_CAPTURE) 386 timeperframe = parm->parm.capture.timeperframe; 387 else 388 timeperframe = parm->parm.output.timeperframe; 389 390 interval = uvc_fraction_to_interval(timeperframe.numerator, 391 timeperframe.denominator); 392 uvc_trace(UVC_TRACE_FORMAT, "Setting frame interval to %u/%u (%u).\n", 393 timeperframe.numerator, timeperframe.denominator, interval); 394 395 mutex_lock(&stream->mutex); 396 397 if (uvc_queue_streaming(&stream->queue)) { 398 mutex_unlock(&stream->mutex); 399 return -EBUSY; 400 } 401 402 format = stream->cur_format; 403 frame = stream->cur_frame; 404 probe = stream->ctrl; 405 probe.dwFrameInterval = uvc_try_frame_interval(frame, interval); 406 maxd = abs((s32)probe.dwFrameInterval - interval); 407 408 /* Try frames with matching size to find the best frame interval. */ 409 for (i = 0; i < format->nframes && maxd != 0; i++) { 410 u32 d, ival; 411 412 if (&format->frame[i] == stream->cur_frame) 413 continue; 414 415 if (format->frame[i].wWidth != stream->cur_frame->wWidth || 416 format->frame[i].wHeight != stream->cur_frame->wHeight) 417 continue; 418 419 ival = uvc_try_frame_interval(&format->frame[i], interval); 420 d = abs((s32)ival - interval); 421 if (d >= maxd) 422 continue; 423 424 frame = &format->frame[i]; 425 probe.bFrameIndex = frame->bFrameIndex; 426 probe.dwFrameInterval = ival; 427 maxd = d; 428 } 429 430 /* Probe the device with the new settings. */ 431 ret = uvc_probe_video(stream, &probe); 432 if (ret < 0) { 433 mutex_unlock(&stream->mutex); 434 return ret; 435 } 436 437 stream->ctrl = probe; 438 stream->cur_frame = frame; 439 mutex_unlock(&stream->mutex); 440 441 /* Return the actual frame period. */ 442 timeperframe.numerator = probe.dwFrameInterval; 443 timeperframe.denominator = 10000000; 444 uvc_simplify_fraction(&timeperframe.numerator, 445 &timeperframe.denominator, 8, 333); 446 447 if (parm->type == V4L2_BUF_TYPE_VIDEO_CAPTURE) 448 parm->parm.capture.timeperframe = timeperframe; 449 else 450 parm->parm.output.timeperframe = timeperframe; 451 452 return 0; 453 } 454 455 /* ------------------------------------------------------------------------ 456 * Privilege management 457 */ 458 459 /* 460 * Privilege management is the multiple-open implementation basis. The current 461 * implementation is completely transparent for the end-user and doesn't 462 * require explicit use of the VIDIOC_G_PRIORITY and VIDIOC_S_PRIORITY ioctls. 463 * Those ioctls enable finer control on the device (by making possible for a 464 * user to request exclusive access to a device), but are not mature yet. 465 * Switching to the V4L2 priority mechanism might be considered in the future 466 * if this situation changes. 467 * 468 * Each open instance of a UVC device can either be in a privileged or 469 * unprivileged state. Only a single instance can be in a privileged state at 470 * a given time. Trying to perform an operation that requires privileges will 471 * automatically acquire the required privileges if possible, or return -EBUSY 472 * otherwise. Privileges are dismissed when closing the instance or when 473 * freeing the video buffers using VIDIOC_REQBUFS. 474 * 475 * Operations that require privileges are: 476 * 477 * - VIDIOC_S_INPUT 478 * - VIDIOC_S_PARM 479 * - VIDIOC_S_FMT 480 * - VIDIOC_REQBUFS 481 */ 482 static int uvc_acquire_privileges(struct uvc_fh *handle) 483 { 484 /* Always succeed if the handle is already privileged. */ 485 if (handle->state == UVC_HANDLE_ACTIVE) 486 return 0; 487 488 /* Check if the device already has a privileged handle. */ 489 if (atomic_inc_return(&handle->stream->active) != 1) { 490 atomic_dec(&handle->stream->active); 491 return -EBUSY; 492 } 493 494 handle->state = UVC_HANDLE_ACTIVE; 495 return 0; 496 } 497 498 static void uvc_dismiss_privileges(struct uvc_fh *handle) 499 { 500 if (handle->state == UVC_HANDLE_ACTIVE) 501 atomic_dec(&handle->stream->active); 502 503 handle->state = UVC_HANDLE_PASSIVE; 504 } 505 506 static int uvc_has_privileges(struct uvc_fh *handle) 507 { 508 return handle->state == UVC_HANDLE_ACTIVE; 509 } 510 511 /* ------------------------------------------------------------------------ 512 * V4L2 file operations 513 */ 514 515 static int uvc_v4l2_open(struct file *file) 516 { 517 struct uvc_streaming *stream; 518 struct uvc_fh *handle; 519 int ret = 0; 520 521 uvc_trace(UVC_TRACE_CALLS, "uvc_v4l2_open\n"); 522 stream = video_drvdata(file); 523 524 ret = usb_autopm_get_interface(stream->dev->intf); 525 if (ret < 0) 526 return ret; 527 528 /* Create the device handle. */ 529 handle = kzalloc(sizeof(*handle), GFP_KERNEL); 530 if (handle == NULL) { 531 usb_autopm_put_interface(stream->dev->intf); 532 return -ENOMEM; 533 } 534 535 mutex_lock(&stream->dev->lock); 536 if (stream->dev->users == 0) { 537 ret = uvc_status_start(stream->dev, GFP_KERNEL); 538 if (ret < 0) { 539 mutex_unlock(&stream->dev->lock); 540 usb_autopm_put_interface(stream->dev->intf); 541 kfree(handle); 542 return ret; 543 } 544 } 545 546 stream->dev->users++; 547 mutex_unlock(&stream->dev->lock); 548 549 v4l2_fh_init(&handle->vfh, &stream->vdev); 550 v4l2_fh_add(&handle->vfh); 551 handle->chain = stream->chain; 552 handle->stream = stream; 553 handle->state = UVC_HANDLE_PASSIVE; 554 file->private_data = handle; 555 556 return 0; 557 } 558 559 static int uvc_v4l2_release(struct file *file) 560 { 561 struct uvc_fh *handle = file->private_data; 562 struct uvc_streaming *stream = handle->stream; 563 564 uvc_trace(UVC_TRACE_CALLS, "uvc_v4l2_release\n"); 565 566 /* Only free resources if this is a privileged handle. */ 567 if (uvc_has_privileges(handle)) 568 uvc_queue_release(&stream->queue); 569 570 /* Release the file handle. */ 571 uvc_dismiss_privileges(handle); 572 v4l2_fh_del(&handle->vfh); 573 v4l2_fh_exit(&handle->vfh); 574 kfree(handle); 575 file->private_data = NULL; 576 577 mutex_lock(&stream->dev->lock); 578 if (--stream->dev->users == 0) 579 uvc_status_stop(stream->dev); 580 mutex_unlock(&stream->dev->lock); 581 582 usb_autopm_put_interface(stream->dev->intf); 583 return 0; 584 } 585 586 static int uvc_ioctl_querycap(struct file *file, void *fh, 587 struct v4l2_capability *cap) 588 { 589 struct video_device *vdev = video_devdata(file); 590 struct uvc_fh *handle = file->private_data; 591 struct uvc_video_chain *chain = handle->chain; 592 struct uvc_streaming *stream = handle->stream; 593 594 strscpy(cap->driver, "uvcvideo", sizeof(cap->driver)); 595 strscpy(cap->card, vdev->name, sizeof(cap->card)); 596 usb_make_path(stream->dev->udev, cap->bus_info, sizeof(cap->bus_info)); 597 cap->capabilities = V4L2_CAP_DEVICE_CAPS | V4L2_CAP_STREAMING 598 | chain->caps; 599 600 return 0; 601 } 602 603 static int uvc_ioctl_enum_fmt(struct uvc_streaming *stream, 604 struct v4l2_fmtdesc *fmt) 605 { 606 struct uvc_format *format; 607 enum v4l2_buf_type type = fmt->type; 608 u32 index = fmt->index; 609 610 if (fmt->type != stream->type || fmt->index >= stream->nformats) 611 return -EINVAL; 612 613 memset(fmt, 0, sizeof(*fmt)); 614 fmt->index = index; 615 fmt->type = type; 616 617 format = &stream->format[fmt->index]; 618 fmt->flags = 0; 619 if (format->flags & UVC_FMT_FLAG_COMPRESSED) 620 fmt->flags |= V4L2_FMT_FLAG_COMPRESSED; 621 strscpy(fmt->description, format->name, sizeof(fmt->description)); 622 fmt->description[sizeof(fmt->description) - 1] = 0; 623 fmt->pixelformat = format->fcc; 624 return 0; 625 } 626 627 static int uvc_ioctl_enum_fmt_vid_cap(struct file *file, void *fh, 628 struct v4l2_fmtdesc *fmt) 629 { 630 struct uvc_fh *handle = fh; 631 struct uvc_streaming *stream = handle->stream; 632 633 return uvc_ioctl_enum_fmt(stream, fmt); 634 } 635 636 static int uvc_ioctl_enum_fmt_vid_out(struct file *file, void *fh, 637 struct v4l2_fmtdesc *fmt) 638 { 639 struct uvc_fh *handle = fh; 640 struct uvc_streaming *stream = handle->stream; 641 642 return uvc_ioctl_enum_fmt(stream, fmt); 643 } 644 645 static int uvc_ioctl_g_fmt_vid_cap(struct file *file, void *fh, 646 struct v4l2_format *fmt) 647 { 648 struct uvc_fh *handle = fh; 649 struct uvc_streaming *stream = handle->stream; 650 651 return uvc_v4l2_get_format(stream, fmt); 652 } 653 654 static int uvc_ioctl_g_fmt_vid_out(struct file *file, void *fh, 655 struct v4l2_format *fmt) 656 { 657 struct uvc_fh *handle = fh; 658 struct uvc_streaming *stream = handle->stream; 659 660 return uvc_v4l2_get_format(stream, fmt); 661 } 662 663 static int uvc_ioctl_s_fmt_vid_cap(struct file *file, void *fh, 664 struct v4l2_format *fmt) 665 { 666 struct uvc_fh *handle = fh; 667 struct uvc_streaming *stream = handle->stream; 668 int ret; 669 670 ret = uvc_acquire_privileges(handle); 671 if (ret < 0) 672 return ret; 673 674 return uvc_v4l2_set_format(stream, fmt); 675 } 676 677 static int uvc_ioctl_s_fmt_vid_out(struct file *file, void *fh, 678 struct v4l2_format *fmt) 679 { 680 struct uvc_fh *handle = fh; 681 struct uvc_streaming *stream = handle->stream; 682 int ret; 683 684 ret = uvc_acquire_privileges(handle); 685 if (ret < 0) 686 return ret; 687 688 return uvc_v4l2_set_format(stream, fmt); 689 } 690 691 static int uvc_ioctl_try_fmt_vid_cap(struct file *file, void *fh, 692 struct v4l2_format *fmt) 693 { 694 struct uvc_fh *handle = fh; 695 struct uvc_streaming *stream = handle->stream; 696 struct uvc_streaming_control probe; 697 698 return uvc_v4l2_try_format(stream, fmt, &probe, NULL, NULL); 699 } 700 701 static int uvc_ioctl_try_fmt_vid_out(struct file *file, void *fh, 702 struct v4l2_format *fmt) 703 { 704 struct uvc_fh *handle = fh; 705 struct uvc_streaming *stream = handle->stream; 706 struct uvc_streaming_control probe; 707 708 return uvc_v4l2_try_format(stream, fmt, &probe, NULL, NULL); 709 } 710 711 static int uvc_ioctl_reqbufs(struct file *file, void *fh, 712 struct v4l2_requestbuffers *rb) 713 { 714 struct uvc_fh *handle = fh; 715 struct uvc_streaming *stream = handle->stream; 716 int ret; 717 718 ret = uvc_acquire_privileges(handle); 719 if (ret < 0) 720 return ret; 721 722 mutex_lock(&stream->mutex); 723 ret = uvc_request_buffers(&stream->queue, rb); 724 mutex_unlock(&stream->mutex); 725 if (ret < 0) 726 return ret; 727 728 if (ret == 0) 729 uvc_dismiss_privileges(handle); 730 731 return 0; 732 } 733 734 static int uvc_ioctl_querybuf(struct file *file, void *fh, 735 struct v4l2_buffer *buf) 736 { 737 struct uvc_fh *handle = fh; 738 struct uvc_streaming *stream = handle->stream; 739 740 if (!uvc_has_privileges(handle)) 741 return -EBUSY; 742 743 return uvc_query_buffer(&stream->queue, buf); 744 } 745 746 static int uvc_ioctl_qbuf(struct file *file, void *fh, struct v4l2_buffer *buf) 747 { 748 struct uvc_fh *handle = fh; 749 struct uvc_streaming *stream = handle->stream; 750 751 if (!uvc_has_privileges(handle)) 752 return -EBUSY; 753 754 return uvc_queue_buffer(&stream->queue, 755 stream->vdev.v4l2_dev->mdev, buf); 756 } 757 758 static int uvc_ioctl_expbuf(struct file *file, void *fh, 759 struct v4l2_exportbuffer *exp) 760 { 761 struct uvc_fh *handle = fh; 762 struct uvc_streaming *stream = handle->stream; 763 764 if (!uvc_has_privileges(handle)) 765 return -EBUSY; 766 767 return uvc_export_buffer(&stream->queue, exp); 768 } 769 770 static int uvc_ioctl_dqbuf(struct file *file, void *fh, struct v4l2_buffer *buf) 771 { 772 struct uvc_fh *handle = fh; 773 struct uvc_streaming *stream = handle->stream; 774 775 if (!uvc_has_privileges(handle)) 776 return -EBUSY; 777 778 return uvc_dequeue_buffer(&stream->queue, buf, 779 file->f_flags & O_NONBLOCK); 780 } 781 782 static int uvc_ioctl_create_bufs(struct file *file, void *fh, 783 struct v4l2_create_buffers *cb) 784 { 785 struct uvc_fh *handle = fh; 786 struct uvc_streaming *stream = handle->stream; 787 int ret; 788 789 ret = uvc_acquire_privileges(handle); 790 if (ret < 0) 791 return ret; 792 793 return uvc_create_buffers(&stream->queue, cb); 794 } 795 796 static int uvc_ioctl_streamon(struct file *file, void *fh, 797 enum v4l2_buf_type type) 798 { 799 struct uvc_fh *handle = fh; 800 struct uvc_streaming *stream = handle->stream; 801 int ret; 802 803 if (!uvc_has_privileges(handle)) 804 return -EBUSY; 805 806 mutex_lock(&stream->mutex); 807 ret = uvc_queue_streamon(&stream->queue, type); 808 mutex_unlock(&stream->mutex); 809 810 return ret; 811 } 812 813 static int uvc_ioctl_streamoff(struct file *file, void *fh, 814 enum v4l2_buf_type type) 815 { 816 struct uvc_fh *handle = fh; 817 struct uvc_streaming *stream = handle->stream; 818 819 if (!uvc_has_privileges(handle)) 820 return -EBUSY; 821 822 mutex_lock(&stream->mutex); 823 uvc_queue_streamoff(&stream->queue, type); 824 mutex_unlock(&stream->mutex); 825 826 return 0; 827 } 828 829 static int uvc_ioctl_enum_input(struct file *file, void *fh, 830 struct v4l2_input *input) 831 { 832 struct uvc_fh *handle = fh; 833 struct uvc_video_chain *chain = handle->chain; 834 const struct uvc_entity *selector = chain->selector; 835 struct uvc_entity *iterm = NULL; 836 u32 index = input->index; 837 int pin = 0; 838 839 if (selector == NULL || 840 (chain->dev->quirks & UVC_QUIRK_IGNORE_SELECTOR_UNIT)) { 841 if (index != 0) 842 return -EINVAL; 843 list_for_each_entry(iterm, &chain->entities, chain) { 844 if (UVC_ENTITY_IS_ITERM(iterm)) 845 break; 846 } 847 pin = iterm->id; 848 } else if (index < selector->bNrInPins) { 849 pin = selector->baSourceID[index]; 850 list_for_each_entry(iterm, &chain->entities, chain) { 851 if (!UVC_ENTITY_IS_ITERM(iterm)) 852 continue; 853 if (iterm->id == pin) 854 break; 855 } 856 } 857 858 if (iterm == NULL || iterm->id != pin) 859 return -EINVAL; 860 861 memset(input, 0, sizeof(*input)); 862 input->index = index; 863 strscpy(input->name, iterm->name, sizeof(input->name)); 864 if (UVC_ENTITY_TYPE(iterm) == UVC_ITT_CAMERA) 865 input->type = V4L2_INPUT_TYPE_CAMERA; 866 867 return 0; 868 } 869 870 static int uvc_ioctl_g_input(struct file *file, void *fh, unsigned int *input) 871 { 872 struct uvc_fh *handle = fh; 873 struct uvc_video_chain *chain = handle->chain; 874 int ret; 875 u8 i; 876 877 if (chain->selector == NULL || 878 (chain->dev->quirks & UVC_QUIRK_IGNORE_SELECTOR_UNIT)) { 879 *input = 0; 880 return 0; 881 } 882 883 ret = uvc_query_ctrl(chain->dev, UVC_GET_CUR, chain->selector->id, 884 chain->dev->intfnum, UVC_SU_INPUT_SELECT_CONTROL, 885 &i, 1); 886 if (ret < 0) 887 return ret; 888 889 *input = i - 1; 890 return 0; 891 } 892 893 static int uvc_ioctl_s_input(struct file *file, void *fh, unsigned int input) 894 { 895 struct uvc_fh *handle = fh; 896 struct uvc_video_chain *chain = handle->chain; 897 int ret; 898 u32 i; 899 900 ret = uvc_acquire_privileges(handle); 901 if (ret < 0) 902 return ret; 903 904 if (chain->selector == NULL || 905 (chain->dev->quirks & UVC_QUIRK_IGNORE_SELECTOR_UNIT)) { 906 if (input) 907 return -EINVAL; 908 return 0; 909 } 910 911 if (input >= chain->selector->bNrInPins) 912 return -EINVAL; 913 914 i = input + 1; 915 return uvc_query_ctrl(chain->dev, UVC_SET_CUR, chain->selector->id, 916 chain->dev->intfnum, UVC_SU_INPUT_SELECT_CONTROL, 917 &i, 1); 918 } 919 920 static int uvc_ioctl_queryctrl(struct file *file, void *fh, 921 struct v4l2_queryctrl *qc) 922 { 923 struct uvc_fh *handle = fh; 924 struct uvc_video_chain *chain = handle->chain; 925 926 return uvc_query_v4l2_ctrl(chain, qc); 927 } 928 929 static int uvc_ioctl_query_ext_ctrl(struct file *file, void *fh, 930 struct v4l2_query_ext_ctrl *qec) 931 { 932 struct uvc_fh *handle = fh; 933 struct uvc_video_chain *chain = handle->chain; 934 struct v4l2_queryctrl qc = { qec->id }; 935 int ret; 936 937 ret = uvc_query_v4l2_ctrl(chain, &qc); 938 if (ret) 939 return ret; 940 941 qec->id = qc.id; 942 qec->type = qc.type; 943 strscpy(qec->name, qc.name, sizeof(qec->name)); 944 qec->minimum = qc.minimum; 945 qec->maximum = qc.maximum; 946 qec->step = qc.step; 947 qec->default_value = qc.default_value; 948 qec->flags = qc.flags; 949 qec->elem_size = 4; 950 qec->elems = 1; 951 qec->nr_of_dims = 0; 952 memset(qec->dims, 0, sizeof(qec->dims)); 953 memset(qec->reserved, 0, sizeof(qec->reserved)); 954 955 return 0; 956 } 957 958 static int uvc_ioctl_g_ctrl(struct file *file, void *fh, 959 struct v4l2_control *ctrl) 960 { 961 struct uvc_fh *handle = fh; 962 struct uvc_video_chain *chain = handle->chain; 963 struct v4l2_ext_control xctrl; 964 int ret; 965 966 memset(&xctrl, 0, sizeof(xctrl)); 967 xctrl.id = ctrl->id; 968 969 ret = uvc_ctrl_begin(chain); 970 if (ret < 0) 971 return ret; 972 973 ret = uvc_ctrl_get(chain, &xctrl); 974 uvc_ctrl_rollback(handle); 975 if (ret < 0) 976 return ret; 977 978 ctrl->value = xctrl.value; 979 return 0; 980 } 981 982 static int uvc_ioctl_s_ctrl(struct file *file, void *fh, 983 struct v4l2_control *ctrl) 984 { 985 struct uvc_fh *handle = fh; 986 struct uvc_video_chain *chain = handle->chain; 987 struct v4l2_ext_control xctrl; 988 int ret; 989 990 memset(&xctrl, 0, sizeof(xctrl)); 991 xctrl.id = ctrl->id; 992 xctrl.value = ctrl->value; 993 994 ret = uvc_ctrl_begin(chain); 995 if (ret < 0) 996 return ret; 997 998 ret = uvc_ctrl_set(handle, &xctrl); 999 if (ret < 0) { 1000 uvc_ctrl_rollback(handle); 1001 return ret; 1002 } 1003 1004 ret = uvc_ctrl_commit(handle, &xctrl, 1); 1005 if (ret < 0) 1006 return ret; 1007 1008 ctrl->value = xctrl.value; 1009 return 0; 1010 } 1011 1012 static int uvc_ioctl_g_ext_ctrls(struct file *file, void *fh, 1013 struct v4l2_ext_controls *ctrls) 1014 { 1015 struct uvc_fh *handle = fh; 1016 struct uvc_video_chain *chain = handle->chain; 1017 struct v4l2_ext_control *ctrl = ctrls->controls; 1018 unsigned int i; 1019 int ret; 1020 1021 if (ctrls->which == V4L2_CTRL_WHICH_DEF_VAL) { 1022 for (i = 0; i < ctrls->count; ++ctrl, ++i) { 1023 struct v4l2_queryctrl qc = { .id = ctrl->id }; 1024 1025 ret = uvc_query_v4l2_ctrl(chain, &qc); 1026 if (ret < 0) { 1027 ctrls->error_idx = i; 1028 return ret; 1029 } 1030 1031 ctrl->value = qc.default_value; 1032 } 1033 1034 return 0; 1035 } 1036 1037 ret = uvc_ctrl_begin(chain); 1038 if (ret < 0) 1039 return ret; 1040 1041 for (i = 0; i < ctrls->count; ++ctrl, ++i) { 1042 ret = uvc_ctrl_get(chain, ctrl); 1043 if (ret < 0) { 1044 uvc_ctrl_rollback(handle); 1045 ctrls->error_idx = i; 1046 return ret; 1047 } 1048 } 1049 1050 ctrls->error_idx = 0; 1051 1052 return uvc_ctrl_rollback(handle); 1053 } 1054 1055 static int uvc_ioctl_s_try_ext_ctrls(struct uvc_fh *handle, 1056 struct v4l2_ext_controls *ctrls, 1057 bool commit) 1058 { 1059 struct v4l2_ext_control *ctrl = ctrls->controls; 1060 struct uvc_video_chain *chain = handle->chain; 1061 unsigned int i; 1062 int ret; 1063 1064 /* Default value cannot be changed */ 1065 if (ctrls->which == V4L2_CTRL_WHICH_DEF_VAL) 1066 return -EINVAL; 1067 1068 ret = uvc_ctrl_begin(chain); 1069 if (ret < 0) 1070 return ret; 1071 1072 for (i = 0; i < ctrls->count; ++ctrl, ++i) { 1073 ret = uvc_ctrl_set(handle, ctrl); 1074 if (ret < 0) { 1075 uvc_ctrl_rollback(handle); 1076 ctrls->error_idx = commit ? ctrls->count : i; 1077 return ret; 1078 } 1079 } 1080 1081 ctrls->error_idx = 0; 1082 1083 if (commit) 1084 return uvc_ctrl_commit(handle, ctrls->controls, ctrls->count); 1085 else 1086 return uvc_ctrl_rollback(handle); 1087 } 1088 1089 static int uvc_ioctl_s_ext_ctrls(struct file *file, void *fh, 1090 struct v4l2_ext_controls *ctrls) 1091 { 1092 struct uvc_fh *handle = fh; 1093 1094 return uvc_ioctl_s_try_ext_ctrls(handle, ctrls, true); 1095 } 1096 1097 static int uvc_ioctl_try_ext_ctrls(struct file *file, void *fh, 1098 struct v4l2_ext_controls *ctrls) 1099 { 1100 struct uvc_fh *handle = fh; 1101 1102 return uvc_ioctl_s_try_ext_ctrls(handle, ctrls, false); 1103 } 1104 1105 static int uvc_ioctl_querymenu(struct file *file, void *fh, 1106 struct v4l2_querymenu *qm) 1107 { 1108 struct uvc_fh *handle = fh; 1109 struct uvc_video_chain *chain = handle->chain; 1110 1111 return uvc_query_v4l2_menu(chain, qm); 1112 } 1113 1114 static int uvc_ioctl_g_selection(struct file *file, void *fh, 1115 struct v4l2_selection *sel) 1116 { 1117 struct uvc_fh *handle = fh; 1118 struct uvc_streaming *stream = handle->stream; 1119 1120 if (sel->type != stream->type) 1121 return -EINVAL; 1122 1123 switch (sel->target) { 1124 case V4L2_SEL_TGT_CROP_DEFAULT: 1125 case V4L2_SEL_TGT_CROP_BOUNDS: 1126 if (stream->type != V4L2_BUF_TYPE_VIDEO_CAPTURE) 1127 return -EINVAL; 1128 break; 1129 case V4L2_SEL_TGT_COMPOSE_DEFAULT: 1130 case V4L2_SEL_TGT_COMPOSE_BOUNDS: 1131 if (stream->type != V4L2_BUF_TYPE_VIDEO_OUTPUT) 1132 return -EINVAL; 1133 break; 1134 default: 1135 return -EINVAL; 1136 } 1137 1138 sel->r.left = 0; 1139 sel->r.top = 0; 1140 mutex_lock(&stream->mutex); 1141 sel->r.width = stream->cur_frame->wWidth; 1142 sel->r.height = stream->cur_frame->wHeight; 1143 mutex_unlock(&stream->mutex); 1144 1145 return 0; 1146 } 1147 1148 static int uvc_ioctl_g_parm(struct file *file, void *fh, 1149 struct v4l2_streamparm *parm) 1150 { 1151 struct uvc_fh *handle = fh; 1152 struct uvc_streaming *stream = handle->stream; 1153 1154 return uvc_v4l2_get_streamparm(stream, parm); 1155 } 1156 1157 static int uvc_ioctl_s_parm(struct file *file, void *fh, 1158 struct v4l2_streamparm *parm) 1159 { 1160 struct uvc_fh *handle = fh; 1161 struct uvc_streaming *stream = handle->stream; 1162 int ret; 1163 1164 ret = uvc_acquire_privileges(handle); 1165 if (ret < 0) 1166 return ret; 1167 1168 return uvc_v4l2_set_streamparm(stream, parm); 1169 } 1170 1171 static int uvc_ioctl_enum_framesizes(struct file *file, void *fh, 1172 struct v4l2_frmsizeenum *fsize) 1173 { 1174 struct uvc_fh *handle = fh; 1175 struct uvc_streaming *stream = handle->stream; 1176 struct uvc_format *format = NULL; 1177 struct uvc_frame *frame = NULL; 1178 unsigned int index; 1179 unsigned int i; 1180 1181 /* Look for the given pixel format */ 1182 for (i = 0; i < stream->nformats; i++) { 1183 if (stream->format[i].fcc == fsize->pixel_format) { 1184 format = &stream->format[i]; 1185 break; 1186 } 1187 } 1188 if (format == NULL) 1189 return -EINVAL; 1190 1191 /* Skip duplicate frame sizes */ 1192 for (i = 0, index = 0; i < format->nframes; i++) { 1193 if (frame && frame->wWidth == format->frame[i].wWidth && 1194 frame->wHeight == format->frame[i].wHeight) 1195 continue; 1196 frame = &format->frame[i]; 1197 if (index == fsize->index) 1198 break; 1199 index++; 1200 } 1201 1202 if (i == format->nframes) 1203 return -EINVAL; 1204 1205 fsize->type = V4L2_FRMSIZE_TYPE_DISCRETE; 1206 fsize->discrete.width = frame->wWidth; 1207 fsize->discrete.height = frame->wHeight; 1208 return 0; 1209 } 1210 1211 static int uvc_ioctl_enum_frameintervals(struct file *file, void *fh, 1212 struct v4l2_frmivalenum *fival) 1213 { 1214 struct uvc_fh *handle = fh; 1215 struct uvc_streaming *stream = handle->stream; 1216 struct uvc_format *format = NULL; 1217 struct uvc_frame *frame = NULL; 1218 unsigned int nintervals; 1219 unsigned int index; 1220 unsigned int i; 1221 1222 /* Look for the given pixel format and frame size */ 1223 for (i = 0; i < stream->nformats; i++) { 1224 if (stream->format[i].fcc == fival->pixel_format) { 1225 format = &stream->format[i]; 1226 break; 1227 } 1228 } 1229 if (format == NULL) 1230 return -EINVAL; 1231 1232 index = fival->index; 1233 for (i = 0; i < format->nframes; i++) { 1234 if (format->frame[i].wWidth == fival->width && 1235 format->frame[i].wHeight == fival->height) { 1236 frame = &format->frame[i]; 1237 nintervals = frame->bFrameIntervalType ?: 1; 1238 if (index < nintervals) 1239 break; 1240 index -= nintervals; 1241 } 1242 } 1243 if (i == format->nframes) 1244 return -EINVAL; 1245 1246 if (frame->bFrameIntervalType) { 1247 fival->type = V4L2_FRMIVAL_TYPE_DISCRETE; 1248 fival->discrete.numerator = 1249 frame->dwFrameInterval[index]; 1250 fival->discrete.denominator = 10000000; 1251 uvc_simplify_fraction(&fival->discrete.numerator, 1252 &fival->discrete.denominator, 8, 333); 1253 } else { 1254 fival->type = V4L2_FRMIVAL_TYPE_STEPWISE; 1255 fival->stepwise.min.numerator = frame->dwFrameInterval[0]; 1256 fival->stepwise.min.denominator = 10000000; 1257 fival->stepwise.max.numerator = frame->dwFrameInterval[1]; 1258 fival->stepwise.max.denominator = 10000000; 1259 fival->stepwise.step.numerator = frame->dwFrameInterval[2]; 1260 fival->stepwise.step.denominator = 10000000; 1261 uvc_simplify_fraction(&fival->stepwise.min.numerator, 1262 &fival->stepwise.min.denominator, 8, 333); 1263 uvc_simplify_fraction(&fival->stepwise.max.numerator, 1264 &fival->stepwise.max.denominator, 8, 333); 1265 uvc_simplify_fraction(&fival->stepwise.step.numerator, 1266 &fival->stepwise.step.denominator, 8, 333); 1267 } 1268 1269 return 0; 1270 } 1271 1272 static int uvc_ioctl_subscribe_event(struct v4l2_fh *fh, 1273 const struct v4l2_event_subscription *sub) 1274 { 1275 switch (sub->type) { 1276 case V4L2_EVENT_CTRL: 1277 return v4l2_event_subscribe(fh, sub, 0, &uvc_ctrl_sub_ev_ops); 1278 default: 1279 return -EINVAL; 1280 } 1281 } 1282 1283 static long uvc_ioctl_default(struct file *file, void *fh, bool valid_prio, 1284 unsigned int cmd, void *arg) 1285 { 1286 struct uvc_fh *handle = fh; 1287 struct uvc_video_chain *chain = handle->chain; 1288 1289 switch (cmd) { 1290 /* Dynamic controls. */ 1291 case UVCIOC_CTRL_MAP: 1292 return uvc_ioctl_ctrl_map(chain, arg); 1293 1294 case UVCIOC_CTRL_QUERY: 1295 return uvc_xu_ctrl_query(chain, arg); 1296 1297 default: 1298 return -ENOTTY; 1299 } 1300 } 1301 1302 #ifdef CONFIG_COMPAT 1303 struct uvc_xu_control_mapping32 { 1304 u32 id; 1305 u8 name[32]; 1306 u8 entity[16]; 1307 u8 selector; 1308 1309 u8 size; 1310 u8 offset; 1311 u32 v4l2_type; 1312 u32 data_type; 1313 1314 compat_caddr_t menu_info; 1315 u32 menu_count; 1316 1317 u32 reserved[4]; 1318 }; 1319 1320 static int uvc_v4l2_get_xu_mapping(struct uvc_xu_control_mapping *kp, 1321 const struct uvc_xu_control_mapping32 __user *up) 1322 { 1323 struct uvc_xu_control_mapping32 *p = (void *)kp; 1324 compat_caddr_t info; 1325 u32 count; 1326 1327 if (copy_from_user(p, up, sizeof(*p))) 1328 return -EFAULT; 1329 1330 count = p->menu_count; 1331 info = p->menu_info; 1332 1333 memset(kp->reserved, 0, sizeof(kp->reserved)); 1334 kp->menu_info = count ? compat_ptr(info) : NULL; 1335 kp->menu_count = count; 1336 return 0; 1337 } 1338 1339 static int uvc_v4l2_put_xu_mapping(const struct uvc_xu_control_mapping *kp, 1340 struct uvc_xu_control_mapping32 __user *up) 1341 { 1342 if (copy_to_user(up, kp, offsetof(typeof(*up), menu_info)) || 1343 put_user(kp->menu_count, &up->menu_count)) 1344 return -EFAULT; 1345 1346 if (clear_user(up->reserved, sizeof(up->reserved))) 1347 return -EFAULT; 1348 1349 return 0; 1350 } 1351 1352 struct uvc_xu_control_query32 { 1353 u8 unit; 1354 u8 selector; 1355 u8 query; 1356 u16 size; 1357 compat_caddr_t data; 1358 }; 1359 1360 static int uvc_v4l2_get_xu_query(struct uvc_xu_control_query *kp, 1361 const struct uvc_xu_control_query32 __user *up) 1362 { 1363 struct uvc_xu_control_query32 v; 1364 1365 if (copy_from_user(&v, up, sizeof(v))) 1366 return -EFAULT; 1367 1368 *kp = (struct uvc_xu_control_query){ 1369 .unit = v.unit, 1370 .selector = v.selector, 1371 .query = v.query, 1372 .size = v.size, 1373 .data = v.size ? compat_ptr(v.data) : NULL 1374 }; 1375 return 0; 1376 } 1377 1378 static int uvc_v4l2_put_xu_query(const struct uvc_xu_control_query *kp, 1379 struct uvc_xu_control_query32 __user *up) 1380 { 1381 if (copy_to_user(up, kp, offsetof(typeof(*up), data))) 1382 return -EFAULT; 1383 return 0; 1384 } 1385 1386 #define UVCIOC_CTRL_MAP32 _IOWR('u', 0x20, struct uvc_xu_control_mapping32) 1387 #define UVCIOC_CTRL_QUERY32 _IOWR('u', 0x21, struct uvc_xu_control_query32) 1388 1389 static long uvc_v4l2_compat_ioctl32(struct file *file, 1390 unsigned int cmd, unsigned long arg) 1391 { 1392 struct uvc_fh *handle = file->private_data; 1393 union { 1394 struct uvc_xu_control_mapping xmap; 1395 struct uvc_xu_control_query xqry; 1396 } karg; 1397 void __user *up = compat_ptr(arg); 1398 long ret; 1399 1400 switch (cmd) { 1401 case UVCIOC_CTRL_MAP32: 1402 ret = uvc_v4l2_get_xu_mapping(&karg.xmap, up); 1403 if (ret) 1404 return ret; 1405 ret = uvc_ioctl_ctrl_map(handle->chain, &karg.xmap); 1406 if (ret) 1407 return ret; 1408 ret = uvc_v4l2_put_xu_mapping(&karg.xmap, up); 1409 if (ret) 1410 return ret; 1411 1412 break; 1413 1414 case UVCIOC_CTRL_QUERY32: 1415 ret = uvc_v4l2_get_xu_query(&karg.xqry, up); 1416 if (ret) 1417 return ret; 1418 ret = uvc_xu_ctrl_query(handle->chain, &karg.xqry); 1419 if (ret) 1420 return ret; 1421 ret = uvc_v4l2_put_xu_query(&karg.xqry, up); 1422 if (ret) 1423 return ret; 1424 break; 1425 1426 default: 1427 return -ENOIOCTLCMD; 1428 } 1429 1430 return ret; 1431 } 1432 #endif 1433 1434 static ssize_t uvc_v4l2_read(struct file *file, char __user *data, 1435 size_t count, loff_t *ppos) 1436 { 1437 uvc_trace(UVC_TRACE_CALLS, "uvc_v4l2_read: not implemented.\n"); 1438 return -EINVAL; 1439 } 1440 1441 static int uvc_v4l2_mmap(struct file *file, struct vm_area_struct *vma) 1442 { 1443 struct uvc_fh *handle = file->private_data; 1444 struct uvc_streaming *stream = handle->stream; 1445 1446 uvc_trace(UVC_TRACE_CALLS, "uvc_v4l2_mmap\n"); 1447 1448 return uvc_queue_mmap(&stream->queue, vma); 1449 } 1450 1451 static __poll_t uvc_v4l2_poll(struct file *file, poll_table *wait) 1452 { 1453 struct uvc_fh *handle = file->private_data; 1454 struct uvc_streaming *stream = handle->stream; 1455 1456 uvc_trace(UVC_TRACE_CALLS, "uvc_v4l2_poll\n"); 1457 1458 return uvc_queue_poll(&stream->queue, file, wait); 1459 } 1460 1461 #ifndef CONFIG_MMU 1462 static unsigned long uvc_v4l2_get_unmapped_area(struct file *file, 1463 unsigned long addr, unsigned long len, unsigned long pgoff, 1464 unsigned long flags) 1465 { 1466 struct uvc_fh *handle = file->private_data; 1467 struct uvc_streaming *stream = handle->stream; 1468 1469 uvc_trace(UVC_TRACE_CALLS, "uvc_v4l2_get_unmapped_area\n"); 1470 1471 return uvc_queue_get_unmapped_area(&stream->queue, pgoff); 1472 } 1473 #endif 1474 1475 const struct v4l2_ioctl_ops uvc_ioctl_ops = { 1476 .vidioc_querycap = uvc_ioctl_querycap, 1477 .vidioc_enum_fmt_vid_cap = uvc_ioctl_enum_fmt_vid_cap, 1478 .vidioc_enum_fmt_vid_out = uvc_ioctl_enum_fmt_vid_out, 1479 .vidioc_g_fmt_vid_cap = uvc_ioctl_g_fmt_vid_cap, 1480 .vidioc_g_fmt_vid_out = uvc_ioctl_g_fmt_vid_out, 1481 .vidioc_s_fmt_vid_cap = uvc_ioctl_s_fmt_vid_cap, 1482 .vidioc_s_fmt_vid_out = uvc_ioctl_s_fmt_vid_out, 1483 .vidioc_try_fmt_vid_cap = uvc_ioctl_try_fmt_vid_cap, 1484 .vidioc_try_fmt_vid_out = uvc_ioctl_try_fmt_vid_out, 1485 .vidioc_reqbufs = uvc_ioctl_reqbufs, 1486 .vidioc_querybuf = uvc_ioctl_querybuf, 1487 .vidioc_qbuf = uvc_ioctl_qbuf, 1488 .vidioc_expbuf = uvc_ioctl_expbuf, 1489 .vidioc_dqbuf = uvc_ioctl_dqbuf, 1490 .vidioc_create_bufs = uvc_ioctl_create_bufs, 1491 .vidioc_streamon = uvc_ioctl_streamon, 1492 .vidioc_streamoff = uvc_ioctl_streamoff, 1493 .vidioc_enum_input = uvc_ioctl_enum_input, 1494 .vidioc_g_input = uvc_ioctl_g_input, 1495 .vidioc_s_input = uvc_ioctl_s_input, 1496 .vidioc_queryctrl = uvc_ioctl_queryctrl, 1497 .vidioc_query_ext_ctrl = uvc_ioctl_query_ext_ctrl, 1498 .vidioc_g_ctrl = uvc_ioctl_g_ctrl, 1499 .vidioc_s_ctrl = uvc_ioctl_s_ctrl, 1500 .vidioc_g_ext_ctrls = uvc_ioctl_g_ext_ctrls, 1501 .vidioc_s_ext_ctrls = uvc_ioctl_s_ext_ctrls, 1502 .vidioc_try_ext_ctrls = uvc_ioctl_try_ext_ctrls, 1503 .vidioc_querymenu = uvc_ioctl_querymenu, 1504 .vidioc_g_selection = uvc_ioctl_g_selection, 1505 .vidioc_g_parm = uvc_ioctl_g_parm, 1506 .vidioc_s_parm = uvc_ioctl_s_parm, 1507 .vidioc_enum_framesizes = uvc_ioctl_enum_framesizes, 1508 .vidioc_enum_frameintervals = uvc_ioctl_enum_frameintervals, 1509 .vidioc_subscribe_event = uvc_ioctl_subscribe_event, 1510 .vidioc_unsubscribe_event = v4l2_event_unsubscribe, 1511 .vidioc_default = uvc_ioctl_default, 1512 }; 1513 1514 const struct v4l2_file_operations uvc_fops = { 1515 .owner = THIS_MODULE, 1516 .open = uvc_v4l2_open, 1517 .release = uvc_v4l2_release, 1518 .unlocked_ioctl = video_ioctl2, 1519 #ifdef CONFIG_COMPAT 1520 .compat_ioctl32 = uvc_v4l2_compat_ioctl32, 1521 #endif 1522 .read = uvc_v4l2_read, 1523 .mmap = uvc_v4l2_mmap, 1524 .poll = uvc_v4l2_poll, 1525 #ifndef CONFIG_MMU 1526 .get_unmapped_area = uvc_v4l2_get_unmapped_area, 1527 #endif 1528 }; 1529 1530