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