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