?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
Avoid beyond bounds copy while caching ACL
[zen-stable.git] / drivers / media / video / uvc / uvc_v4l2.c
blob2ae4f880ea05ed5bd67bee2a4816fcea7ed464ae
1 /*
2 * uvc_v4l2.c -- USB Video Class driver - V4L2 API
3 *
4 * Copyright (C) 2005-2010
5 * Laurent Pinchart (laurent.pinchart@ideasonboard.com)
6 *
7 * This program is free software; you can redistribute it and/or modify
8 * it under the terms of the GNU General Public License as published by
9 * the Free Software Foundation; either version 2 of the License, or
10 * (at your option) any later version.
11 *
12 */
13
14 #include <linux/kernel.h>
15 #include <linux/version.h>
16 #include <linux/list.h>
17 #include <linux/module.h>
18 #include <linux/slab.h>
19 #include <linux/usb.h>
20 #include <linux/videodev2.h>
21 #include <linux/vmalloc.h>
22 #include <linux/mm.h>
23 #include <linux/wait.h>
24 #include <linux/atomic.h>
25
26 #include <media/v4l2-common.h>
27 #include <media/v4l2-ioctl.h>
28
29 #include "uvcvideo.h"
30
31 /* ------------------------------------------------------------------------
32 * UVC ioctls
33 */
34 static int uvc_ioctl_ctrl_map(struct uvc_video_chain *chain,
35 struct uvc_xu_control_mapping *xmap)
36 {
37 struct uvc_control_mapping *map;
38 unsigned int size;
39 int ret;
40
41 map = kzalloc(sizeof *map, GFP_KERNEL);
42 if (map == NULL)
43 return -ENOMEM;
44
45 map->id = xmap->id;
46 memcpy(map->name, xmap->name, sizeof map->name);
47 memcpy(map->entity, xmap->entity, sizeof map->entity);
48 map->selector = xmap->selector;
49 map->size = xmap->size;
50 map->offset = xmap->offset;
51 map->v4l2_type = xmap->v4l2_type;
52 map->data_type = xmap->data_type;
53
54 switch (xmap->v4l2_type) {
55 case V4L2_CTRL_TYPE_INTEGER:
56 case V4L2_CTRL_TYPE_BOOLEAN:
57 case V4L2_CTRL_TYPE_BUTTON:
58 break;
59
60 case V4L2_CTRL_TYPE_MENU:
61 /* Prevent excessive memory consumption, as well as integer
62 * overflows.
63 */
64 if (xmap->menu_count == 0 ||
65 xmap->menu_count > UVC_MAX_CONTROL_MENU_ENTRIES) {
66 ret = -EINVAL;
67 goto done;
68 }
69
70 size = xmap->menu_count * sizeof(*map->menu_info);
71 map->menu_info = kmalloc(size, GFP_KERNEL);
72 if (map->menu_info == NULL) {
73 ret = -ENOMEM;
74 goto done;
75 }
76
77 if (copy_from_user(map->menu_info, xmap->menu_info, size)) {
78 ret = -EFAULT;
79 goto done;
80 }
81
82 map->menu_count = xmap->menu_count;
83 break;
84
85 default:
86 uvc_trace(UVC_TRACE_CONTROL, "Unsupported V4L2 control type "
87 "%u.\n", xmap->v4l2_type);
88 ret = -ENOTTY;
89 goto done;
90 }
91
92 ret = uvc_ctrl_add_mapping(chain, map);
93
94 done:
95 kfree(map->menu_info);
96 kfree(map);
97
98 return ret;
99 }
100
101 /* ------------------------------------------------------------------------
102 * V4L2 interface
103 */
104
105 /*
106 * Find the frame interval closest to the requested frame interval for the
107 * given frame format and size. This should be done by the device as part of
108 * the Video Probe and Commit negotiation, but some hardware don't implement
109 * that feature.
110 */
111 static __u32 uvc_try_frame_interval(struct uvc_frame *frame, __u32 interval)
112 {
113 unsigned int i;
114
115 if (frame->bFrameIntervalType) {
116 __u32 best = -1, dist;
117
118 for (i = 0; i < frame->bFrameIntervalType; ++i) {
119 dist = interval > frame->dwFrameInterval[i]
120 ? interval - frame->dwFrameInterval[i]
121 : frame->dwFrameInterval[i] - interval;
122
123 if (dist > best)
124 break;
125
126 best = dist;
127 }
128
129 interval = frame->dwFrameInterval[i-1];
130 } else {
131 const __u32 min = frame->dwFrameInterval[0];
132 const __u32 max = frame->dwFrameInterval[1];
133 const __u32 step = frame->dwFrameInterval[2];
134
135 interval = min + (interval - min + step/2) / step * step;
136 if (interval > max)
137 interval = max;
138 }
139
140 return interval;
141 }
142
143 static int uvc_v4l2_try_format(struct uvc_streaming *stream,
144 struct v4l2_format *fmt, struct uvc_streaming_control *probe,
145 struct uvc_format **uvc_format, struct uvc_frame **uvc_frame)
146 {
147 struct uvc_format *format = NULL;
148 struct uvc_frame *frame = NULL;
149 __u16 rw, rh;
150 unsigned int d, maxd;
151 unsigned int i;
152 __u32 interval;
153 int ret = 0;
154 __u8 *fcc;
155
156 if (fmt->type != stream->type)
157 return -EINVAL;
158
159 fcc = (__u8 *)&fmt->fmt.pix.pixelformat;
160 uvc_trace(UVC_TRACE_FORMAT, "Trying format 0x%08x (%c%c%c%c): %ux%u.\n",
161 fmt->fmt.pix.pixelformat,
162 fcc[0], fcc[1], fcc[2], fcc[3],
163 fmt->fmt.pix.width, fmt->fmt.pix.height);
164
165 /* Check if the hardware supports the requested format. */
166 for (i = 0; i < stream->nformats; ++i) {
167 format = &stream->format[i];
168 if (format->fcc == fmt->fmt.pix.pixelformat)
169 break;
170 }
171
172 if (format == NULL || format->fcc != fmt->fmt.pix.pixelformat) {
173 uvc_trace(UVC_TRACE_FORMAT, "Unsupported format 0x%08x.\n",
174 fmt->fmt.pix.pixelformat);
175 return -EINVAL;
176 }
177
178 /* Find the closest image size. The distance between image sizes is
179 * the size in pixels of the non-overlapping regions between the
180 * requested size and the frame-specified size.
181 */
182 rw = fmt->fmt.pix.width;
183 rh = fmt->fmt.pix.height;
184 maxd = (unsigned int)-1;
185
186 for (i = 0; i < format->nframes; ++i) {
187 __u16 w = format->frame[i].wWidth;
188 __u16 h = format->frame[i].wHeight;
189
190 d = min(w, rw) * min(h, rh);
191 d = w*h + rw*rh - 2*d;
192 if (d < maxd) {
193 maxd = d;
194 frame = &format->frame[i];
195 }
196
197 if (maxd == 0)
198 break;
199 }
200
201 if (frame == NULL) {
202 uvc_trace(UVC_TRACE_FORMAT, "Unsupported size %ux%u.\n",
203 fmt->fmt.pix.width, fmt->fmt.pix.height);
204 return -EINVAL;
205 }
206
207 /* Use the default frame interval. */
208 interval = frame->dwDefaultFrameInterval;
209 uvc_trace(UVC_TRACE_FORMAT, "Using default frame interval %u.%u us "
210 "(%u.%u fps).\n", interval/10, interval%10, 10000000/interval,
211 (100000000/interval)%10);
212
213 /* Set the format index, frame index and frame interval. */
214 memset(probe, 0, sizeof *probe);
215 probe->bmHint = 1; /* dwFrameInterval */
216 probe->bFormatIndex = format->index;
217 probe->bFrameIndex = frame->bFrameIndex;
218 probe->dwFrameInterval = uvc_try_frame_interval(frame, interval);
219 /* Some webcams stall the probe control set request when the
220 * dwMaxVideoFrameSize field is set to zero. The UVC specification
221 * clearly states that the field is read-only from the host, so this
222 * is a webcam bug. Set dwMaxVideoFrameSize to the value reported by
223 * the webcam to work around the problem.
224 *
225 * The workaround could probably be enabled for all webcams, so the
226 * quirk can be removed if needed. It's currently useful to detect
227 * webcam bugs and fix them before they hit the market (providing
228 * developers test their webcams with the Linux driver as well as with
229 * the Windows driver).
230 */
231 mutex_lock(&stream->mutex);
232 if (stream->dev->quirks & UVC_QUIRK_PROBE_EXTRAFIELDS)
233 probe->dwMaxVideoFrameSize =
234 stream->ctrl.dwMaxVideoFrameSize;
235
236 /* Probe the device. */
237 ret = uvc_probe_video(stream, probe);
238 mutex_unlock(&stream->mutex);
239 if (ret < 0)
240 goto done;
241
242 fmt->fmt.pix.width = frame->wWidth;
243 fmt->fmt.pix.height = frame->wHeight;
244 fmt->fmt.pix.field = V4L2_FIELD_NONE;
245 fmt->fmt.pix.bytesperline = format->bpp * frame->wWidth / 8;
246 fmt->fmt.pix.sizeimage = probe->dwMaxVideoFrameSize;
247 fmt->fmt.pix.colorspace = format->colorspace;
248 fmt->fmt.pix.priv = 0;
249
250 if (uvc_format != NULL)
251 *uvc_format = format;
252 if (uvc_frame != NULL)
253 *uvc_frame = frame;
254
255 done:
256 return ret;
257 }
258
259 static int uvc_v4l2_get_format(struct uvc_streaming *stream,
260 struct v4l2_format *fmt)
261 {
262 struct uvc_format *format;
263 struct uvc_frame *frame;
264 int ret = 0;
265
266 if (fmt->type != stream->type)
267 return -EINVAL;
268
269 mutex_lock(&stream->mutex);
270 format = stream->cur_format;
271 frame = stream->cur_frame;
272
273 if (format == NULL || frame == NULL) {
274 ret = -EINVAL;
275 goto done;
276 }
277
278 fmt->fmt.pix.pixelformat = format->fcc;
279 fmt->fmt.pix.width = frame->wWidth;
280 fmt->fmt.pix.height = frame->wHeight;
281 fmt->fmt.pix.field = V4L2_FIELD_NONE;
282 fmt->fmt.pix.bytesperline = format->bpp * frame->wWidth / 8;
283 fmt->fmt.pix.sizeimage = stream->ctrl.dwMaxVideoFrameSize;
284 fmt->fmt.pix.colorspace = format->colorspace;
285 fmt->fmt.pix.priv = 0;
286
287 done:
288 mutex_unlock(&stream->mutex);
289 return ret;
290 }
291
292 static int uvc_v4l2_set_format(struct uvc_streaming *stream,
293 struct v4l2_format *fmt)
294 {
295 struct uvc_streaming_control probe;
296 struct uvc_format *format;
297 struct uvc_frame *frame;
298 int ret;
299
300 if (fmt->type != stream->type)
301 return -EINVAL;
302
303 ret = uvc_v4l2_try_format(stream, fmt, &probe, &format, &frame);
304 if (ret < 0)
305 return ret;
306
307 mutex_lock(&stream->mutex);
308
309 if (uvc_queue_allocated(&stream->queue)) {
310 ret = -EBUSY;
311 goto done;
312 }
313
314 memcpy(&stream->ctrl, &probe, sizeof probe);
315 stream->cur_format = format;
316 stream->cur_frame = frame;
317
318 done:
319 mutex_unlock(&stream->mutex);
320 return ret;
321 }
322
323 static int uvc_v4l2_get_streamparm(struct uvc_streaming *stream,
324 struct v4l2_streamparm *parm)
325 {
326 uint32_t numerator, denominator;
327
328 if (parm->type != stream->type)
329 return -EINVAL;
330
331 mutex_lock(&stream->mutex);
332 numerator = stream->ctrl.dwFrameInterval;
333 mutex_unlock(&stream->mutex);
334
335 denominator = 10000000;
336 uvc_simplify_fraction(&numerator, &denominator, 8, 333);
337
338 memset(parm, 0, sizeof *parm);
339 parm->type = stream->type;
340
341 if (stream->type == V4L2_BUF_TYPE_VIDEO_CAPTURE) {
342 parm->parm.capture.capability = V4L2_CAP_TIMEPERFRAME;
343 parm->parm.capture.capturemode = 0;
344 parm->parm.capture.timeperframe.numerator = numerator;
345 parm->parm.capture.timeperframe.denominator = denominator;
346 parm->parm.capture.extendedmode = 0;
347 parm->parm.capture.readbuffers = 0;
348 } else {
349 parm->parm.output.capability = V4L2_CAP_TIMEPERFRAME;
350 parm->parm.output.outputmode = 0;
351 parm->parm.output.timeperframe.numerator = numerator;
352 parm->parm.output.timeperframe.denominator = denominator;
353 }
354
355 return 0;
356 }
357
358 static int uvc_v4l2_set_streamparm(struct uvc_streaming *stream,
359 struct v4l2_streamparm *parm)
360 {
361 struct uvc_streaming_control probe;
362 struct v4l2_fract timeperframe;
363 uint32_t interval;
364 int ret;
365
366 if (parm->type != stream->type)
367 return -EINVAL;
368
369 if (parm->type == V4L2_BUF_TYPE_VIDEO_CAPTURE)
370 timeperframe = parm->parm.capture.timeperframe;
371 else
372 timeperframe = parm->parm.output.timeperframe;
373
374 interval = uvc_fraction_to_interval(timeperframe.numerator,
375 timeperframe.denominator);
376 uvc_trace(UVC_TRACE_FORMAT, "Setting frame interval to %u/%u (%u).\n",
377 timeperframe.numerator, timeperframe.denominator, interval);
378
379 mutex_lock(&stream->mutex);
380
381 if (uvc_queue_streaming(&stream->queue)) {
382 mutex_unlock(&stream->mutex);
383 return -EBUSY;
384 }
385
386 memcpy(&probe, &stream->ctrl, sizeof probe);
387 probe.dwFrameInterval =
388 uvc_try_frame_interval(stream->cur_frame, interval);
389
390 /* Probe the device with the new settings. */
391 ret = uvc_probe_video(stream, &probe);
392 if (ret < 0) {
393 mutex_unlock(&stream->mutex);
394 return ret;
395 }
396
397 memcpy(&stream->ctrl, &probe, sizeof probe);
398 mutex_unlock(&stream->mutex);
399
400 /* Return the actual frame period. */
401 timeperframe.numerator = probe.dwFrameInterval;
402 timeperframe.denominator = 10000000;
403 uvc_simplify_fraction(&timeperframe.numerator,
404 &timeperframe.denominator, 8, 333);
405
406 if (parm->type == V4L2_BUF_TYPE_VIDEO_CAPTURE)
407 parm->parm.capture.timeperframe = timeperframe;
408 else
409 parm->parm.output.timeperframe = timeperframe;
410
411 return 0;
412 }
413
414 /* ------------------------------------------------------------------------
415 * Privilege management
416 */
417
418 /*
419 * Privilege management is the multiple-open implementation basis. The current
420 * implementation is completely transparent for the end-user and doesn't
421 * require explicit use of the VIDIOC_G_PRIORITY and VIDIOC_S_PRIORITY ioctls.
422 * Those ioctls enable finer control on the device (by making possible for a
423 * user to request exclusive access to a device), but are not mature yet.
424 * Switching to the V4L2 priority mechanism might be considered in the future
425 * if this situation changes.
426 *
427 * Each open instance of a UVC device can either be in a privileged or
428 * unprivileged state. Only a single instance can be in a privileged state at
429 * a given time. Trying to perform an operation that requires privileges will
430 * automatically acquire the required privileges if possible, or return -EBUSY
431 * otherwise. Privileges are dismissed when closing the instance or when
432 * freeing the video buffers using VIDIOC_REQBUFS.
433 *
434 * Operations that require privileges are:
435 *
436 * - VIDIOC_S_INPUT
437 * - VIDIOC_S_PARM
438 * - VIDIOC_S_FMT
439 * - VIDIOC_REQBUFS
440 */
441 static int uvc_acquire_privileges(struct uvc_fh *handle)
442 {
443 /* Always succeed if the handle is already privileged. */
444 if (handle->state == UVC_HANDLE_ACTIVE)
445 return 0;
446
447 /* Check if the device already has a privileged handle. */
448 if (atomic_inc_return(&handle->stream->active) != 1) {
449 atomic_dec(&handle->stream->active);
450 return -EBUSY;
451 }
452
453 handle->state = UVC_HANDLE_ACTIVE;
454 return 0;
455 }
456
457 static void uvc_dismiss_privileges(struct uvc_fh *handle)
458 {
459 if (handle->state == UVC_HANDLE_ACTIVE)
460 atomic_dec(&handle->stream->active);
461
462 handle->state = UVC_HANDLE_PASSIVE;
463 }
464
465 static int uvc_has_privileges(struct uvc_fh *handle)
466 {
467 return handle->state == UVC_HANDLE_ACTIVE;
468 }
469
470 /* ------------------------------------------------------------------------
471 * V4L2 file operations
472 */
473
474 static int uvc_v4l2_open(struct file *file)
475 {
476 struct uvc_streaming *stream;
477 struct uvc_fh *handle;
478 int ret = 0;
479
480 uvc_trace(UVC_TRACE_CALLS, "uvc_v4l2_open\n");
481 stream = video_drvdata(file);
482
483 if (stream->dev->state & UVC_DEV_DISCONNECTED)
484 return -ENODEV;
485
486 ret = usb_autopm_get_interface(stream->dev->intf);
487 if (ret < 0)
488 return ret;
489
490 /* Create the device handle. */
491 handle = kzalloc(sizeof *handle, GFP_KERNEL);
492 if (handle == NULL) {
493 usb_autopm_put_interface(stream->dev->intf);
494 return -ENOMEM;
495 }
496
497 if (atomic_inc_return(&stream->dev->users) == 1) {
498 ret = uvc_status_start(stream->dev);
499 if (ret < 0) {
500 usb_autopm_put_interface(stream->dev->intf);
501 atomic_dec(&stream->dev->users);
502 kfree(handle);
503 return ret;
504 }
505 }
506
507 handle->chain = stream->chain;
508 handle->stream = stream;
509 handle->state = UVC_HANDLE_PASSIVE;
510 file->private_data = handle;
511
512 return 0;
513 }
514
515 static int uvc_v4l2_release(struct file *file)
516 {
517 struct uvc_fh *handle = file->private_data;
518 struct uvc_streaming *stream = handle->stream;
519
520 uvc_trace(UVC_TRACE_CALLS, "uvc_v4l2_release\n");
521
522 /* Only free resources if this is a privileged handle. */
523 if (uvc_has_privileges(handle)) {
524 uvc_video_enable(stream, 0);
525 uvc_free_buffers(&stream->queue);
526 }
527
528 /* Release the file handle. */
529 uvc_dismiss_privileges(handle);
530 kfree(handle);
531 file->private_data = NULL;
532
533 if (atomic_dec_return(&stream->dev->users) == 0)
534 uvc_status_stop(stream->dev);
535
536 usb_autopm_put_interface(stream->dev->intf);
537 return 0;
538 }
539
540 static long uvc_v4l2_do_ioctl(struct file *file, unsigned int cmd, void *arg)
541 {
542 struct video_device *vdev = video_devdata(file);
543 struct uvc_fh *handle = file->private_data;
544 struct uvc_video_chain *chain = handle->chain;
545 struct uvc_streaming *stream = handle->stream;
546 long ret = 0;
547
548 switch (cmd) {
549 /* Query capabilities */
550 case VIDIOC_QUERYCAP:
551 {
552 struct v4l2_capability *cap = arg;
553
554 memset(cap, 0, sizeof *cap);
555 strlcpy(cap->driver, "uvcvideo", sizeof cap->driver);
556 strlcpy(cap->card, vdev->name, sizeof cap->card);
557 usb_make_path(stream->dev->udev,
558 cap->bus_info, sizeof(cap->bus_info));
559 cap->version = LINUX_VERSION_CODE;
560 if (stream->type == V4L2_BUF_TYPE_VIDEO_CAPTURE)
561 cap->capabilities = V4L2_CAP_VIDEO_CAPTURE
562 | V4L2_CAP_STREAMING;
563 else
564 cap->capabilities = V4L2_CAP_VIDEO_OUTPUT
565 | V4L2_CAP_STREAMING;
566 break;
567 }
568
569 /* Get, Set & Query control */
570 case VIDIOC_QUERYCTRL:
571 return uvc_query_v4l2_ctrl(chain, arg);
572
573 case VIDIOC_G_CTRL:
574 {
575 struct v4l2_control *ctrl = arg;
576 struct v4l2_ext_control xctrl;
577
578 memset(&xctrl, 0, sizeof xctrl);
579 xctrl.id = ctrl->id;
580
581 ret = uvc_ctrl_begin(chain);
582 if (ret < 0)
583 return ret;
584
585 ret = uvc_ctrl_get(chain, &xctrl);
586 uvc_ctrl_rollback(chain);
587 if (ret >= 0)
588 ctrl->value = xctrl.value;
589 break;
590 }
591
592 case VIDIOC_S_CTRL:
593 {
594 struct v4l2_control *ctrl = arg;
595 struct v4l2_ext_control xctrl;
596
597 memset(&xctrl, 0, sizeof xctrl);
598 xctrl.id = ctrl->id;
599 xctrl.value = ctrl->value;
600
601 ret = uvc_ctrl_begin(chain);
602 if (ret < 0)
603 return ret;
604
605 ret = uvc_ctrl_set(chain, &xctrl);
606 if (ret < 0) {
607 uvc_ctrl_rollback(chain);
608 return ret;
609 }
610 ret = uvc_ctrl_commit(chain);
611 if (ret == 0)
612 ctrl->value = xctrl.value;
613 break;
614 }
615
616 case VIDIOC_QUERYMENU:
617 return uvc_query_v4l2_menu(chain, arg);
618
619 case VIDIOC_G_EXT_CTRLS:
620 {
621 struct v4l2_ext_controls *ctrls = arg;
622 struct v4l2_ext_control *ctrl = ctrls->controls;
623 unsigned int i;
624
625 ret = uvc_ctrl_begin(chain);
626 if (ret < 0)
627 return ret;
628
629 for (i = 0; i < ctrls->count; ++ctrl, ++i) {
630 ret = uvc_ctrl_get(chain, ctrl);
631 if (ret < 0) {
632 uvc_ctrl_rollback(chain);
633 ctrls->error_idx = i;
634 return ret;
635 }
636 }
637 ctrls->error_idx = 0;
638 ret = uvc_ctrl_rollback(chain);
639 break;
640 }
641
642 case VIDIOC_S_EXT_CTRLS:
643 case VIDIOC_TRY_EXT_CTRLS:
644 {
645 struct v4l2_ext_controls *ctrls = arg;
646 struct v4l2_ext_control *ctrl = ctrls->controls;
647 unsigned int i;
648
649 ret = uvc_ctrl_begin(chain);
650 if (ret < 0)
651 return ret;
652
653 for (i = 0; i < ctrls->count; ++ctrl, ++i) {
654 ret = uvc_ctrl_set(chain, ctrl);
655 if (ret < 0) {
656 uvc_ctrl_rollback(chain);
657 ctrls->error_idx = i;
658 return ret;
659 }
660 }
661
662 ctrls->error_idx = 0;
663
664 if (cmd == VIDIOC_S_EXT_CTRLS)
665 ret = uvc_ctrl_commit(chain);
666 else
667 ret = uvc_ctrl_rollback(chain);
668 break;
669 }
670
671 /* Get, Set & Enum input */
672 case VIDIOC_ENUMINPUT:
673 {
674 const struct uvc_entity *selector = chain->selector;
675 struct v4l2_input *input = arg;
676 struct uvc_entity *iterm = NULL;
677 u32 index = input->index;
678 int pin = 0;
679
680 if (selector == NULL ||
681 (chain->dev->quirks & UVC_QUIRK_IGNORE_SELECTOR_UNIT)) {
682 if (index != 0)
683 return -EINVAL;
684 list_for_each_entry(iterm, &chain->entities, chain) {
685 if (UVC_ENTITY_IS_ITERM(iterm))
686 break;
687 }
688 pin = iterm->id;
689 } else if (pin < selector->bNrInPins) {
690 pin = selector->baSourceID[index];
691 list_for_each_entry(iterm, &chain->entities, chain) {
692 if (!UVC_ENTITY_IS_ITERM(iterm))
693 continue;
694 if (iterm->id == pin)
695 break;
696 }
697 }
698
699 if (iterm == NULL || iterm->id != pin)
700 return -EINVAL;
701
702 memset(input, 0, sizeof *input);
703 input->index = index;
704 strlcpy(input->name, iterm->name, sizeof input->name);
705 if (UVC_ENTITY_TYPE(iterm) == UVC_ITT_CAMERA)
706 input->type = V4L2_INPUT_TYPE_CAMERA;
707 break;
708 }
709
710 case VIDIOC_G_INPUT:
711 {
712 u8 input;
713
714 if (chain->selector == NULL ||
715 (chain->dev->quirks & UVC_QUIRK_IGNORE_SELECTOR_UNIT)) {
716 *(int *)arg = 0;
717 break;
718 }
719
720 ret = uvc_query_ctrl(chain->dev, UVC_GET_CUR,
721 chain->selector->id, chain->dev->intfnum,
722 UVC_SU_INPUT_SELECT_CONTROL, &input, 1);
723 if (ret < 0)
724 return ret;
725
726 *(int *)arg = input - 1;
727 break;
728 }
729
730 case VIDIOC_S_INPUT:
731 {
732 u32 input = *(u32 *)arg + 1;
733
734 if ((ret = uvc_acquire_privileges(handle)) < 0)
735 return ret;
736
737 if (chain->selector == NULL ||
738 (chain->dev->quirks & UVC_QUIRK_IGNORE_SELECTOR_UNIT)) {
739 if (input != 1)
740 return -EINVAL;
741 break;
742 }
743
744 if (input == 0 || input > chain->selector->bNrInPins)
745 return -EINVAL;
746
747 return uvc_query_ctrl(chain->dev, UVC_SET_CUR,
748 chain->selector->id, chain->dev->intfnum,
749 UVC_SU_INPUT_SELECT_CONTROL, &input, 1);
750 }
751
752 /* Try, Get, Set & Enum format */
753 case VIDIOC_ENUM_FMT:
754 {
755 struct v4l2_fmtdesc *fmt = arg;
756 struct uvc_format *format;
757 enum v4l2_buf_type type = fmt->type;
758 __u32 index = fmt->index;
759
760 if (fmt->type != stream->type ||
761 fmt->index >= stream->nformats)
762 return -EINVAL;
763
764 memset(fmt, 0, sizeof(*fmt));
765 fmt->index = index;
766 fmt->type = type;
767
768 format = &stream->format[fmt->index];
769 fmt->flags = 0;
770 if (format->flags & UVC_FMT_FLAG_COMPRESSED)
771 fmt->flags |= V4L2_FMT_FLAG_COMPRESSED;
772 strlcpy(fmt->description, format->name,
773 sizeof fmt->description);
774 fmt->description[sizeof fmt->description - 1] = 0;
775 fmt->pixelformat = format->fcc;
776 break;
777 }
778
779 case VIDIOC_TRY_FMT:
780 {
781 struct uvc_streaming_control probe;
782
783 return uvc_v4l2_try_format(stream, arg, &probe, NULL, NULL);
784 }
785
786 case VIDIOC_S_FMT:
787 if ((ret = uvc_acquire_privileges(handle)) < 0)
788 return ret;
789
790 return uvc_v4l2_set_format(stream, arg);
791
792 case VIDIOC_G_FMT:
793 return uvc_v4l2_get_format(stream, arg);
794
795 /* Frame size enumeration */
796 case VIDIOC_ENUM_FRAMESIZES:
797 {
798 struct v4l2_frmsizeenum *fsize = arg;
799 struct uvc_format *format = NULL;
800 struct uvc_frame *frame;
801 int i;
802
803 /* Look for the given pixel format */
804 for (i = 0; i < stream->nformats; i++) {
805 if (stream->format[i].fcc ==
806 fsize->pixel_format) {
807 format = &stream->format[i];
808 break;
809 }
810 }
811 if (format == NULL)
812 return -EINVAL;
813
814 if (fsize->index >= format->nframes)
815 return -EINVAL;
816
817 frame = &format->frame[fsize->index];
818 fsize->type = V4L2_FRMSIZE_TYPE_DISCRETE;
819 fsize->discrete.width = frame->wWidth;
820 fsize->discrete.height = frame->wHeight;
821 break;
822 }
823
824 /* Frame interval enumeration */
825 case VIDIOC_ENUM_FRAMEINTERVALS:
826 {
827 struct v4l2_frmivalenum *fival = arg;
828 struct uvc_format *format = NULL;
829 struct uvc_frame *frame = NULL;
830 int i;
831
832 /* Look for the given pixel format and frame size */
833 for (i = 0; i < stream->nformats; i++) {
834 if (stream->format[i].fcc ==
835 fival->pixel_format) {
836 format = &stream->format[i];
837 break;
838 }
839 }
840 if (format == NULL)
841 return -EINVAL;
842
843 for (i = 0; i < format->nframes; i++) {
844 if (format->frame[i].wWidth == fival->width &&
845 format->frame[i].wHeight == fival->height) {
846 frame = &format->frame[i];
847 break;
848 }
849 }
850 if (frame == NULL)
851 return -EINVAL;
852
853 if (frame->bFrameIntervalType) {
854 if (fival->index >= frame->bFrameIntervalType)
855 return -EINVAL;
856
857 fival->type = V4L2_FRMIVAL_TYPE_DISCRETE;
858 fival->discrete.numerator =
859 frame->dwFrameInterval[fival->index];
860 fival->discrete.denominator = 10000000;
861 uvc_simplify_fraction(&fival->discrete.numerator,
862 &fival->discrete.denominator, 8, 333);
863 } else {
864 fival->type = V4L2_FRMIVAL_TYPE_STEPWISE;
865 fival->stepwise.min.numerator =
866 frame->dwFrameInterval[0];
867 fival->stepwise.min.denominator = 10000000;
868 fival->stepwise.max.numerator =
869 frame->dwFrameInterval[1];
870 fival->stepwise.max.denominator = 10000000;
871 fival->stepwise.step.numerator =
872 frame->dwFrameInterval[2];
873 fival->stepwise.step.denominator = 10000000;
874 uvc_simplify_fraction(&fival->stepwise.min.numerator,
875 &fival->stepwise.min.denominator, 8, 333);
876 uvc_simplify_fraction(&fival->stepwise.max.numerator,
877 &fival->stepwise.max.denominator, 8, 333);
878 uvc_simplify_fraction(&fival->stepwise.step.numerator,
879 &fival->stepwise.step.denominator, 8, 333);
880 }
881 break;
882 }
883
884 /* Get & Set streaming parameters */
885 case VIDIOC_G_PARM:
886 return uvc_v4l2_get_streamparm(stream, arg);
887
888 case VIDIOC_S_PARM:
889 if ((ret = uvc_acquire_privileges(handle)) < 0)
890 return ret;
891
892 return uvc_v4l2_set_streamparm(stream, arg);
893
894 /* Cropping and scaling */
895 case VIDIOC_CROPCAP:
896 {
897 struct v4l2_cropcap *ccap = arg;
898
899 if (ccap->type != stream->type)
900 return -EINVAL;
901
902 ccap->bounds.left = 0;
903 ccap->bounds.top = 0;
904
905 mutex_lock(&stream->mutex);
906 ccap->bounds.width = stream->cur_frame->wWidth;
907 ccap->bounds.height = stream->cur_frame->wHeight;
908 mutex_unlock(&stream->mutex);
909
910 ccap->defrect = ccap->bounds;
911
912 ccap->pixelaspect.numerator = 1;
913 ccap->pixelaspect.denominator = 1;
914 break;
915 }
916
917 case VIDIOC_G_CROP:
918 case VIDIOC_S_CROP:
919 return -EINVAL;
920
921 /* Buffers & streaming */
922 case VIDIOC_REQBUFS:
923 if ((ret = uvc_acquire_privileges(handle)) < 0)
924 return ret;
925
926 mutex_lock(&stream->mutex);
927 ret = uvc_alloc_buffers(&stream->queue, arg);
928 mutex_unlock(&stream->mutex);
929 if (ret < 0)
930 return ret;
931
932 if (ret == 0)
933 uvc_dismiss_privileges(handle);
934
935 ret = 0;
936 break;
937
938 case VIDIOC_QUERYBUF:
939 {
940 struct v4l2_buffer *buf = arg;
941
942 if (!uvc_has_privileges(handle))
943 return -EBUSY;
944
945 return uvc_query_buffer(&stream->queue, buf);
946 }
947
948 case VIDIOC_QBUF:
949 if (!uvc_has_privileges(handle))
950 return -EBUSY;
951
952 return uvc_queue_buffer(&stream->queue, arg);
953
954 case VIDIOC_DQBUF:
955 if (!uvc_has_privileges(handle))
956 return -EBUSY;
957
958 return uvc_dequeue_buffer(&stream->queue, arg,
959 file->f_flags & O_NONBLOCK);
960
961 case VIDIOC_STREAMON:
962 {
963 int *type = arg;
964
965 if (*type != stream->type)
966 return -EINVAL;
967
968 if (!uvc_has_privileges(handle))
969 return -EBUSY;
970
971 mutex_lock(&stream->mutex);
972 ret = uvc_video_enable(stream, 1);
973 mutex_unlock(&stream->mutex);
974 if (ret < 0)
975 return ret;
976 break;
977 }
978
979 case VIDIOC_STREAMOFF:
980 {
981 int *type = arg;
982
983 if (*type != stream->type)
984 return -EINVAL;
985
986 if (!uvc_has_privileges(handle))
987 return -EBUSY;
988
989 return uvc_video_enable(stream, 0);
990 }
991
992 /* Analog video standards make no sense for digital cameras. */
993 case VIDIOC_ENUMSTD:
994 case VIDIOC_QUERYSTD:
995 case VIDIOC_G_STD:
996 case VIDIOC_S_STD:
997
998 case VIDIOC_OVERLAY:
999
1000 case VIDIOC_ENUMAUDIO:
1001 case VIDIOC_ENUMAUDOUT:
1002
1003 case VIDIOC_ENUMOUTPUT:
1004 uvc_trace(UVC_TRACE_IOCTL, "Unsupported ioctl 0x%08x\n", cmd);
1005 return -EINVAL;
1006
1007 case UVCIOC_CTRL_MAP:
1008 return uvc_ioctl_ctrl_map(chain, arg);
1009
1010 case UVCIOC_CTRL_QUERY:
1011 return uvc_xu_ctrl_query(chain, arg);
1012
1013 default:
1014 uvc_trace(UVC_TRACE_IOCTL, "Unknown ioctl 0x%08x\n", cmd);
1015 return -EINVAL;
1016 }
1017
1018 return ret;
1019 }
1020
1021 static long uvc_v4l2_ioctl(struct file *file,
1022 unsigned int cmd, unsigned long arg)
1023 {
1024 if (uvc_trace_param & UVC_TRACE_IOCTL) {
1025 uvc_printk(KERN_DEBUG, "uvc_v4l2_ioctl(");
1026 v4l_printk_ioctl(cmd);
1027 printk(")\n");
1028 }
1029
1030 return video_usercopy(file, cmd, arg, uvc_v4l2_do_ioctl);
1031 }
1032
1033 static ssize_t uvc_v4l2_read(struct file *file, char __user *data,
1034 size_t count, loff_t *ppos)
1035 {
1036 uvc_trace(UVC_TRACE_CALLS, "uvc_v4l2_read: not implemented.\n");
1037 return -EINVAL;
1038 }
1039
1040 static int uvc_v4l2_mmap(struct file *file, struct vm_area_struct *vma)
1041 {
1042 struct uvc_fh *handle = file->private_data;
1043 struct uvc_streaming *stream = handle->stream;
1044
1045 uvc_trace(UVC_TRACE_CALLS, "uvc_v4l2_mmap\n");
1046
1047 return uvc_queue_mmap(&stream->queue, vma);
1048 }
1049
1050 static unsigned int uvc_v4l2_poll(struct file *file, poll_table *wait)
1051 {
1052 struct uvc_fh *handle = file->private_data;
1053 struct uvc_streaming *stream = handle->stream;
1054
1055 uvc_trace(UVC_TRACE_CALLS, "uvc_v4l2_poll\n");
1056
1057 return uvc_queue_poll(&stream->queue, file, wait);
1058 }
1059
1060 #ifndef CONFIG_MMU
1061 static unsigned long uvc_v4l2_get_unmapped_area(struct file *file,
1062 unsigned long addr, unsigned long len, unsigned long pgoff,
1063 unsigned long flags)
1064 {
1065 struct uvc_fh *handle = file->private_data;
1066 struct uvc_streaming *stream = handle->stream;
1067
1068 uvc_trace(UVC_TRACE_CALLS, "uvc_v4l2_get_unmapped_area\n");
1069
1070 return uvc_queue_get_unmapped_area(&stream->queue, pgoff);
1071 }
1072 #endif
1073
1074 const struct v4l2_file_operations uvc_fops = {
1075 .owner = THIS_MODULE,
1076 .open = uvc_v4l2_open,
1077 .release = uvc_v4l2_release,
1078 .unlocked_ioctl = uvc_v4l2_ioctl,
1079 .read = uvc_v4l2_read,
1080 .mmap = uvc_v4l2_mmap,
1081 .poll = uvc_v4l2_poll,
1082 #ifndef CONFIG_MMU
1083 .get_unmapped_area = uvc_v4l2_get_unmapped_area,
1084 #endif
1085 };
1086