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
= memdup_user(xmap
->menu_info
, size
);
74 if (IS_ERR(map
->menu_info
)) {
75 ret
= PTR_ERR(map
->menu_info
);
79 map
->menu_count
= xmap
->menu_count
;
83 uvc_trace(UVC_TRACE_CONTROL
, "Unsupported V4L2 control type "
84 "%u.\n", xmap
->v4l2_type
);
89 ret
= uvc_ctrl_add_mapping(chain
, map
);
91 kfree(map
->menu_info
);
98 /* ------------------------------------------------------------------------
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
108 static __u32
uvc_try_frame_interval(struct uvc_frame
*frame
, __u32 interval
)
112 if (frame
->bFrameIntervalType
) {
113 __u32 best
= -1, dist
;
115 for (i
= 0; i
< frame
->bFrameIntervalType
; ++i
) {
116 dist
= interval
> frame
->dwFrameInterval
[i
]
117 ? interval
- frame
->dwFrameInterval
[i
]
118 : frame
->dwFrameInterval
[i
] - interval
;
126 interval
= frame
->dwFrameInterval
[i
-1];
128 const __u32 min
= frame
->dwFrameInterval
[0];
129 const __u32 max
= frame
->dwFrameInterval
[1];
130 const __u32 step
= frame
->dwFrameInterval
[2];
132 interval
= min
+ (interval
- min
+ step
/2) / step
* step
;
140 static __u32
uvc_v4l2_get_bytesperline(const struct uvc_format
*format
,
141 const struct uvc_frame
*frame
)
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
;
151 return format
->bpp
* frame
->wWidth
/ 8;
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
)
159 struct uvc_format
*format
= NULL
;
160 struct uvc_frame
*frame
= NULL
;
162 unsigned int d
, maxd
;
168 if (fmt
->type
!= stream
->type
)
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
);
177 /* Check if the hardware supports the requested format, use the default
180 for (i
= 0; i
< stream
->nformats
; ++i
) {
181 format
= &stream
->format
[i
];
182 if (format
->fcc
== fmt
->fmt
.pix
.pixelformat
)
186 if (i
== stream
->nformats
) {
187 format
= stream
->def_format
;
188 fmt
->fmt
.pix
.pixelformat
= format
->fcc
;
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.
195 rw
= fmt
->fmt
.pix
.width
;
196 rh
= fmt
->fmt
.pix
.height
;
197 maxd
= (unsigned int)-1;
199 for (i
= 0; i
< format
->nframes
; ++i
) {
200 __u16 w
= format
->frame
[i
].wWidth
;
201 __u16 h
= format
->frame
[i
].wHeight
;
203 d
= min(w
, rw
) * min(h
, rh
);
204 d
= w
*h
+ rw
*rh
- 2*d
;
207 frame
= &format
->frame
[i
];
215 uvc_trace(UVC_TRACE_FORMAT
, "Unsupported size %ux%u.\n",
216 fmt
->fmt
.pix
.width
, fmt
->fmt
.pix
.height
);
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);
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.
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).
244 mutex_lock(&stream
->mutex
);
245 if (stream
->dev
->quirks
& UVC_QUIRK_PROBE_EXTRAFIELDS
)
246 probe
->dwMaxVideoFrameSize
=
247 stream
->ctrl
.dwMaxVideoFrameSize
;
249 /* Probe the device. */
250 ret
= uvc_probe_video(stream
, probe
);
251 mutex_unlock(&stream
->mutex
);
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;
263 if (uvc_format
!= NULL
)
264 *uvc_format
= format
;
265 if (uvc_frame
!= NULL
)
272 static int uvc_v4l2_get_format(struct uvc_streaming
*stream
,
273 struct v4l2_format
*fmt
)
275 struct uvc_format
*format
;
276 struct uvc_frame
*frame
;
279 if (fmt
->type
!= stream
->type
)
282 mutex_lock(&stream
->mutex
);
283 format
= stream
->cur_format
;
284 frame
= stream
->cur_frame
;
286 if (format
== NULL
|| frame
== NULL
) {
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;
301 mutex_unlock(&stream
->mutex
);
305 static int uvc_v4l2_set_format(struct uvc_streaming
*stream
,
306 struct v4l2_format
*fmt
)
308 struct uvc_streaming_control probe
;
309 struct uvc_format
*format
;
310 struct uvc_frame
*frame
;
313 if (fmt
->type
!= stream
->type
)
316 ret
= uvc_v4l2_try_format(stream
, fmt
, &probe
, &format
, &frame
);
320 mutex_lock(&stream
->mutex
);
322 if (uvc_queue_allocated(&stream
->queue
)) {
327 stream
->ctrl
= probe
;
328 stream
->cur_format
= format
;
329 stream
->cur_frame
= frame
;
332 mutex_unlock(&stream
->mutex
);
336 static int uvc_v4l2_get_streamparm(struct uvc_streaming
*stream
,
337 struct v4l2_streamparm
*parm
)
339 uint32_t numerator
, denominator
;
341 if (parm
->type
!= stream
->type
)
344 mutex_lock(&stream
->mutex
);
345 numerator
= stream
->ctrl
.dwFrameInterval
;
346 mutex_unlock(&stream
->mutex
);
348 denominator
= 10000000;
349 uvc_simplify_fraction(&numerator
, &denominator
, 8, 333);
351 memset(parm
, 0, sizeof *parm
);
352 parm
->type
= stream
->type
;
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;
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
;
371 static int uvc_v4l2_set_streamparm(struct uvc_streaming
*stream
,
372 struct v4l2_streamparm
*parm
)
374 struct uvc_streaming_control probe
;
375 struct v4l2_fract timeperframe
;
379 if (parm
->type
!= stream
->type
)
382 if (parm
->type
== V4L2_BUF_TYPE_VIDEO_CAPTURE
)
383 timeperframe
= parm
->parm
.capture
.timeperframe
;
385 timeperframe
= parm
->parm
.output
.timeperframe
;
387 interval
= uvc_fraction_to_interval(timeperframe
.numerator
,
388 timeperframe
.denominator
);
389 uvc_trace(UVC_TRACE_FORMAT
, "Setting frame interval to %u/%u (%u).\n",
390 timeperframe
.numerator
, timeperframe
.denominator
, interval
);
392 mutex_lock(&stream
->mutex
);
394 if (uvc_queue_streaming(&stream
->queue
)) {
395 mutex_unlock(&stream
->mutex
);
399 probe
= stream
->ctrl
;
400 probe
.dwFrameInterval
=
401 uvc_try_frame_interval(stream
->cur_frame
, interval
);
403 /* Probe the device with the new settings. */
404 ret
= uvc_probe_video(stream
, &probe
);
406 mutex_unlock(&stream
->mutex
);
410 stream
->ctrl
= probe
;
411 mutex_unlock(&stream
->mutex
);
413 /* Return the actual frame period. */
414 timeperframe
.numerator
= probe
.dwFrameInterval
;
415 timeperframe
.denominator
= 10000000;
416 uvc_simplify_fraction(&timeperframe
.numerator
,
417 &timeperframe
.denominator
, 8, 333);
419 if (parm
->type
== V4L2_BUF_TYPE_VIDEO_CAPTURE
)
420 parm
->parm
.capture
.timeperframe
= timeperframe
;
422 parm
->parm
.output
.timeperframe
= timeperframe
;
427 /* ------------------------------------------------------------------------
428 * Privilege management
432 * Privilege management is the multiple-open implementation basis. The current
433 * implementation is completely transparent for the end-user and doesn't
434 * require explicit use of the VIDIOC_G_PRIORITY and VIDIOC_S_PRIORITY ioctls.
435 * Those ioctls enable finer control on the device (by making possible for a
436 * user to request exclusive access to a device), but are not mature yet.
437 * Switching to the V4L2 priority mechanism might be considered in the future
438 * if this situation changes.
440 * Each open instance of a UVC device can either be in a privileged or
441 * unprivileged state. Only a single instance can be in a privileged state at
442 * a given time. Trying to perform an operation that requires privileges will
443 * automatically acquire the required privileges if possible, or return -EBUSY
444 * otherwise. Privileges are dismissed when closing the instance or when
445 * freeing the video buffers using VIDIOC_REQBUFS.
447 * Operations that require privileges are:
454 static int uvc_acquire_privileges(struct uvc_fh
*handle
)
456 /* Always succeed if the handle is already privileged. */
457 if (handle
->state
== UVC_HANDLE_ACTIVE
)
460 /* Check if the device already has a privileged handle. */
461 if (atomic_inc_return(&handle
->stream
->active
) != 1) {
462 atomic_dec(&handle
->stream
->active
);
466 handle
->state
= UVC_HANDLE_ACTIVE
;
470 static void uvc_dismiss_privileges(struct uvc_fh
*handle
)
472 if (handle
->state
== UVC_HANDLE_ACTIVE
)
473 atomic_dec(&handle
->stream
->active
);
475 handle
->state
= UVC_HANDLE_PASSIVE
;
478 static int uvc_has_privileges(struct uvc_fh
*handle
)
480 return handle
->state
== UVC_HANDLE_ACTIVE
;
483 /* ------------------------------------------------------------------------
484 * V4L2 file operations
487 static int uvc_v4l2_open(struct file
*file
)
489 struct uvc_streaming
*stream
;
490 struct uvc_fh
*handle
;
493 uvc_trace(UVC_TRACE_CALLS
, "uvc_v4l2_open\n");
494 stream
= video_drvdata(file
);
496 ret
= usb_autopm_get_interface(stream
->dev
->intf
);
500 /* Create the device handle. */
501 handle
= kzalloc(sizeof *handle
, GFP_KERNEL
);
502 if (handle
== NULL
) {
503 usb_autopm_put_interface(stream
->dev
->intf
);
507 mutex_lock(&stream
->dev
->lock
);
508 if (stream
->dev
->users
== 0) {
509 ret
= uvc_status_start(stream
->dev
, GFP_KERNEL
);
511 mutex_unlock(&stream
->dev
->lock
);
512 usb_autopm_put_interface(stream
->dev
->intf
);
518 stream
->dev
->users
++;
519 mutex_unlock(&stream
->dev
->lock
);
521 v4l2_fh_init(&handle
->vfh
, &stream
->vdev
);
522 v4l2_fh_add(&handle
->vfh
);
523 handle
->chain
= stream
->chain
;
524 handle
->stream
= stream
;
525 handle
->state
= UVC_HANDLE_PASSIVE
;
526 file
->private_data
= handle
;
531 static int uvc_v4l2_release(struct file
*file
)
533 struct uvc_fh
*handle
= file
->private_data
;
534 struct uvc_streaming
*stream
= handle
->stream
;
536 uvc_trace(UVC_TRACE_CALLS
, "uvc_v4l2_release\n");
538 /* Only free resources if this is a privileged handle. */
539 if (uvc_has_privileges(handle
))
540 uvc_queue_release(&stream
->queue
);
542 /* Release the file handle. */
543 uvc_dismiss_privileges(handle
);
544 v4l2_fh_del(&handle
->vfh
);
545 v4l2_fh_exit(&handle
->vfh
);
547 file
->private_data
= NULL
;
549 mutex_lock(&stream
->dev
->lock
);
550 if (--stream
->dev
->users
== 0)
551 uvc_status_stop(stream
->dev
);
552 mutex_unlock(&stream
->dev
->lock
);
554 usb_autopm_put_interface(stream
->dev
->intf
);
558 static int uvc_ioctl_querycap(struct file
*file
, void *fh
,
559 struct v4l2_capability
*cap
)
561 struct video_device
*vdev
= video_devdata(file
);
562 struct uvc_fh
*handle
= file
->private_data
;
563 struct uvc_video_chain
*chain
= handle
->chain
;
564 struct uvc_streaming
*stream
= handle
->stream
;
566 strlcpy(cap
->driver
, "uvcvideo", sizeof(cap
->driver
));
567 strlcpy(cap
->card
, vdev
->name
, sizeof(cap
->card
));
568 usb_make_path(stream
->dev
->udev
, cap
->bus_info
, sizeof(cap
->bus_info
));
569 cap
->capabilities
= V4L2_CAP_DEVICE_CAPS
| V4L2_CAP_STREAMING
571 if (stream
->type
== V4L2_BUF_TYPE_VIDEO_CAPTURE
)
572 cap
->device_caps
= V4L2_CAP_VIDEO_CAPTURE
| V4L2_CAP_STREAMING
;
574 cap
->device_caps
= V4L2_CAP_VIDEO_OUTPUT
| V4L2_CAP_STREAMING
;
579 static int uvc_ioctl_enum_fmt(struct uvc_streaming
*stream
,
580 struct v4l2_fmtdesc
*fmt
)
582 struct uvc_format
*format
;
583 enum v4l2_buf_type type
= fmt
->type
;
584 __u32 index
= fmt
->index
;
586 if (fmt
->type
!= stream
->type
|| fmt
->index
>= stream
->nformats
)
589 memset(fmt
, 0, sizeof(*fmt
));
593 format
= &stream
->format
[fmt
->index
];
595 if (format
->flags
& UVC_FMT_FLAG_COMPRESSED
)
596 fmt
->flags
|= V4L2_FMT_FLAG_COMPRESSED
;
597 strlcpy(fmt
->description
, format
->name
, sizeof(fmt
->description
));
598 fmt
->description
[sizeof(fmt
->description
) - 1] = 0;
599 fmt
->pixelformat
= format
->fcc
;
603 static int uvc_ioctl_enum_fmt_vid_cap(struct file
*file
, void *fh
,
604 struct v4l2_fmtdesc
*fmt
)
606 struct uvc_fh
*handle
= fh
;
607 struct uvc_streaming
*stream
= handle
->stream
;
609 return uvc_ioctl_enum_fmt(stream
, fmt
);
612 static int uvc_ioctl_enum_fmt_vid_out(struct file
*file
, void *fh
,
613 struct v4l2_fmtdesc
*fmt
)
615 struct uvc_fh
*handle
= fh
;
616 struct uvc_streaming
*stream
= handle
->stream
;
618 return uvc_ioctl_enum_fmt(stream
, fmt
);
621 static int uvc_ioctl_g_fmt_vid_cap(struct file
*file
, void *fh
,
622 struct v4l2_format
*fmt
)
624 struct uvc_fh
*handle
= fh
;
625 struct uvc_streaming
*stream
= handle
->stream
;
627 return uvc_v4l2_get_format(stream
, fmt
);
630 static int uvc_ioctl_g_fmt_vid_out(struct file
*file
, void *fh
,
631 struct v4l2_format
*fmt
)
633 struct uvc_fh
*handle
= fh
;
634 struct uvc_streaming
*stream
= handle
->stream
;
636 return uvc_v4l2_get_format(stream
, fmt
);
639 static int uvc_ioctl_s_fmt_vid_cap(struct file
*file
, void *fh
,
640 struct v4l2_format
*fmt
)
642 struct uvc_fh
*handle
= fh
;
643 struct uvc_streaming
*stream
= handle
->stream
;
646 ret
= uvc_acquire_privileges(handle
);
650 return uvc_v4l2_set_format(stream
, fmt
);
653 static int uvc_ioctl_s_fmt_vid_out(struct file
*file
, void *fh
,
654 struct v4l2_format
*fmt
)
656 struct uvc_fh
*handle
= fh
;
657 struct uvc_streaming
*stream
= handle
->stream
;
660 ret
= uvc_acquire_privileges(handle
);
664 return uvc_v4l2_set_format(stream
, fmt
);
667 static int uvc_ioctl_try_fmt_vid_cap(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_try_fmt_vid_out(struct file
*file
, void *fh
,
678 struct v4l2_format
*fmt
)
680 struct uvc_fh
*handle
= fh
;
681 struct uvc_streaming
*stream
= handle
->stream
;
682 struct uvc_streaming_control probe
;
684 return uvc_v4l2_try_format(stream
, fmt
, &probe
, NULL
, NULL
);
687 static int uvc_ioctl_reqbufs(struct file
*file
, void *fh
,
688 struct v4l2_requestbuffers
*rb
)
690 struct uvc_fh
*handle
= fh
;
691 struct uvc_streaming
*stream
= handle
->stream
;
694 ret
= uvc_acquire_privileges(handle
);
698 mutex_lock(&stream
->mutex
);
699 ret
= uvc_request_buffers(&stream
->queue
, rb
);
700 mutex_unlock(&stream
->mutex
);
705 uvc_dismiss_privileges(handle
);
710 static int uvc_ioctl_querybuf(struct file
*file
, void *fh
,
711 struct v4l2_buffer
*buf
)
713 struct uvc_fh
*handle
= fh
;
714 struct uvc_streaming
*stream
= handle
->stream
;
716 if (!uvc_has_privileges(handle
))
719 return uvc_query_buffer(&stream
->queue
, buf
);
722 static int uvc_ioctl_qbuf(struct file
*file
, void *fh
, struct v4l2_buffer
*buf
)
724 struct uvc_fh
*handle
= fh
;
725 struct uvc_streaming
*stream
= handle
->stream
;
727 if (!uvc_has_privileges(handle
))
730 return uvc_queue_buffer(&stream
->queue
, buf
);
733 static int uvc_ioctl_expbuf(struct file
*file
, void *fh
,
734 struct v4l2_exportbuffer
*exp
)
736 struct uvc_fh
*handle
= fh
;
737 struct uvc_streaming
*stream
= handle
->stream
;
739 if (!uvc_has_privileges(handle
))
742 return uvc_export_buffer(&stream
->queue
, exp
);
745 static int uvc_ioctl_dqbuf(struct file
*file
, void *fh
, struct v4l2_buffer
*buf
)
747 struct uvc_fh
*handle
= fh
;
748 struct uvc_streaming
*stream
= handle
->stream
;
750 if (!uvc_has_privileges(handle
))
753 return uvc_dequeue_buffer(&stream
->queue
, buf
,
754 file
->f_flags
& O_NONBLOCK
);
757 static int uvc_ioctl_create_bufs(struct file
*file
, void *fh
,
758 struct v4l2_create_buffers
*cb
)
760 struct uvc_fh
*handle
= fh
;
761 struct uvc_streaming
*stream
= handle
->stream
;
764 ret
= uvc_acquire_privileges(handle
);
768 return uvc_create_buffers(&stream
->queue
, cb
);
771 static int uvc_ioctl_streamon(struct file
*file
, void *fh
,
772 enum v4l2_buf_type type
)
774 struct uvc_fh
*handle
= fh
;
775 struct uvc_streaming
*stream
= handle
->stream
;
778 if (!uvc_has_privileges(handle
))
781 mutex_lock(&stream
->mutex
);
782 ret
= uvc_queue_streamon(&stream
->queue
, type
);
783 mutex_unlock(&stream
->mutex
);
788 static int uvc_ioctl_streamoff(struct file
*file
, void *fh
,
789 enum v4l2_buf_type type
)
791 struct uvc_fh
*handle
= fh
;
792 struct uvc_streaming
*stream
= handle
->stream
;
794 if (!uvc_has_privileges(handle
))
797 mutex_lock(&stream
->mutex
);
798 uvc_queue_streamoff(&stream
->queue
, type
);
799 mutex_unlock(&stream
->mutex
);
804 static int uvc_ioctl_enum_input(struct file
*file
, void *fh
,
805 struct v4l2_input
*input
)
807 struct uvc_fh
*handle
= fh
;
808 struct uvc_video_chain
*chain
= handle
->chain
;
809 const struct uvc_entity
*selector
= chain
->selector
;
810 struct uvc_entity
*iterm
= NULL
;
811 u32 index
= input
->index
;
814 if (selector
== NULL
||
815 (chain
->dev
->quirks
& UVC_QUIRK_IGNORE_SELECTOR_UNIT
)) {
818 list_for_each_entry(iterm
, &chain
->entities
, chain
) {
819 if (UVC_ENTITY_IS_ITERM(iterm
))
823 } else if (index
< selector
->bNrInPins
) {
824 pin
= selector
->baSourceID
[index
];
825 list_for_each_entry(iterm
, &chain
->entities
, chain
) {
826 if (!UVC_ENTITY_IS_ITERM(iterm
))
828 if (iterm
->id
== pin
)
833 if (iterm
== NULL
|| iterm
->id
!= pin
)
836 memset(input
, 0, sizeof(*input
));
837 input
->index
= index
;
838 strlcpy(input
->name
, iterm
->name
, sizeof(input
->name
));
839 if (UVC_ENTITY_TYPE(iterm
) == UVC_ITT_CAMERA
)
840 input
->type
= V4L2_INPUT_TYPE_CAMERA
;
845 static int uvc_ioctl_g_input(struct file
*file
, void *fh
, unsigned int *input
)
847 struct uvc_fh
*handle
= fh
;
848 struct uvc_video_chain
*chain
= handle
->chain
;
852 if (chain
->selector
== NULL
||
853 (chain
->dev
->quirks
& UVC_QUIRK_IGNORE_SELECTOR_UNIT
)) {
858 ret
= uvc_query_ctrl(chain
->dev
, UVC_GET_CUR
, chain
->selector
->id
,
859 chain
->dev
->intfnum
, UVC_SU_INPUT_SELECT_CONTROL
,
868 static int uvc_ioctl_s_input(struct file
*file
, void *fh
, unsigned int input
)
870 struct uvc_fh
*handle
= fh
;
871 struct uvc_video_chain
*chain
= handle
->chain
;
875 ret
= uvc_acquire_privileges(handle
);
879 if (chain
->selector
== NULL
||
880 (chain
->dev
->quirks
& UVC_QUIRK_IGNORE_SELECTOR_UNIT
)) {
886 if (input
>= chain
->selector
->bNrInPins
)
890 return uvc_query_ctrl(chain
->dev
, UVC_SET_CUR
, chain
->selector
->id
,
891 chain
->dev
->intfnum
, UVC_SU_INPUT_SELECT_CONTROL
,
895 static int uvc_ioctl_queryctrl(struct file
*file
, void *fh
,
896 struct v4l2_queryctrl
*qc
)
898 struct uvc_fh
*handle
= fh
;
899 struct uvc_video_chain
*chain
= handle
->chain
;
901 return uvc_query_v4l2_ctrl(chain
, qc
);
904 static int uvc_ioctl_query_ext_ctrl(struct file
*file
, void *fh
,
905 struct v4l2_query_ext_ctrl
*qec
)
907 struct uvc_fh
*handle
= fh
;
908 struct uvc_video_chain
*chain
= handle
->chain
;
909 struct v4l2_queryctrl qc
= { qec
->id
};
912 ret
= uvc_query_v4l2_ctrl(chain
, &qc
);
918 strlcpy(qec
->name
, qc
.name
, sizeof(qec
->name
));
919 qec
->minimum
= qc
.minimum
;
920 qec
->maximum
= qc
.maximum
;
922 qec
->default_value
= qc
.default_value
;
923 qec
->flags
= qc
.flags
;
927 memset(qec
->dims
, 0, sizeof(qec
->dims
));
928 memset(qec
->reserved
, 0, sizeof(qec
->reserved
));
933 static int uvc_ioctl_g_ctrl(struct file
*file
, void *fh
,
934 struct v4l2_control
*ctrl
)
936 struct uvc_fh
*handle
= fh
;
937 struct uvc_video_chain
*chain
= handle
->chain
;
938 struct v4l2_ext_control xctrl
;
941 memset(&xctrl
, 0, sizeof(xctrl
));
944 ret
= uvc_ctrl_begin(chain
);
948 ret
= uvc_ctrl_get(chain
, &xctrl
);
949 uvc_ctrl_rollback(handle
);
953 ctrl
->value
= xctrl
.value
;
957 static int uvc_ioctl_s_ctrl(struct file
*file
, void *fh
,
958 struct v4l2_control
*ctrl
)
960 struct uvc_fh
*handle
= fh
;
961 struct uvc_video_chain
*chain
= handle
->chain
;
962 struct v4l2_ext_control xctrl
;
965 memset(&xctrl
, 0, sizeof(xctrl
));
967 xctrl
.value
= ctrl
->value
;
969 ret
= uvc_ctrl_begin(chain
);
973 ret
= uvc_ctrl_set(chain
, &xctrl
);
975 uvc_ctrl_rollback(handle
);
979 ret
= uvc_ctrl_commit(handle
, &xctrl
, 1);
983 ctrl
->value
= xctrl
.value
;
987 static int uvc_ioctl_g_ext_ctrls(struct file
*file
, void *fh
,
988 struct v4l2_ext_controls
*ctrls
)
990 struct uvc_fh
*handle
= fh
;
991 struct uvc_video_chain
*chain
= handle
->chain
;
992 struct v4l2_ext_control
*ctrl
= ctrls
->controls
;
996 if (ctrls
->which
== V4L2_CTRL_WHICH_DEF_VAL
) {
997 for (i
= 0; i
< ctrls
->count
; ++ctrl
, ++i
) {
998 struct v4l2_queryctrl qc
= { .id
= ctrl
->id
};
1000 ret
= uvc_query_v4l2_ctrl(chain
, &qc
);
1002 ctrls
->error_idx
= i
;
1006 ctrl
->value
= qc
.default_value
;
1012 ret
= uvc_ctrl_begin(chain
);
1016 for (i
= 0; i
< ctrls
->count
; ++ctrl
, ++i
) {
1017 ret
= uvc_ctrl_get(chain
, ctrl
);
1019 uvc_ctrl_rollback(handle
);
1020 ctrls
->error_idx
= i
;
1025 ctrls
->error_idx
= 0;
1027 return uvc_ctrl_rollback(handle
);
1030 static int uvc_ioctl_s_try_ext_ctrls(struct uvc_fh
*handle
,
1031 struct v4l2_ext_controls
*ctrls
,
1034 struct v4l2_ext_control
*ctrl
= ctrls
->controls
;
1035 struct uvc_video_chain
*chain
= handle
->chain
;
1039 /* Default value cannot be changed */
1040 if (ctrls
->which
== V4L2_CTRL_WHICH_DEF_VAL
)
1043 ret
= uvc_ctrl_begin(chain
);
1047 for (i
= 0; i
< ctrls
->count
; ++ctrl
, ++i
) {
1048 ret
= uvc_ctrl_set(chain
, ctrl
);
1050 uvc_ctrl_rollback(handle
);
1051 ctrls
->error_idx
= commit
? ctrls
->count
: i
;
1056 ctrls
->error_idx
= 0;
1059 return uvc_ctrl_commit(handle
, ctrls
->controls
, ctrls
->count
);
1061 return uvc_ctrl_rollback(handle
);
1064 static int uvc_ioctl_s_ext_ctrls(struct file
*file
, void *fh
,
1065 struct v4l2_ext_controls
*ctrls
)
1067 struct uvc_fh
*handle
= fh
;
1069 return uvc_ioctl_s_try_ext_ctrls(handle
, ctrls
, true);
1072 static int uvc_ioctl_try_ext_ctrls(struct file
*file
, void *fh
,
1073 struct v4l2_ext_controls
*ctrls
)
1075 struct uvc_fh
*handle
= fh
;
1077 return uvc_ioctl_s_try_ext_ctrls(handle
, ctrls
, false);
1080 static int uvc_ioctl_querymenu(struct file
*file
, void *fh
,
1081 struct v4l2_querymenu
*qm
)
1083 struct uvc_fh
*handle
= fh
;
1084 struct uvc_video_chain
*chain
= handle
->chain
;
1086 return uvc_query_v4l2_menu(chain
, qm
);
1089 static int uvc_ioctl_g_selection(struct file
*file
, void *fh
,
1090 struct v4l2_selection
*sel
)
1092 struct uvc_fh
*handle
= fh
;
1093 struct uvc_streaming
*stream
= handle
->stream
;
1095 if (sel
->type
!= stream
->type
)
1098 switch (sel
->target
) {
1099 case V4L2_SEL_TGT_CROP_DEFAULT
:
1100 case V4L2_SEL_TGT_CROP_BOUNDS
:
1101 if (stream
->type
!= V4L2_BUF_TYPE_VIDEO_CAPTURE
)
1104 case V4L2_SEL_TGT_COMPOSE_DEFAULT
:
1105 case V4L2_SEL_TGT_COMPOSE_BOUNDS
:
1106 if (stream
->type
!= V4L2_BUF_TYPE_VIDEO_OUTPUT
)
1115 mutex_lock(&stream
->mutex
);
1116 sel
->r
.width
= stream
->cur_frame
->wWidth
;
1117 sel
->r
.height
= stream
->cur_frame
->wHeight
;
1118 mutex_unlock(&stream
->mutex
);
1123 static int uvc_ioctl_g_parm(struct file
*file
, void *fh
,
1124 struct v4l2_streamparm
*parm
)
1126 struct uvc_fh
*handle
= fh
;
1127 struct uvc_streaming
*stream
= handle
->stream
;
1129 return uvc_v4l2_get_streamparm(stream
, parm
);
1132 static int uvc_ioctl_s_parm(struct file
*file
, void *fh
,
1133 struct v4l2_streamparm
*parm
)
1135 struct uvc_fh
*handle
= fh
;
1136 struct uvc_streaming
*stream
= handle
->stream
;
1139 ret
= uvc_acquire_privileges(handle
);
1143 return uvc_v4l2_set_streamparm(stream
, parm
);
1146 static int uvc_ioctl_enum_framesizes(struct file
*file
, void *fh
,
1147 struct v4l2_frmsizeenum
*fsize
)
1149 struct uvc_fh
*handle
= fh
;
1150 struct uvc_streaming
*stream
= handle
->stream
;
1151 struct uvc_format
*format
= NULL
;
1152 struct uvc_frame
*frame
;
1155 /* Look for the given pixel format */
1156 for (i
= 0; i
< stream
->nformats
; i
++) {
1157 if (stream
->format
[i
].fcc
== fsize
->pixel_format
) {
1158 format
= &stream
->format
[i
];
1165 if (fsize
->index
>= format
->nframes
)
1168 frame
= &format
->frame
[fsize
->index
];
1169 fsize
->type
= V4L2_FRMSIZE_TYPE_DISCRETE
;
1170 fsize
->discrete
.width
= frame
->wWidth
;
1171 fsize
->discrete
.height
= frame
->wHeight
;
1175 static int uvc_ioctl_enum_frameintervals(struct file
*file
, void *fh
,
1176 struct v4l2_frmivalenum
*fival
)
1178 struct uvc_fh
*handle
= fh
;
1179 struct uvc_streaming
*stream
= handle
->stream
;
1180 struct uvc_format
*format
= NULL
;
1181 struct uvc_frame
*frame
= NULL
;
1184 /* Look for the given pixel format and frame size */
1185 for (i
= 0; i
< stream
->nformats
; i
++) {
1186 if (stream
->format
[i
].fcc
== fival
->pixel_format
) {
1187 format
= &stream
->format
[i
];
1194 for (i
= 0; i
< format
->nframes
; i
++) {
1195 if (format
->frame
[i
].wWidth
== fival
->width
&&
1196 format
->frame
[i
].wHeight
== fival
->height
) {
1197 frame
= &format
->frame
[i
];
1204 if (frame
->bFrameIntervalType
) {
1205 if (fival
->index
>= frame
->bFrameIntervalType
)
1208 fival
->type
= V4L2_FRMIVAL_TYPE_DISCRETE
;
1209 fival
->discrete
.numerator
=
1210 frame
->dwFrameInterval
[fival
->index
];
1211 fival
->discrete
.denominator
= 10000000;
1212 uvc_simplify_fraction(&fival
->discrete
.numerator
,
1213 &fival
->discrete
.denominator
, 8, 333);
1218 fival
->type
= V4L2_FRMIVAL_TYPE_STEPWISE
;
1219 fival
->stepwise
.min
.numerator
= frame
->dwFrameInterval
[0];
1220 fival
->stepwise
.min
.denominator
= 10000000;
1221 fival
->stepwise
.max
.numerator
= frame
->dwFrameInterval
[1];
1222 fival
->stepwise
.max
.denominator
= 10000000;
1223 fival
->stepwise
.step
.numerator
= frame
->dwFrameInterval
[2];
1224 fival
->stepwise
.step
.denominator
= 10000000;
1225 uvc_simplify_fraction(&fival
->stepwise
.min
.numerator
,
1226 &fival
->stepwise
.min
.denominator
, 8, 333);
1227 uvc_simplify_fraction(&fival
->stepwise
.max
.numerator
,
1228 &fival
->stepwise
.max
.denominator
, 8, 333);
1229 uvc_simplify_fraction(&fival
->stepwise
.step
.numerator
,
1230 &fival
->stepwise
.step
.denominator
, 8, 333);
1236 static int uvc_ioctl_subscribe_event(struct v4l2_fh
*fh
,
1237 const struct v4l2_event_subscription
*sub
)
1239 switch (sub
->type
) {
1240 case V4L2_EVENT_CTRL
:
1241 return v4l2_event_subscribe(fh
, sub
, 0, &uvc_ctrl_sub_ev_ops
);
1247 static long uvc_ioctl_default(struct file
*file
, void *fh
, bool valid_prio
,
1248 unsigned int cmd
, void *arg
)
1250 struct uvc_fh
*handle
= fh
;
1251 struct uvc_video_chain
*chain
= handle
->chain
;
1254 /* Dynamic controls. */
1255 case UVCIOC_CTRL_MAP
:
1256 return uvc_ioctl_ctrl_map(chain
, arg
);
1258 case UVCIOC_CTRL_QUERY
:
1259 return uvc_xu_ctrl_query(chain
, arg
);
1266 #ifdef CONFIG_COMPAT
1267 struct uvc_xu_control_mapping32
{
1278 compat_caddr_t menu_info
;
1284 static int uvc_v4l2_get_xu_mapping(struct uvc_xu_control_mapping
*kp
,
1285 const struct uvc_xu_control_mapping32 __user
*up
)
1287 struct uvc_xu_control_mapping32
*p
= (void *)kp
;
1288 compat_caddr_t info
;
1291 if (copy_from_user(p
, up
, sizeof(*p
)))
1294 count
= p
->menu_count
;
1295 info
= p
->menu_info
;
1297 memset(kp
->reserved
, 0, sizeof(kp
->reserved
));
1298 kp
->menu_info
= count
? compat_ptr(info
) : NULL
;
1299 kp
->menu_count
= count
;
1303 static int uvc_v4l2_put_xu_mapping(const struct uvc_xu_control_mapping
*kp
,
1304 struct uvc_xu_control_mapping32 __user
*up
)
1306 if (copy_to_user(up
, kp
, offsetof(typeof(*up
), menu_info
)) ||
1307 put_user(kp
->menu_count
, &up
->menu_count
))
1310 if (clear_user(up
->reserved
, sizeof(up
->reserved
)))
1316 struct uvc_xu_control_query32
{
1321 compat_caddr_t data
;
1324 static int uvc_v4l2_get_xu_query(struct uvc_xu_control_query
*kp
,
1325 const struct uvc_xu_control_query32 __user
*up
)
1327 struct uvc_xu_control_query32 v
;
1329 if (copy_from_user(&v
, up
, sizeof(v
)))
1332 *kp
= (struct uvc_xu_control_query
){
1334 .selector
= v
.selector
,
1337 .data
= v
.size
? compat_ptr(v
.data
) : NULL
1342 static int uvc_v4l2_put_xu_query(const struct uvc_xu_control_query
*kp
,
1343 struct uvc_xu_control_query32 __user
*up
)
1345 if (copy_to_user(up
, kp
, offsetof(typeof(*up
), data
)))
1350 #define UVCIOC_CTRL_MAP32 _IOWR('u', 0x20, struct uvc_xu_control_mapping32)
1351 #define UVCIOC_CTRL_QUERY32 _IOWR('u', 0x21, struct uvc_xu_control_query32)
1353 static long uvc_v4l2_compat_ioctl32(struct file
*file
,
1354 unsigned int cmd
, unsigned long arg
)
1356 struct uvc_fh
*handle
= file
->private_data
;
1358 struct uvc_xu_control_mapping xmap
;
1359 struct uvc_xu_control_query xqry
;
1361 void __user
*up
= compat_ptr(arg
);
1365 case UVCIOC_CTRL_MAP32
:
1366 ret
= uvc_v4l2_get_xu_mapping(&karg
.xmap
, up
);
1369 ret
= uvc_ioctl_ctrl_map(handle
->chain
, &karg
.xmap
);
1372 ret
= uvc_v4l2_put_xu_mapping(&karg
.xmap
, up
);
1378 case UVCIOC_CTRL_QUERY32
:
1379 ret
= uvc_v4l2_get_xu_query(&karg
.xqry
, up
);
1382 ret
= uvc_xu_ctrl_query(handle
->chain
, &karg
.xqry
);
1385 ret
= uvc_v4l2_put_xu_query(&karg
.xqry
, up
);
1391 return -ENOIOCTLCMD
;
1398 static ssize_t
uvc_v4l2_read(struct file
*file
, char __user
*data
,
1399 size_t count
, loff_t
*ppos
)
1401 uvc_trace(UVC_TRACE_CALLS
, "uvc_v4l2_read: not implemented.\n");
1405 static int uvc_v4l2_mmap(struct file
*file
, struct vm_area_struct
*vma
)
1407 struct uvc_fh
*handle
= file
->private_data
;
1408 struct uvc_streaming
*stream
= handle
->stream
;
1410 uvc_trace(UVC_TRACE_CALLS
, "uvc_v4l2_mmap\n");
1412 return uvc_queue_mmap(&stream
->queue
, vma
);
1415 static unsigned int uvc_v4l2_poll(struct file
*file
, poll_table
*wait
)
1417 struct uvc_fh
*handle
= file
->private_data
;
1418 struct uvc_streaming
*stream
= handle
->stream
;
1420 uvc_trace(UVC_TRACE_CALLS
, "uvc_v4l2_poll\n");
1422 return uvc_queue_poll(&stream
->queue
, file
, wait
);
1426 static unsigned long uvc_v4l2_get_unmapped_area(struct file
*file
,
1427 unsigned long addr
, unsigned long len
, unsigned long pgoff
,
1428 unsigned long flags
)
1430 struct uvc_fh
*handle
= file
->private_data
;
1431 struct uvc_streaming
*stream
= handle
->stream
;
1433 uvc_trace(UVC_TRACE_CALLS
, "uvc_v4l2_get_unmapped_area\n");
1435 return uvc_queue_get_unmapped_area(&stream
->queue
, pgoff
);
1439 const struct v4l2_ioctl_ops uvc_ioctl_ops
= {
1440 .vidioc_querycap
= uvc_ioctl_querycap
,
1441 .vidioc_enum_fmt_vid_cap
= uvc_ioctl_enum_fmt_vid_cap
,
1442 .vidioc_enum_fmt_vid_out
= uvc_ioctl_enum_fmt_vid_out
,
1443 .vidioc_g_fmt_vid_cap
= uvc_ioctl_g_fmt_vid_cap
,
1444 .vidioc_g_fmt_vid_out
= uvc_ioctl_g_fmt_vid_out
,
1445 .vidioc_s_fmt_vid_cap
= uvc_ioctl_s_fmt_vid_cap
,
1446 .vidioc_s_fmt_vid_out
= uvc_ioctl_s_fmt_vid_out
,
1447 .vidioc_try_fmt_vid_cap
= uvc_ioctl_try_fmt_vid_cap
,
1448 .vidioc_try_fmt_vid_out
= uvc_ioctl_try_fmt_vid_out
,
1449 .vidioc_reqbufs
= uvc_ioctl_reqbufs
,
1450 .vidioc_querybuf
= uvc_ioctl_querybuf
,
1451 .vidioc_qbuf
= uvc_ioctl_qbuf
,
1452 .vidioc_expbuf
= uvc_ioctl_expbuf
,
1453 .vidioc_dqbuf
= uvc_ioctl_dqbuf
,
1454 .vidioc_create_bufs
= uvc_ioctl_create_bufs
,
1455 .vidioc_streamon
= uvc_ioctl_streamon
,
1456 .vidioc_streamoff
= uvc_ioctl_streamoff
,
1457 .vidioc_enum_input
= uvc_ioctl_enum_input
,
1458 .vidioc_g_input
= uvc_ioctl_g_input
,
1459 .vidioc_s_input
= uvc_ioctl_s_input
,
1460 .vidioc_queryctrl
= uvc_ioctl_queryctrl
,
1461 .vidioc_query_ext_ctrl
= uvc_ioctl_query_ext_ctrl
,
1462 .vidioc_g_ctrl
= uvc_ioctl_g_ctrl
,
1463 .vidioc_s_ctrl
= uvc_ioctl_s_ctrl
,
1464 .vidioc_g_ext_ctrls
= uvc_ioctl_g_ext_ctrls
,
1465 .vidioc_s_ext_ctrls
= uvc_ioctl_s_ext_ctrls
,
1466 .vidioc_try_ext_ctrls
= uvc_ioctl_try_ext_ctrls
,
1467 .vidioc_querymenu
= uvc_ioctl_querymenu
,
1468 .vidioc_g_selection
= uvc_ioctl_g_selection
,
1469 .vidioc_g_parm
= uvc_ioctl_g_parm
,
1470 .vidioc_s_parm
= uvc_ioctl_s_parm
,
1471 .vidioc_enum_framesizes
= uvc_ioctl_enum_framesizes
,
1472 .vidioc_enum_frameintervals
= uvc_ioctl_enum_frameintervals
,
1473 .vidioc_subscribe_event
= uvc_ioctl_subscribe_event
,
1474 .vidioc_unsubscribe_event
= v4l2_event_unsubscribe
,
1475 .vidioc_default
= uvc_ioctl_default
,
1478 const struct v4l2_file_operations uvc_fops
= {
1479 .owner
= THIS_MODULE
,
1480 .open
= uvc_v4l2_open
,
1481 .release
= uvc_v4l2_release
,
1482 .unlocked_ioctl
= video_ioctl2
,
1483 #ifdef CONFIG_COMPAT
1484 .compat_ioctl32
= uvc_v4l2_compat_ioctl32
,
1486 .read
= uvc_v4l2_read
,
1487 .mmap
= uvc_v4l2_mmap
,
1488 .poll
= uvc_v4l2_poll
,
1490 .get_unmapped_area
= uvc_v4l2_get_unmapped_area
,