2 * uvc_v4l2.c -- USB Video Class driver - V4L2 API
4 * Copyright (C) 2005-2010
5 * Laurent Pinchart (laurent.pinchart@ideasonboard.com)
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.
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>
23 #include <linux/wait.h>
24 #include <linux/atomic.h>
26 #include <media/v4l2-common.h>
27 #include <media/v4l2-ctrls.h>
28 #include <media/v4l2-event.h>
29 #include <media/v4l2-ioctl.h>
33 /* ------------------------------------------------------------------------
36 static int uvc_ioctl_ctrl_map(struct uvc_video_chain
*chain
,
37 struct uvc_xu_control_mapping
*xmap
)
39 struct uvc_control_mapping
*map
;
43 map
= kzalloc(sizeof *map
, GFP_KERNEL
);
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
;
56 switch (xmap
->v4l2_type
) {
57 case V4L2_CTRL_TYPE_INTEGER
:
58 case V4L2_CTRL_TYPE_BOOLEAN
:
59 case V4L2_CTRL_TYPE_BUTTON
:
62 case V4L2_CTRL_TYPE_MENU
:
63 /* Prevent excessive memory consumption, as well as integer
66 if (xmap
->menu_count
== 0 ||
67 xmap
->menu_count
> UVC_MAX_CONTROL_MENU_ENTRIES
) {
72 size
= xmap
->menu_count
* sizeof(*map
->menu_info
);
73 map
->menu_info
= kmalloc(size
, GFP_KERNEL
);
74 if (map
->menu_info
== NULL
) {
79 if (copy_from_user(map
->menu_info
, xmap
->menu_info
, size
)) {
84 map
->menu_count
= xmap
->menu_count
;
88 uvc_trace(UVC_TRACE_CONTROL
, "Unsupported V4L2 control type "
89 "%u.\n", xmap
->v4l2_type
);
94 ret
= uvc_ctrl_add_mapping(chain
, map
);
97 kfree(map
->menu_info
);
103 /* ------------------------------------------------------------------------
108 * Find the frame interval closest to the requested frame interval for the
109 * given frame format and size. This should be done by the device as part of
110 * the Video Probe and Commit negotiation, but some hardware don't implement
113 static __u32
uvc_try_frame_interval(struct uvc_frame
*frame
, __u32 interval
)
117 if (frame
->bFrameIntervalType
) {
118 __u32 best
= -1, dist
;
120 for (i
= 0; i
< frame
->bFrameIntervalType
; ++i
) {
121 dist
= interval
> frame
->dwFrameInterval
[i
]
122 ? interval
- frame
->dwFrameInterval
[i
]
123 : frame
->dwFrameInterval
[i
] - interval
;
131 interval
= frame
->dwFrameInterval
[i
-1];
133 const __u32 min
= frame
->dwFrameInterval
[0];
134 const __u32 max
= frame
->dwFrameInterval
[1];
135 const __u32 step
= frame
->dwFrameInterval
[2];
137 interval
= min
+ (interval
- min
+ step
/2) / step
* step
;
145 static int uvc_v4l2_try_format(struct uvc_streaming
*stream
,
146 struct v4l2_format
*fmt
, struct uvc_streaming_control
*probe
,
147 struct uvc_format
**uvc_format
, struct uvc_frame
**uvc_frame
)
149 struct uvc_format
*format
= NULL
;
150 struct uvc_frame
*frame
= NULL
;
152 unsigned int d
, maxd
;
158 if (fmt
->type
!= stream
->type
)
161 fcc
= (__u8
*)&fmt
->fmt
.pix
.pixelformat
;
162 uvc_trace(UVC_TRACE_FORMAT
, "Trying format 0x%08x (%c%c%c%c): %ux%u.\n",
163 fmt
->fmt
.pix
.pixelformat
,
164 fcc
[0], fcc
[1], fcc
[2], fcc
[3],
165 fmt
->fmt
.pix
.width
, fmt
->fmt
.pix
.height
);
167 /* Check if the hardware supports the requested format, use the default
170 for (i
= 0; i
< stream
->nformats
; ++i
) {
171 format
= &stream
->format
[i
];
172 if (format
->fcc
== fmt
->fmt
.pix
.pixelformat
)
176 if (i
== stream
->nformats
) {
177 format
= stream
->def_format
;
178 fmt
->fmt
.pix
.pixelformat
= format
->fcc
;
181 /* Find the closest image size. The distance between image sizes is
182 * the size in pixels of the non-overlapping regions between the
183 * requested size and the frame-specified size.
185 rw
= fmt
->fmt
.pix
.width
;
186 rh
= fmt
->fmt
.pix
.height
;
187 maxd
= (unsigned int)-1;
189 for (i
= 0; i
< format
->nframes
; ++i
) {
190 __u16 w
= format
->frame
[i
].wWidth
;
191 __u16 h
= format
->frame
[i
].wHeight
;
193 d
= min(w
, rw
) * min(h
, rh
);
194 d
= w
*h
+ rw
*rh
- 2*d
;
197 frame
= &format
->frame
[i
];
205 uvc_trace(UVC_TRACE_FORMAT
, "Unsupported size %ux%u.\n",
206 fmt
->fmt
.pix
.width
, fmt
->fmt
.pix
.height
);
210 /* Use the default frame interval. */
211 interval
= frame
->dwDefaultFrameInterval
;
212 uvc_trace(UVC_TRACE_FORMAT
, "Using default frame interval %u.%u us "
213 "(%u.%u fps).\n", interval
/10, interval
%10, 10000000/interval
,
214 (100000000/interval
)%10);
216 /* Set the format index, frame index and frame interval. */
217 memset(probe
, 0, sizeof *probe
);
218 probe
->bmHint
= 1; /* dwFrameInterval */
219 probe
->bFormatIndex
= format
->index
;
220 probe
->bFrameIndex
= frame
->bFrameIndex
;
221 probe
->dwFrameInterval
= uvc_try_frame_interval(frame
, interval
);
222 /* Some webcams stall the probe control set request when the
223 * dwMaxVideoFrameSize field is set to zero. The UVC specification
224 * clearly states that the field is read-only from the host, so this
225 * is a webcam bug. Set dwMaxVideoFrameSize to the value reported by
226 * the webcam to work around the problem.
228 * The workaround could probably be enabled for all webcams, so the
229 * quirk can be removed if needed. It's currently useful to detect
230 * webcam bugs and fix them before they hit the market (providing
231 * developers test their webcams with the Linux driver as well as with
232 * the Windows driver).
234 mutex_lock(&stream
->mutex
);
235 if (stream
->dev
->quirks
& UVC_QUIRK_PROBE_EXTRAFIELDS
)
236 probe
->dwMaxVideoFrameSize
=
237 stream
->ctrl
.dwMaxVideoFrameSize
;
239 /* Probe the device. */
240 ret
= uvc_probe_video(stream
, probe
);
241 mutex_unlock(&stream
->mutex
);
245 fmt
->fmt
.pix
.width
= frame
->wWidth
;
246 fmt
->fmt
.pix
.height
= frame
->wHeight
;
247 fmt
->fmt
.pix
.field
= V4L2_FIELD_NONE
;
248 fmt
->fmt
.pix
.bytesperline
= format
->bpp
* frame
->wWidth
/ 8;
249 fmt
->fmt
.pix
.sizeimage
= probe
->dwMaxVideoFrameSize
;
250 fmt
->fmt
.pix
.colorspace
= format
->colorspace
;
251 fmt
->fmt
.pix
.priv
= 0;
253 if (uvc_format
!= NULL
)
254 *uvc_format
= format
;
255 if (uvc_frame
!= NULL
)
262 static int uvc_v4l2_get_format(struct uvc_streaming
*stream
,
263 struct v4l2_format
*fmt
)
265 struct uvc_format
*format
;
266 struct uvc_frame
*frame
;
269 if (fmt
->type
!= stream
->type
)
272 mutex_lock(&stream
->mutex
);
273 format
= stream
->cur_format
;
274 frame
= stream
->cur_frame
;
276 if (format
== NULL
|| frame
== NULL
) {
281 fmt
->fmt
.pix
.pixelformat
= format
->fcc
;
282 fmt
->fmt
.pix
.width
= frame
->wWidth
;
283 fmt
->fmt
.pix
.height
= frame
->wHeight
;
284 fmt
->fmt
.pix
.field
= V4L2_FIELD_NONE
;
285 fmt
->fmt
.pix
.bytesperline
= format
->bpp
* frame
->wWidth
/ 8;
286 fmt
->fmt
.pix
.sizeimage
= stream
->ctrl
.dwMaxVideoFrameSize
;
287 fmt
->fmt
.pix
.colorspace
= format
->colorspace
;
288 fmt
->fmt
.pix
.priv
= 0;
291 mutex_unlock(&stream
->mutex
);
295 static int uvc_v4l2_set_format(struct uvc_streaming
*stream
,
296 struct v4l2_format
*fmt
)
298 struct uvc_streaming_control probe
;
299 struct uvc_format
*format
;
300 struct uvc_frame
*frame
;
303 if (fmt
->type
!= stream
->type
)
306 ret
= uvc_v4l2_try_format(stream
, fmt
, &probe
, &format
, &frame
);
310 mutex_lock(&stream
->mutex
);
312 if (uvc_queue_allocated(&stream
->queue
)) {
317 stream
->ctrl
= probe
;
318 stream
->cur_format
= format
;
319 stream
->cur_frame
= frame
;
322 mutex_unlock(&stream
->mutex
);
326 static int uvc_v4l2_get_streamparm(struct uvc_streaming
*stream
,
327 struct v4l2_streamparm
*parm
)
329 uint32_t numerator
, denominator
;
331 if (parm
->type
!= stream
->type
)
334 mutex_lock(&stream
->mutex
);
335 numerator
= stream
->ctrl
.dwFrameInterval
;
336 mutex_unlock(&stream
->mutex
);
338 denominator
= 10000000;
339 uvc_simplify_fraction(&numerator
, &denominator
, 8, 333);
341 memset(parm
, 0, sizeof *parm
);
342 parm
->type
= stream
->type
;
344 if (stream
->type
== V4L2_BUF_TYPE_VIDEO_CAPTURE
) {
345 parm
->parm
.capture
.capability
= V4L2_CAP_TIMEPERFRAME
;
346 parm
->parm
.capture
.capturemode
= 0;
347 parm
->parm
.capture
.timeperframe
.numerator
= numerator
;
348 parm
->parm
.capture
.timeperframe
.denominator
= denominator
;
349 parm
->parm
.capture
.extendedmode
= 0;
350 parm
->parm
.capture
.readbuffers
= 0;
352 parm
->parm
.output
.capability
= V4L2_CAP_TIMEPERFRAME
;
353 parm
->parm
.output
.outputmode
= 0;
354 parm
->parm
.output
.timeperframe
.numerator
= numerator
;
355 parm
->parm
.output
.timeperframe
.denominator
= denominator
;
361 static int uvc_v4l2_set_streamparm(struct uvc_streaming
*stream
,
362 struct v4l2_streamparm
*parm
)
364 struct uvc_streaming_control probe
;
365 struct v4l2_fract timeperframe
;
369 if (parm
->type
!= stream
->type
)
372 if (parm
->type
== V4L2_BUF_TYPE_VIDEO_CAPTURE
)
373 timeperframe
= parm
->parm
.capture
.timeperframe
;
375 timeperframe
= parm
->parm
.output
.timeperframe
;
377 interval
= uvc_fraction_to_interval(timeperframe
.numerator
,
378 timeperframe
.denominator
);
379 uvc_trace(UVC_TRACE_FORMAT
, "Setting frame interval to %u/%u (%u).\n",
380 timeperframe
.numerator
, timeperframe
.denominator
, interval
);
382 mutex_lock(&stream
->mutex
);
384 if (uvc_queue_streaming(&stream
->queue
)) {
385 mutex_unlock(&stream
->mutex
);
389 probe
= stream
->ctrl
;
390 probe
.dwFrameInterval
=
391 uvc_try_frame_interval(stream
->cur_frame
, interval
);
393 /* Probe the device with the new settings. */
394 ret
= uvc_probe_video(stream
, &probe
);
396 mutex_unlock(&stream
->mutex
);
400 stream
->ctrl
= probe
;
401 mutex_unlock(&stream
->mutex
);
403 /* Return the actual frame period. */
404 timeperframe
.numerator
= probe
.dwFrameInterval
;
405 timeperframe
.denominator
= 10000000;
406 uvc_simplify_fraction(&timeperframe
.numerator
,
407 &timeperframe
.denominator
, 8, 333);
409 if (parm
->type
== V4L2_BUF_TYPE_VIDEO_CAPTURE
)
410 parm
->parm
.capture
.timeperframe
= timeperframe
;
412 parm
->parm
.output
.timeperframe
= timeperframe
;
417 /* ------------------------------------------------------------------------
418 * Privilege management
422 * Privilege management is the multiple-open implementation basis. The current
423 * implementation is completely transparent for the end-user and doesn't
424 * require explicit use of the VIDIOC_G_PRIORITY and VIDIOC_S_PRIORITY ioctls.
425 * Those ioctls enable finer control on the device (by making possible for a
426 * user to request exclusive access to a device), but are not mature yet.
427 * Switching to the V4L2 priority mechanism might be considered in the future
428 * if this situation changes.
430 * Each open instance of a UVC device can either be in a privileged or
431 * unprivileged state. Only a single instance can be in a privileged state at
432 * a given time. Trying to perform an operation that requires privileges will
433 * automatically acquire the required privileges if possible, or return -EBUSY
434 * otherwise. Privileges are dismissed when closing the instance or when
435 * freeing the video buffers using VIDIOC_REQBUFS.
437 * Operations that require privileges are:
444 static int uvc_acquire_privileges(struct uvc_fh
*handle
)
446 /* Always succeed if the handle is already privileged. */
447 if (handle
->state
== UVC_HANDLE_ACTIVE
)
450 /* Check if the device already has a privileged handle. */
451 if (atomic_inc_return(&handle
->stream
->active
) != 1) {
452 atomic_dec(&handle
->stream
->active
);
456 handle
->state
= UVC_HANDLE_ACTIVE
;
460 static void uvc_dismiss_privileges(struct uvc_fh
*handle
)
462 if (handle
->state
== UVC_HANDLE_ACTIVE
)
463 atomic_dec(&handle
->stream
->active
);
465 handle
->state
= UVC_HANDLE_PASSIVE
;
468 static int uvc_has_privileges(struct uvc_fh
*handle
)
470 return handle
->state
== UVC_HANDLE_ACTIVE
;
473 /* ------------------------------------------------------------------------
474 * V4L2 file operations
477 static int uvc_v4l2_open(struct file
*file
)
479 struct uvc_streaming
*stream
;
480 struct uvc_fh
*handle
;
483 uvc_trace(UVC_TRACE_CALLS
, "uvc_v4l2_open\n");
484 stream
= video_drvdata(file
);
486 ret
= usb_autopm_get_interface(stream
->dev
->intf
);
490 /* Create the device handle. */
491 handle
= kzalloc(sizeof *handle
, GFP_KERNEL
);
492 if (handle
== NULL
) {
493 usb_autopm_put_interface(stream
->dev
->intf
);
497 mutex_lock(&stream
->dev
->lock
);
498 if (stream
->dev
->users
== 0) {
499 ret
= uvc_status_start(stream
->dev
, GFP_KERNEL
);
501 mutex_unlock(&stream
->dev
->lock
);
502 usb_autopm_put_interface(stream
->dev
->intf
);
508 stream
->dev
->users
++;
509 mutex_unlock(&stream
->dev
->lock
);
511 v4l2_fh_init(&handle
->vfh
, &stream
->vdev
);
512 v4l2_fh_add(&handle
->vfh
);
513 handle
->chain
= stream
->chain
;
514 handle
->stream
= stream
;
515 handle
->state
= UVC_HANDLE_PASSIVE
;
516 file
->private_data
= handle
;
521 static int uvc_v4l2_release(struct file
*file
)
523 struct uvc_fh
*handle
= file
->private_data
;
524 struct uvc_streaming
*stream
= handle
->stream
;
526 uvc_trace(UVC_TRACE_CALLS
, "uvc_v4l2_release\n");
528 /* Only free resources if this is a privileged handle. */
529 if (uvc_has_privileges(handle
))
530 uvc_queue_release(&stream
->queue
);
532 /* Release the file handle. */
533 uvc_dismiss_privileges(handle
);
534 v4l2_fh_del(&handle
->vfh
);
535 v4l2_fh_exit(&handle
->vfh
);
537 file
->private_data
= NULL
;
539 mutex_lock(&stream
->dev
->lock
);
540 if (--stream
->dev
->users
== 0)
541 uvc_status_stop(stream
->dev
);
542 mutex_unlock(&stream
->dev
->lock
);
544 usb_autopm_put_interface(stream
->dev
->intf
);
548 static int uvc_ioctl_querycap(struct file
*file
, void *fh
,
549 struct v4l2_capability
*cap
)
551 struct video_device
*vdev
= video_devdata(file
);
552 struct uvc_fh
*handle
= file
->private_data
;
553 struct uvc_video_chain
*chain
= handle
->chain
;
554 struct uvc_streaming
*stream
= handle
->stream
;
556 strlcpy(cap
->driver
, "uvcvideo", sizeof(cap
->driver
));
557 strlcpy(cap
->card
, vdev
->name
, sizeof(cap
->card
));
558 usb_make_path(stream
->dev
->udev
, cap
->bus_info
, sizeof(cap
->bus_info
));
559 cap
->capabilities
= V4L2_CAP_DEVICE_CAPS
| V4L2_CAP_STREAMING
561 if (stream
->type
== V4L2_BUF_TYPE_VIDEO_CAPTURE
)
562 cap
->device_caps
= V4L2_CAP_VIDEO_CAPTURE
| V4L2_CAP_STREAMING
;
564 cap
->device_caps
= V4L2_CAP_VIDEO_OUTPUT
| V4L2_CAP_STREAMING
;
569 static int uvc_ioctl_enum_fmt(struct uvc_streaming
*stream
,
570 struct v4l2_fmtdesc
*fmt
)
572 struct uvc_format
*format
;
573 enum v4l2_buf_type type
= fmt
->type
;
574 __u32 index
= fmt
->index
;
576 if (fmt
->type
!= stream
->type
|| fmt
->index
>= stream
->nformats
)
579 memset(fmt
, 0, sizeof(*fmt
));
583 format
= &stream
->format
[fmt
->index
];
585 if (format
->flags
& UVC_FMT_FLAG_COMPRESSED
)
586 fmt
->flags
|= V4L2_FMT_FLAG_COMPRESSED
;
587 strlcpy(fmt
->description
, format
->name
, sizeof(fmt
->description
));
588 fmt
->description
[sizeof(fmt
->description
) - 1] = 0;
589 fmt
->pixelformat
= format
->fcc
;
593 static int uvc_ioctl_enum_fmt_vid_cap(struct file
*file
, void *fh
,
594 struct v4l2_fmtdesc
*fmt
)
596 struct uvc_fh
*handle
= fh
;
597 struct uvc_streaming
*stream
= handle
->stream
;
599 return uvc_ioctl_enum_fmt(stream
, fmt
);
602 static int uvc_ioctl_enum_fmt_vid_out(struct file
*file
, void *fh
,
603 struct v4l2_fmtdesc
*fmt
)
605 struct uvc_fh
*handle
= fh
;
606 struct uvc_streaming
*stream
= handle
->stream
;
608 return uvc_ioctl_enum_fmt(stream
, fmt
);
611 static int uvc_ioctl_g_fmt_vid_cap(struct file
*file
, void *fh
,
612 struct v4l2_format
*fmt
)
614 struct uvc_fh
*handle
= fh
;
615 struct uvc_streaming
*stream
= handle
->stream
;
617 return uvc_v4l2_get_format(stream
, fmt
);
620 static int uvc_ioctl_g_fmt_vid_out(struct file
*file
, void *fh
,
621 struct v4l2_format
*fmt
)
623 struct uvc_fh
*handle
= fh
;
624 struct uvc_streaming
*stream
= handle
->stream
;
626 return uvc_v4l2_get_format(stream
, fmt
);
629 static int uvc_ioctl_s_fmt_vid_cap(struct file
*file
, void *fh
,
630 struct v4l2_format
*fmt
)
632 struct uvc_fh
*handle
= fh
;
633 struct uvc_streaming
*stream
= handle
->stream
;
636 ret
= uvc_acquire_privileges(handle
);
640 return uvc_v4l2_set_format(stream
, fmt
);
643 static int uvc_ioctl_s_fmt_vid_out(struct file
*file
, void *fh
,
644 struct v4l2_format
*fmt
)
646 struct uvc_fh
*handle
= fh
;
647 struct uvc_streaming
*stream
= handle
->stream
;
650 ret
= uvc_acquire_privileges(handle
);
654 return uvc_v4l2_set_format(stream
, fmt
);
657 static int uvc_ioctl_try_fmt_vid_cap(struct file
*file
, void *fh
,
658 struct v4l2_format
*fmt
)
660 struct uvc_fh
*handle
= fh
;
661 struct uvc_streaming
*stream
= handle
->stream
;
662 struct uvc_streaming_control probe
;
664 return uvc_v4l2_try_format(stream
, fmt
, &probe
, NULL
, NULL
);
667 static int uvc_ioctl_try_fmt_vid_out(struct file
*file
, void *fh
,
668 struct v4l2_format
*fmt
)
670 struct uvc_fh
*handle
= fh
;
671 struct uvc_streaming
*stream
= handle
->stream
;
672 struct uvc_streaming_control probe
;
674 return uvc_v4l2_try_format(stream
, fmt
, &probe
, NULL
, NULL
);
677 static int uvc_ioctl_reqbufs(struct file
*file
, void *fh
,
678 struct v4l2_requestbuffers
*rb
)
680 struct uvc_fh
*handle
= fh
;
681 struct uvc_streaming
*stream
= handle
->stream
;
684 ret
= uvc_acquire_privileges(handle
);
688 mutex_lock(&stream
->mutex
);
689 ret
= uvc_request_buffers(&stream
->queue
, rb
);
690 mutex_unlock(&stream
->mutex
);
695 uvc_dismiss_privileges(handle
);
700 static int uvc_ioctl_querybuf(struct file
*file
, void *fh
,
701 struct v4l2_buffer
*buf
)
703 struct uvc_fh
*handle
= fh
;
704 struct uvc_streaming
*stream
= handle
->stream
;
706 if (!uvc_has_privileges(handle
))
709 return uvc_query_buffer(&stream
->queue
, buf
);
712 static int uvc_ioctl_qbuf(struct file
*file
, void *fh
, struct v4l2_buffer
*buf
)
714 struct uvc_fh
*handle
= fh
;
715 struct uvc_streaming
*stream
= handle
->stream
;
717 if (!uvc_has_privileges(handle
))
720 return uvc_queue_buffer(&stream
->queue
, buf
);
723 static int uvc_ioctl_expbuf(struct file
*file
, void *fh
,
724 struct v4l2_exportbuffer
*exp
)
726 struct uvc_fh
*handle
= fh
;
727 struct uvc_streaming
*stream
= handle
->stream
;
729 if (!uvc_has_privileges(handle
))
732 return uvc_export_buffer(&stream
->queue
, exp
);
735 static int uvc_ioctl_dqbuf(struct file
*file
, void *fh
, struct v4l2_buffer
*buf
)
737 struct uvc_fh
*handle
= fh
;
738 struct uvc_streaming
*stream
= handle
->stream
;
740 if (!uvc_has_privileges(handle
))
743 return uvc_dequeue_buffer(&stream
->queue
, buf
,
744 file
->f_flags
& O_NONBLOCK
);
747 static int uvc_ioctl_create_bufs(struct file
*file
, void *fh
,
748 struct v4l2_create_buffers
*cb
)
750 struct uvc_fh
*handle
= fh
;
751 struct uvc_streaming
*stream
= handle
->stream
;
754 ret
= uvc_acquire_privileges(handle
);
758 return uvc_create_buffers(&stream
->queue
, cb
);
761 static int uvc_ioctl_streamon(struct file
*file
, void *fh
,
762 enum v4l2_buf_type type
)
764 struct uvc_fh
*handle
= fh
;
765 struct uvc_streaming
*stream
= handle
->stream
;
768 if (!uvc_has_privileges(handle
))
771 mutex_lock(&stream
->mutex
);
772 ret
= uvc_queue_streamon(&stream
->queue
, type
);
773 mutex_unlock(&stream
->mutex
);
778 static int uvc_ioctl_streamoff(struct file
*file
, void *fh
,
779 enum v4l2_buf_type type
)
781 struct uvc_fh
*handle
= fh
;
782 struct uvc_streaming
*stream
= handle
->stream
;
784 if (!uvc_has_privileges(handle
))
787 mutex_lock(&stream
->mutex
);
788 uvc_queue_streamoff(&stream
->queue
, type
);
789 mutex_unlock(&stream
->mutex
);
794 static int uvc_ioctl_enum_input(struct file
*file
, void *fh
,
795 struct v4l2_input
*input
)
797 struct uvc_fh
*handle
= fh
;
798 struct uvc_video_chain
*chain
= handle
->chain
;
799 const struct uvc_entity
*selector
= chain
->selector
;
800 struct uvc_entity
*iterm
= NULL
;
801 u32 index
= input
->index
;
804 if (selector
== NULL
||
805 (chain
->dev
->quirks
& UVC_QUIRK_IGNORE_SELECTOR_UNIT
)) {
808 list_for_each_entry(iterm
, &chain
->entities
, chain
) {
809 if (UVC_ENTITY_IS_ITERM(iterm
))
813 } else if (index
< selector
->bNrInPins
) {
814 pin
= selector
->baSourceID
[index
];
815 list_for_each_entry(iterm
, &chain
->entities
, chain
) {
816 if (!UVC_ENTITY_IS_ITERM(iterm
))
818 if (iterm
->id
== pin
)
823 if (iterm
== NULL
|| iterm
->id
!= pin
)
826 memset(input
, 0, sizeof(*input
));
827 input
->index
= index
;
828 strlcpy(input
->name
, iterm
->name
, sizeof(input
->name
));
829 if (UVC_ENTITY_TYPE(iterm
) == UVC_ITT_CAMERA
)
830 input
->type
= V4L2_INPUT_TYPE_CAMERA
;
835 static int uvc_ioctl_g_input(struct file
*file
, void *fh
, unsigned int *input
)
837 struct uvc_fh
*handle
= fh
;
838 struct uvc_video_chain
*chain
= handle
->chain
;
842 if (chain
->selector
== NULL
||
843 (chain
->dev
->quirks
& UVC_QUIRK_IGNORE_SELECTOR_UNIT
)) {
848 ret
= uvc_query_ctrl(chain
->dev
, UVC_GET_CUR
, chain
->selector
->id
,
849 chain
->dev
->intfnum
, UVC_SU_INPUT_SELECT_CONTROL
,
858 static int uvc_ioctl_s_input(struct file
*file
, void *fh
, unsigned int input
)
860 struct uvc_fh
*handle
= fh
;
861 struct uvc_video_chain
*chain
= handle
->chain
;
865 ret
= uvc_acquire_privileges(handle
);
869 if (chain
->selector
== NULL
||
870 (chain
->dev
->quirks
& UVC_QUIRK_IGNORE_SELECTOR_UNIT
)) {
876 if (input
>= chain
->selector
->bNrInPins
)
880 return uvc_query_ctrl(chain
->dev
, UVC_SET_CUR
, chain
->selector
->id
,
881 chain
->dev
->intfnum
, UVC_SU_INPUT_SELECT_CONTROL
,
885 static int uvc_ioctl_queryctrl(struct file
*file
, void *fh
,
886 struct v4l2_queryctrl
*qc
)
888 struct uvc_fh
*handle
= fh
;
889 struct uvc_video_chain
*chain
= handle
->chain
;
891 return uvc_query_v4l2_ctrl(chain
, qc
);
894 static int uvc_ioctl_query_ext_ctrl(struct file
*file
, void *fh
,
895 struct v4l2_query_ext_ctrl
*qec
)
897 struct uvc_fh
*handle
= fh
;
898 struct uvc_video_chain
*chain
= handle
->chain
;
899 struct v4l2_queryctrl qc
= { qec
->id
};
902 ret
= uvc_query_v4l2_ctrl(chain
, &qc
);
908 strlcpy(qec
->name
, qc
.name
, sizeof(qec
->name
));
909 qec
->minimum
= qc
.minimum
;
910 qec
->maximum
= qc
.maximum
;
912 qec
->default_value
= qc
.default_value
;
913 qec
->flags
= qc
.flags
;
917 memset(qec
->dims
, 0, sizeof(qec
->dims
));
918 memset(qec
->reserved
, 0, sizeof(qec
->reserved
));
923 static int uvc_ioctl_g_ctrl(struct file
*file
, void *fh
,
924 struct v4l2_control
*ctrl
)
926 struct uvc_fh
*handle
= fh
;
927 struct uvc_video_chain
*chain
= handle
->chain
;
928 struct v4l2_ext_control xctrl
;
931 memset(&xctrl
, 0, sizeof(xctrl
));
934 ret
= uvc_ctrl_begin(chain
);
938 ret
= uvc_ctrl_get(chain
, &xctrl
);
939 uvc_ctrl_rollback(handle
);
943 ctrl
->value
= xctrl
.value
;
947 static int uvc_ioctl_s_ctrl(struct file
*file
, void *fh
,
948 struct v4l2_control
*ctrl
)
950 struct uvc_fh
*handle
= fh
;
951 struct uvc_video_chain
*chain
= handle
->chain
;
952 struct v4l2_ext_control xctrl
;
955 memset(&xctrl
, 0, sizeof(xctrl
));
957 xctrl
.value
= ctrl
->value
;
959 ret
= uvc_ctrl_begin(chain
);
963 ret
= uvc_ctrl_set(chain
, &xctrl
);
965 uvc_ctrl_rollback(handle
);
969 ret
= uvc_ctrl_commit(handle
, &xctrl
, 1);
973 ctrl
->value
= xctrl
.value
;
977 static int uvc_ioctl_g_ext_ctrls(struct file
*file
, void *fh
,
978 struct v4l2_ext_controls
*ctrls
)
980 struct uvc_fh
*handle
= fh
;
981 struct uvc_video_chain
*chain
= handle
->chain
;
982 struct v4l2_ext_control
*ctrl
= ctrls
->controls
;
986 if (ctrls
->which
== V4L2_CTRL_WHICH_DEF_VAL
) {
987 for (i
= 0; i
< ctrls
->count
; ++ctrl
, ++i
) {
988 struct v4l2_queryctrl qc
= { .id
= ctrl
->id
};
990 ret
= uvc_query_v4l2_ctrl(chain
, &qc
);
992 ctrls
->error_idx
= i
;
996 ctrl
->value
= qc
.default_value
;
1002 ret
= uvc_ctrl_begin(chain
);
1006 for (i
= 0; i
< ctrls
->count
; ++ctrl
, ++i
) {
1007 ret
= uvc_ctrl_get(chain
, ctrl
);
1009 uvc_ctrl_rollback(handle
);
1010 ctrls
->error_idx
= i
;
1015 ctrls
->error_idx
= 0;
1017 return uvc_ctrl_rollback(handle
);
1020 static int uvc_ioctl_s_try_ext_ctrls(struct uvc_fh
*handle
,
1021 struct v4l2_ext_controls
*ctrls
,
1024 struct v4l2_ext_control
*ctrl
= ctrls
->controls
;
1025 struct uvc_video_chain
*chain
= handle
->chain
;
1029 /* Default value cannot be changed */
1030 if (ctrls
->which
== V4L2_CTRL_WHICH_DEF_VAL
)
1033 ret
= uvc_ctrl_begin(chain
);
1037 for (i
= 0; i
< ctrls
->count
; ++ctrl
, ++i
) {
1038 ret
= uvc_ctrl_set(chain
, ctrl
);
1040 uvc_ctrl_rollback(handle
);
1041 ctrls
->error_idx
= commit
? ctrls
->count
: i
;
1046 ctrls
->error_idx
= 0;
1049 return uvc_ctrl_commit(handle
, ctrls
->controls
, ctrls
->count
);
1051 return uvc_ctrl_rollback(handle
);
1054 static int uvc_ioctl_s_ext_ctrls(struct file
*file
, void *fh
,
1055 struct v4l2_ext_controls
*ctrls
)
1057 struct uvc_fh
*handle
= fh
;
1059 return uvc_ioctl_s_try_ext_ctrls(handle
, ctrls
, true);
1062 static int uvc_ioctl_try_ext_ctrls(struct file
*file
, void *fh
,
1063 struct v4l2_ext_controls
*ctrls
)
1065 struct uvc_fh
*handle
= fh
;
1067 return uvc_ioctl_s_try_ext_ctrls(handle
, ctrls
, false);
1070 static int uvc_ioctl_querymenu(struct file
*file
, void *fh
,
1071 struct v4l2_querymenu
*qm
)
1073 struct uvc_fh
*handle
= fh
;
1074 struct uvc_video_chain
*chain
= handle
->chain
;
1076 return uvc_query_v4l2_menu(chain
, qm
);
1079 static int uvc_ioctl_g_selection(struct file
*file
, void *fh
,
1080 struct v4l2_selection
*sel
)
1082 struct uvc_fh
*handle
= fh
;
1083 struct uvc_streaming
*stream
= handle
->stream
;
1085 if (sel
->type
!= stream
->type
)
1088 switch (sel
->target
) {
1089 case V4L2_SEL_TGT_CROP_DEFAULT
:
1090 case V4L2_SEL_TGT_CROP_BOUNDS
:
1091 if (stream
->type
!= V4L2_BUF_TYPE_VIDEO_CAPTURE
)
1094 case V4L2_SEL_TGT_COMPOSE_DEFAULT
:
1095 case V4L2_SEL_TGT_COMPOSE_BOUNDS
:
1096 if (stream
->type
!= V4L2_BUF_TYPE_VIDEO_OUTPUT
)
1105 mutex_lock(&stream
->mutex
);
1106 sel
->r
.width
= stream
->cur_frame
->wWidth
;
1107 sel
->r
.height
= stream
->cur_frame
->wHeight
;
1108 mutex_unlock(&stream
->mutex
);
1113 static int uvc_ioctl_g_parm(struct file
*file
, void *fh
,
1114 struct v4l2_streamparm
*parm
)
1116 struct uvc_fh
*handle
= fh
;
1117 struct uvc_streaming
*stream
= handle
->stream
;
1119 return uvc_v4l2_get_streamparm(stream
, parm
);
1122 static int uvc_ioctl_s_parm(struct file
*file
, void *fh
,
1123 struct v4l2_streamparm
*parm
)
1125 struct uvc_fh
*handle
= fh
;
1126 struct uvc_streaming
*stream
= handle
->stream
;
1129 ret
= uvc_acquire_privileges(handle
);
1133 return uvc_v4l2_set_streamparm(stream
, parm
);
1136 static int uvc_ioctl_enum_framesizes(struct file
*file
, void *fh
,
1137 struct v4l2_frmsizeenum
*fsize
)
1139 struct uvc_fh
*handle
= fh
;
1140 struct uvc_streaming
*stream
= handle
->stream
;
1141 struct uvc_format
*format
= NULL
;
1142 struct uvc_frame
*frame
;
1145 /* Look for the given pixel format */
1146 for (i
= 0; i
< stream
->nformats
; i
++) {
1147 if (stream
->format
[i
].fcc
== fsize
->pixel_format
) {
1148 format
= &stream
->format
[i
];
1155 if (fsize
->index
>= format
->nframes
)
1158 frame
= &format
->frame
[fsize
->index
];
1159 fsize
->type
= V4L2_FRMSIZE_TYPE_DISCRETE
;
1160 fsize
->discrete
.width
= frame
->wWidth
;
1161 fsize
->discrete
.height
= frame
->wHeight
;
1165 static int uvc_ioctl_enum_frameintervals(struct file
*file
, void *fh
,
1166 struct v4l2_frmivalenum
*fival
)
1168 struct uvc_fh
*handle
= fh
;
1169 struct uvc_streaming
*stream
= handle
->stream
;
1170 struct uvc_format
*format
= NULL
;
1171 struct uvc_frame
*frame
= NULL
;
1174 /* Look for the given pixel format and frame size */
1175 for (i
= 0; i
< stream
->nformats
; i
++) {
1176 if (stream
->format
[i
].fcc
== fival
->pixel_format
) {
1177 format
= &stream
->format
[i
];
1184 for (i
= 0; i
< format
->nframes
; i
++) {
1185 if (format
->frame
[i
].wWidth
== fival
->width
&&
1186 format
->frame
[i
].wHeight
== fival
->height
) {
1187 frame
= &format
->frame
[i
];
1194 if (frame
->bFrameIntervalType
) {
1195 if (fival
->index
>= frame
->bFrameIntervalType
)
1198 fival
->type
= V4L2_FRMIVAL_TYPE_DISCRETE
;
1199 fival
->discrete
.numerator
=
1200 frame
->dwFrameInterval
[fival
->index
];
1201 fival
->discrete
.denominator
= 10000000;
1202 uvc_simplify_fraction(&fival
->discrete
.numerator
,
1203 &fival
->discrete
.denominator
, 8, 333);
1208 fival
->type
= V4L2_FRMIVAL_TYPE_STEPWISE
;
1209 fival
->stepwise
.min
.numerator
= frame
->dwFrameInterval
[0];
1210 fival
->stepwise
.min
.denominator
= 10000000;
1211 fival
->stepwise
.max
.numerator
= frame
->dwFrameInterval
[1];
1212 fival
->stepwise
.max
.denominator
= 10000000;
1213 fival
->stepwise
.step
.numerator
= frame
->dwFrameInterval
[2];
1214 fival
->stepwise
.step
.denominator
= 10000000;
1215 uvc_simplify_fraction(&fival
->stepwise
.min
.numerator
,
1216 &fival
->stepwise
.min
.denominator
, 8, 333);
1217 uvc_simplify_fraction(&fival
->stepwise
.max
.numerator
,
1218 &fival
->stepwise
.max
.denominator
, 8, 333);
1219 uvc_simplify_fraction(&fival
->stepwise
.step
.numerator
,
1220 &fival
->stepwise
.step
.denominator
, 8, 333);
1226 static int uvc_ioctl_subscribe_event(struct v4l2_fh
*fh
,
1227 const struct v4l2_event_subscription
*sub
)
1229 switch (sub
->type
) {
1230 case V4L2_EVENT_CTRL
:
1231 return v4l2_event_subscribe(fh
, sub
, 0, &uvc_ctrl_sub_ev_ops
);
1237 static long uvc_ioctl_default(struct file
*file
, void *fh
, bool valid_prio
,
1238 unsigned int cmd
, void *arg
)
1240 struct uvc_fh
*handle
= fh
;
1241 struct uvc_video_chain
*chain
= handle
->chain
;
1244 /* Dynamic controls. */
1245 case UVCIOC_CTRL_MAP
:
1246 return uvc_ioctl_ctrl_map(chain
, arg
);
1248 case UVCIOC_CTRL_QUERY
:
1249 return uvc_xu_ctrl_query(chain
, arg
);
1256 #ifdef CONFIG_COMPAT
1257 struct uvc_xu_control_mapping32
{
1268 compat_caddr_t menu_info
;
1274 static int uvc_v4l2_get_xu_mapping(struct uvc_xu_control_mapping
*kp
,
1275 const struct uvc_xu_control_mapping32 __user
*up
)
1277 struct uvc_menu_info __user
*umenus
;
1278 struct uvc_menu_info __user
*kmenus
;
1281 if (!access_ok(VERIFY_READ
, up
, sizeof(*up
)) ||
1282 __copy_from_user(kp
, up
, offsetof(typeof(*up
), menu_info
)) ||
1283 __get_user(kp
->menu_count
, &up
->menu_count
))
1286 memset(kp
->reserved
, 0, sizeof(kp
->reserved
));
1288 if (kp
->menu_count
== 0) {
1289 kp
->menu_info
= NULL
;
1293 if (__get_user(p
, &up
->menu_info
))
1295 umenus
= compat_ptr(p
);
1296 if (!access_ok(VERIFY_READ
, umenus
, kp
->menu_count
* sizeof(*umenus
)))
1299 kmenus
= compat_alloc_user_space(kp
->menu_count
* sizeof(*kmenus
));
1302 kp
->menu_info
= kmenus
;
1304 if (copy_in_user(kmenus
, umenus
, kp
->menu_count
* sizeof(*umenus
)))
1310 static int uvc_v4l2_put_xu_mapping(const struct uvc_xu_control_mapping
*kp
,
1311 struct uvc_xu_control_mapping32 __user
*up
)
1313 struct uvc_menu_info __user
*umenus
;
1314 struct uvc_menu_info __user
*kmenus
= kp
->menu_info
;
1317 if (!access_ok(VERIFY_WRITE
, up
, sizeof(*up
)) ||
1318 __copy_to_user(up
, kp
, offsetof(typeof(*up
), menu_info
)) ||
1319 __put_user(kp
->menu_count
, &up
->menu_count
))
1322 if (__clear_user(up
->reserved
, sizeof(up
->reserved
)))
1325 if (kp
->menu_count
== 0)
1328 if (get_user(p
, &up
->menu_info
))
1330 umenus
= compat_ptr(p
);
1332 if (copy_in_user(umenus
, kmenus
, kp
->menu_count
* sizeof(*umenus
)))
1338 struct uvc_xu_control_query32
{
1343 compat_caddr_t data
;
1346 static int uvc_v4l2_get_xu_query(struct uvc_xu_control_query
*kp
,
1347 const struct uvc_xu_control_query32 __user
*up
)
1353 if (!access_ok(VERIFY_READ
, up
, sizeof(*up
)) ||
1354 __copy_from_user(kp
, up
, offsetof(typeof(*up
), data
)))
1357 if (kp
->size
== 0) {
1362 if (__get_user(p
, &up
->data
))
1364 udata
= compat_ptr(p
);
1365 if (!access_ok(VERIFY_READ
, udata
, kp
->size
))
1368 kdata
= compat_alloc_user_space(kp
->size
);
1373 if (copy_in_user(kdata
, udata
, kp
->size
))
1379 static int uvc_v4l2_put_xu_query(const struct uvc_xu_control_query
*kp
,
1380 struct uvc_xu_control_query32 __user
*up
)
1383 u8 __user
*kdata
= kp
->data
;
1386 if (!access_ok(VERIFY_WRITE
, up
, sizeof(*up
)) ||
1387 __copy_to_user(up
, kp
, offsetof(typeof(*up
), data
)))
1393 if (get_user(p
, &up
->data
))
1395 udata
= compat_ptr(p
);
1396 if (!access_ok(VERIFY_READ
, udata
, kp
->size
))
1399 if (copy_in_user(udata
, kdata
, kp
->size
))
1405 #define UVCIOC_CTRL_MAP32 _IOWR('u', 0x20, struct uvc_xu_control_mapping32)
1406 #define UVCIOC_CTRL_QUERY32 _IOWR('u', 0x21, struct uvc_xu_control_query32)
1408 static long uvc_v4l2_compat_ioctl32(struct file
*file
,
1409 unsigned int cmd
, unsigned long arg
)
1412 struct uvc_xu_control_mapping xmap
;
1413 struct uvc_xu_control_query xqry
;
1415 void __user
*up
= compat_ptr(arg
);
1416 mm_segment_t old_fs
;
1420 case UVCIOC_CTRL_MAP32
:
1421 cmd
= UVCIOC_CTRL_MAP
;
1422 ret
= uvc_v4l2_get_xu_mapping(&karg
.xmap
, up
);
1425 case UVCIOC_CTRL_QUERY32
:
1426 cmd
= UVCIOC_CTRL_QUERY
;
1427 ret
= uvc_v4l2_get_xu_query(&karg
.xqry
, up
);
1431 return -ENOIOCTLCMD
;
1436 ret
= video_ioctl2(file
, cmd
, (unsigned long)&karg
);
1443 case UVCIOC_CTRL_MAP
:
1444 ret
= uvc_v4l2_put_xu_mapping(&karg
.xmap
, up
);
1447 case UVCIOC_CTRL_QUERY
:
1448 ret
= uvc_v4l2_put_xu_query(&karg
.xqry
, up
);
1456 static ssize_t
uvc_v4l2_read(struct file
*file
, char __user
*data
,
1457 size_t count
, loff_t
*ppos
)
1459 uvc_trace(UVC_TRACE_CALLS
, "uvc_v4l2_read: not implemented.\n");
1463 static int uvc_v4l2_mmap(struct file
*file
, struct vm_area_struct
*vma
)
1465 struct uvc_fh
*handle
= file
->private_data
;
1466 struct uvc_streaming
*stream
= handle
->stream
;
1468 uvc_trace(UVC_TRACE_CALLS
, "uvc_v4l2_mmap\n");
1470 return uvc_queue_mmap(&stream
->queue
, vma
);
1473 static unsigned int uvc_v4l2_poll(struct file
*file
, poll_table
*wait
)
1475 struct uvc_fh
*handle
= file
->private_data
;
1476 struct uvc_streaming
*stream
= handle
->stream
;
1478 uvc_trace(UVC_TRACE_CALLS
, "uvc_v4l2_poll\n");
1480 return uvc_queue_poll(&stream
->queue
, file
, wait
);
1484 static unsigned long uvc_v4l2_get_unmapped_area(struct file
*file
,
1485 unsigned long addr
, unsigned long len
, unsigned long pgoff
,
1486 unsigned long flags
)
1488 struct uvc_fh
*handle
= file
->private_data
;
1489 struct uvc_streaming
*stream
= handle
->stream
;
1491 uvc_trace(UVC_TRACE_CALLS
, "uvc_v4l2_get_unmapped_area\n");
1493 return uvc_queue_get_unmapped_area(&stream
->queue
, pgoff
);
1497 const struct v4l2_ioctl_ops uvc_ioctl_ops
= {
1498 .vidioc_querycap
= uvc_ioctl_querycap
,
1499 .vidioc_enum_fmt_vid_cap
= uvc_ioctl_enum_fmt_vid_cap
,
1500 .vidioc_enum_fmt_vid_out
= uvc_ioctl_enum_fmt_vid_out
,
1501 .vidioc_g_fmt_vid_cap
= uvc_ioctl_g_fmt_vid_cap
,
1502 .vidioc_g_fmt_vid_out
= uvc_ioctl_g_fmt_vid_out
,
1503 .vidioc_s_fmt_vid_cap
= uvc_ioctl_s_fmt_vid_cap
,
1504 .vidioc_s_fmt_vid_out
= uvc_ioctl_s_fmt_vid_out
,
1505 .vidioc_try_fmt_vid_cap
= uvc_ioctl_try_fmt_vid_cap
,
1506 .vidioc_try_fmt_vid_out
= uvc_ioctl_try_fmt_vid_out
,
1507 .vidioc_reqbufs
= uvc_ioctl_reqbufs
,
1508 .vidioc_querybuf
= uvc_ioctl_querybuf
,
1509 .vidioc_qbuf
= uvc_ioctl_qbuf
,
1510 .vidioc_expbuf
= uvc_ioctl_expbuf
,
1511 .vidioc_dqbuf
= uvc_ioctl_dqbuf
,
1512 .vidioc_create_bufs
= uvc_ioctl_create_bufs
,
1513 .vidioc_streamon
= uvc_ioctl_streamon
,
1514 .vidioc_streamoff
= uvc_ioctl_streamoff
,
1515 .vidioc_enum_input
= uvc_ioctl_enum_input
,
1516 .vidioc_g_input
= uvc_ioctl_g_input
,
1517 .vidioc_s_input
= uvc_ioctl_s_input
,
1518 .vidioc_queryctrl
= uvc_ioctl_queryctrl
,
1519 .vidioc_query_ext_ctrl
= uvc_ioctl_query_ext_ctrl
,
1520 .vidioc_g_ctrl
= uvc_ioctl_g_ctrl
,
1521 .vidioc_s_ctrl
= uvc_ioctl_s_ctrl
,
1522 .vidioc_g_ext_ctrls
= uvc_ioctl_g_ext_ctrls
,
1523 .vidioc_s_ext_ctrls
= uvc_ioctl_s_ext_ctrls
,
1524 .vidioc_try_ext_ctrls
= uvc_ioctl_try_ext_ctrls
,
1525 .vidioc_querymenu
= uvc_ioctl_querymenu
,
1526 .vidioc_g_selection
= uvc_ioctl_g_selection
,
1527 .vidioc_g_parm
= uvc_ioctl_g_parm
,
1528 .vidioc_s_parm
= uvc_ioctl_s_parm
,
1529 .vidioc_enum_framesizes
= uvc_ioctl_enum_framesizes
,
1530 .vidioc_enum_frameintervals
= uvc_ioctl_enum_frameintervals
,
1531 .vidioc_subscribe_event
= uvc_ioctl_subscribe_event
,
1532 .vidioc_unsubscribe_event
= v4l2_event_unsubscribe
,
1533 .vidioc_default
= uvc_ioctl_default
,
1536 const struct v4l2_file_operations uvc_fops
= {
1537 .owner
= THIS_MODULE
,
1538 .open
= uvc_v4l2_open
,
1539 .release
= uvc_v4l2_release
,
1540 .unlocked_ioctl
= video_ioctl2
,
1541 #ifdef CONFIG_COMPAT
1542 .compat_ioctl32
= uvc_v4l2_compat_ioctl32
,
1544 .read
= uvc_v4l2_read
,
1545 .mmap
= uvc_v4l2_mmap
,
1546 .poll
= uvc_v4l2_poll
,
1548 .get_unmapped_area
= uvc_v4l2_get_unmapped_area
,