uvc_v4l2.c

  1// SPDX-License-Identifier: GPL-2.0+
  2/*
  3 *	uvc_v4l2.c  --  USB Video Class Gadget driver
  4 *
  5 *	Copyright (C) 2009-2010
  6 *	    Laurent Pinchart (laurent.pinchart@ideasonboard.com)
  7 */
  8
  9#include <linux/device.h>
 10#include <linux/errno.h>
 11#include <linux/kernel.h>
 12#include <linux/list.h>
 13#include <linux/usb/g_uvc.h>
 14#include <linux/usb/uvc.h>
 15#include <linux/videodev2.h>
 16#include <linux/vmalloc.h>
 17#include <linux/wait.h>
 18
 19#include <media/v4l2-dev.h>
 20#include <media/v4l2-event.h>
 21#include <media/v4l2-ioctl.h>
 22
 23#include "f_uvc.h"
 24#include "uvc.h"
 25#include "uvc_queue.h"
 26#include "uvc_video.h"
 27#include "uvc_v4l2.h"
 28#include "uvc_configfs.h"
 29
 30static const struct uvc_format_desc *to_uvc_format(struct uvcg_format *uformat)
 31{
 32	char guid[16] = UVC_GUID_FORMAT_MJPEG;
 33	const struct uvc_format_desc *format;
 34
 35	if (uformat->type == UVCG_UNCOMPRESSED) {
 36		struct uvcg_uncompressed *unc;
 37
 38		unc = to_uvcg_uncompressed(&uformat->group.cg_item);
 39		if (!unc)
 40			return ERR_PTR(-EINVAL);
 41
 42		memcpy(guid, unc->desc.guidFormat, sizeof(guid));
 43	} else if (uformat->type == UVCG_FRAMEBASED) {
 44		struct uvcg_framebased *unc;
 45
 46		unc = to_uvcg_framebased(&uformat->group.cg_item);
 47		if (!unc)
 48			return ERR_PTR(-EINVAL);
 49
 50		memcpy(guid, unc->desc.guidFormat, sizeof(guid));
 51	}
 52
 53	format = uvc_format_by_guid(guid);
 54	if (!format)
 55		return ERR_PTR(-EINVAL);
 56
 57	return format;
 58}
 59
 60static int uvc_v4l2_get_bytesperline(struct uvcg_format *uformat,
 61			      struct uvcg_frame *uframe)
 62{
 63	struct uvcg_uncompressed *u;
 64
 65	if (uformat->type == UVCG_UNCOMPRESSED) {
 66		u = to_uvcg_uncompressed(&uformat->group.cg_item);
 67		if (!u)
 68			return 0;
 69
 70		return u->desc.bBitsPerPixel * uframe->frame.w_width / 8;
 71	}
 72
 73	return 0;
 74}
 75
 76static int uvc_get_frame_size(struct uvcg_format *uformat,
 77		       struct uvcg_frame *uframe)
 78{
 79	unsigned int bpl = uvc_v4l2_get_bytesperline(uformat, uframe);
 80
 81	return bpl ? bpl * uframe->frame.w_height :
 82		uframe->frame.dw_max_video_frame_buffer_size;
 83}
 84
 85static struct uvcg_format *find_format_by_index(struct uvc_device *uvc, int index)
 86{
 87	struct uvcg_format_ptr *format;
 88	struct uvcg_format *uformat = NULL;
 89	int i = 1;
 90
 91	list_for_each_entry(format, &uvc->header->formats, entry) {
 92		if (index == i) {
 93			uformat = format->fmt;
 94			break;
 95		}
 96		i++;
 97	}
 98
 99	return uformat;
100}
101
102static struct uvcg_frame *find_frame_by_index(struct uvc_device *uvc,
103				       struct uvcg_format *uformat,
104				       int index)
105{
106	struct uvcg_format_ptr *format;
107	struct uvcg_frame_ptr *frame;
108	struct uvcg_frame *uframe = NULL;
109
110	list_for_each_entry(format, &uvc->header->formats, entry) {
111		if (format->fmt->type != uformat->type)
112			continue;
113		list_for_each_entry(frame, &format->fmt->frames, entry) {
114			if (index == frame->frm->frame.b_frame_index) {
115				uframe = frame->frm;
116				break;
117			}
118		}
119	}
120
121	return uframe;
122}
123
124static struct uvcg_format *find_format_by_pix(struct uvc_device *uvc,
125					      u32 pixelformat)
126{
127	struct uvcg_format_ptr *format;
128	struct uvcg_format *uformat = NULL;
129
130	list_for_each_entry(format, &uvc->header->formats, entry) {
131		const struct uvc_format_desc *fmtdesc = to_uvc_format(format->fmt);
132
133		if (IS_ERR(fmtdesc))
134			continue;
135
136		if (fmtdesc->fcc == pixelformat) {
137			uformat = format->fmt;
138			break;
139		}
140	}
141
142	return uformat;
143}
144
145static struct uvcg_frame *find_closest_frame_by_size(struct uvc_device *uvc,
146					   struct uvcg_format *uformat,
147					   u16 rw, u16 rh)
148{
149	struct uvc_video *video = &uvc->video;
150	struct uvcg_format_ptr *format;
151	struct uvcg_frame_ptr *frame;
152	struct uvcg_frame *uframe = NULL;
153	unsigned int d, maxd;
154
155	/* Find the closest image size. The distance between image sizes is
156	 * the size in pixels of the non-overlapping regions between the
157	 * requested size and the frame-specified size.
158	 */
159	maxd = (unsigned int)-1;
160
161	list_for_each_entry(format, &uvc->header->formats, entry) {
162		if (format->fmt->type != uformat->type)
163			continue;
164
165		list_for_each_entry(frame, &format->fmt->frames, entry) {
166			u16 w, h;
167
168			w = frame->frm->frame.w_width;
169			h = frame->frm->frame.w_height;
170
171			d = min(w, rw) * min(h, rh);
172			d = w*h + rw*rh - 2*d;
173			if (d < maxd) {
174				maxd = d;
175				uframe = frame->frm;
176			}
177
178			if (maxd == 0)
179				break;
180		}
181	}
182
183	if (!uframe)
184		uvcg_dbg(&video->uvc->func, "Unsupported size %ux%u\n", rw, rh);
185
186	return uframe;
187}
188
189/* --------------------------------------------------------------------------
190 * Requests handling
191 */
192
193static int
194uvc_send_response(struct uvc_device *uvc, struct uvc_request_data *data)
195{
196	struct usb_composite_dev *cdev = uvc->func.config->cdev;
197	struct usb_request *req = uvc->control_req;
198
199	if (data->length < 0)
200		return usb_ep_set_halt(cdev->gadget->ep0);
201
202	req->length = min_t(unsigned int, uvc->event_length, data->length);
203	req->zero = data->length < uvc->event_length;
204
205	memcpy(req->buf, data->data, req->length);
206
207	return usb_ep_queue(cdev->gadget->ep0, req, GFP_KERNEL);
208}
209
210/* --------------------------------------------------------------------------
211 * V4L2 ioctls
212 */
213
214static int
215uvc_v4l2_querycap(struct file *file, void *fh, struct v4l2_capability *cap)
216{
217	struct video_device *vdev = video_devdata(file);
218	struct uvc_device *uvc = video_get_drvdata(vdev);
219	struct usb_composite_dev *cdev = uvc->func.config->cdev;
220
221	strscpy(cap->driver, "g_uvc", sizeof(cap->driver));
222	strscpy(cap->card, cdev->gadget->name, sizeof(cap->card));
223	strscpy(cap->bus_info, dev_name(&cdev->gadget->dev),
224		sizeof(cap->bus_info));
225	return 0;
226}
227
228static int
229uvc_v4l2_get_format(struct file *file, void *fh, struct v4l2_format *fmt)
230{
231	struct video_device *vdev = video_devdata(file);
232	struct uvc_device *uvc = video_get_drvdata(vdev);
233	struct uvc_video *video = &uvc->video;
234
235	fmt->fmt.pix.pixelformat = video->fcc;
236	fmt->fmt.pix.width = video->width;
237	fmt->fmt.pix.height = video->height;
238	fmt->fmt.pix.field = V4L2_FIELD_NONE;
239	fmt->fmt.pix.bytesperline = video->bpp * video->width / 8;
240	fmt->fmt.pix.sizeimage = video->imagesize;
241	fmt->fmt.pix.colorspace = V4L2_COLORSPACE_SRGB;
242	fmt->fmt.pix.priv = 0;
243
244	return 0;
245}
246
247static int
248uvc_v4l2_try_format(struct file *file, void *fh, struct v4l2_format *fmt)
249{
250	struct video_device *vdev = video_devdata(file);
251	struct uvc_device *uvc = video_get_drvdata(vdev);
252	struct uvc_video *video = &uvc->video;
253	struct uvcg_format *uformat;
254	struct uvcg_frame *uframe;
255	const struct uvc_format_desc *fmtdesc;
256	u8 *fcc;
257
258	if (fmt->type != video->queue.queue.type)
259		return -EINVAL;
260
261	fcc = (u8 *)&fmt->fmt.pix.pixelformat;
262	uvcg_dbg(&uvc->func, "Trying format 0x%08x (%c%c%c%c): %ux%u\n",
263		fmt->fmt.pix.pixelformat,
264		fcc[0], fcc[1], fcc[2], fcc[3],
265		fmt->fmt.pix.width, fmt->fmt.pix.height);
266
267	uformat = find_format_by_pix(uvc, fmt->fmt.pix.pixelformat);
268	if (!uformat)
269		return -EINVAL;
270
271	uframe = find_closest_frame_by_size(uvc, uformat,
272				fmt->fmt.pix.width, fmt->fmt.pix.height);
273	if (!uframe)
274		return -EINVAL;
275
276	if (uformat->type == UVCG_UNCOMPRESSED) {
277		struct uvcg_uncompressed *u =
278			to_uvcg_uncompressed(&uformat->group.cg_item);
279		if (!u)
280			return 0;
281
282		v4l2_fill_pixfmt(&fmt->fmt.pix, fmt->fmt.pix.pixelformat,
283				 uframe->frame.w_width, uframe->frame.w_height);
284
285		if (fmt->fmt.pix.sizeimage != (uvc_v4l2_get_bytesperline(uformat, uframe) *
286						uframe->frame.w_height))
287			return -EINVAL;
288	} else {
289		fmt->fmt.pix.width = uframe->frame.w_width;
290		fmt->fmt.pix.height = uframe->frame.w_height;
291		fmt->fmt.pix.bytesperline = uvc_v4l2_get_bytesperline(uformat, uframe);
292		fmt->fmt.pix.sizeimage = uvc_get_frame_size(uformat, uframe);
293		fmtdesc = to_uvc_format(uformat);
294		if (IS_ERR(fmtdesc))
295			return PTR_ERR(fmtdesc);
296		fmt->fmt.pix.pixelformat = fmtdesc->fcc;
297	}
298	fmt->fmt.pix.field = V4L2_FIELD_NONE;
299	fmt->fmt.pix.colorspace = V4L2_COLORSPACE_SRGB;
300	fmt->fmt.pix.priv = 0;
301
302	return 0;
303}
304
305static int
306uvc_v4l2_set_format(struct file *file, void *fh, struct v4l2_format *fmt)
307{
308	struct video_device *vdev = video_devdata(file);
309	struct uvc_device *uvc = video_get_drvdata(vdev);
310	struct uvc_video *video = &uvc->video;
311	int ret;
312
313	ret = uvc_v4l2_try_format(file, fh, fmt);
314	if (ret)
315		return ret;
316
317	video->fcc = fmt->fmt.pix.pixelformat;
318	video->bpp = fmt->fmt.pix.bytesperline * 8 / video->width;
319	video->width = fmt->fmt.pix.width;
320	video->height = fmt->fmt.pix.height;
321	video->imagesize = fmt->fmt.pix.sizeimage;
322
323	return ret;
324}
325
326static int uvc_v4l2_g_parm(struct file *file, void *fh,
327			   struct v4l2_streamparm *parm)
328{
329	struct video_device *vdev = video_devdata(file);
330	struct uvc_device *uvc = video_get_drvdata(vdev);
331	struct uvc_video *video = &uvc->video;
332	struct v4l2_fract timeperframe;
333
334	if (!V4L2_TYPE_IS_OUTPUT(parm->type))
335		return -EINVAL;
336
337	/* Return the actual frame period. */
338	timeperframe.numerator = video->interval;
339	timeperframe.denominator = 10000000;
340	v4l2_simplify_fraction(&timeperframe.numerator,
341			       &timeperframe.denominator, 8, 333);
342
343	uvcg_dbg(&uvc->func, "Getting frame interval of %u/%u (%u)\n",
344		 timeperframe.numerator, timeperframe.denominator,
345		 video->interval);
346
347	parm->parm.output.timeperframe = timeperframe;
348	parm->parm.output.capability = V4L2_CAP_TIMEPERFRAME;
349
350	return 0;
351}
352
353static int uvc_v4l2_s_parm(struct file *file, void *fh,
354			   struct v4l2_streamparm *parm)
355{
356	struct video_device *vdev = video_devdata(file);
357	struct uvc_device *uvc = video_get_drvdata(vdev);
358	struct uvc_video *video = &uvc->video;
359	struct v4l2_fract timeperframe;
360
361	if (!V4L2_TYPE_IS_OUTPUT(parm->type))
362		return -EINVAL;
363
364	timeperframe = parm->parm.output.timeperframe;
365
366	video->interval = v4l2_fraction_to_interval(timeperframe.numerator,
367						    timeperframe.denominator);
368
369	uvcg_dbg(&uvc->func, "Setting frame interval to %u/%u (%u)\n",
370		 timeperframe.numerator, timeperframe.denominator,
371		 video->interval);
372
373	return 0;
374}
375
376static int
377uvc_v4l2_enum_frameintervals(struct file *file, void *fh,
378		struct v4l2_frmivalenum *fival)
379{
380	struct video_device *vdev = video_devdata(file);
381	struct uvc_device *uvc = video_get_drvdata(vdev);
382	struct uvcg_format *uformat = NULL;
383	struct uvcg_frame *uframe = NULL;
384	struct uvcg_frame_ptr *frame;
385
386	uformat = find_format_by_pix(uvc, fival->pixel_format);
387	if (!uformat)
388		return -EINVAL;
389
390	list_for_each_entry(frame, &uformat->frames, entry) {
391		if (frame->frm->frame.w_width == fival->width &&
392		    frame->frm->frame.w_height == fival->height) {
393			uframe = frame->frm;
394			break;
395		}
396	}
397	if (!uframe)
398		return -EINVAL;
399
400	if (fival->index >= uframe->frame.b_frame_interval_type)
401		return -EINVAL;
402
403	fival->discrete.numerator =
404		uframe->dw_frame_interval[fival->index];
405
406	/* TODO: handle V4L2_FRMIVAL_TYPE_STEPWISE */
407	fival->type = V4L2_FRMIVAL_TYPE_DISCRETE;
408	fival->discrete.denominator = 10000000;
409	v4l2_simplify_fraction(&fival->discrete.numerator,
410		&fival->discrete.denominator, 8, 333);
411
412	return 0;
413}
414
415static int
416uvc_v4l2_enum_framesizes(struct file *file, void *fh,
417		struct v4l2_frmsizeenum *fsize)
418{
419	struct video_device *vdev = video_devdata(file);
420	struct uvc_device *uvc = video_get_drvdata(vdev);
421	struct uvcg_format *uformat = NULL;
422	struct uvcg_frame *uframe = NULL;
423
424	uformat = find_format_by_pix(uvc, fsize->pixel_format);
425	if (!uformat)
426		return -EINVAL;
427
428	if (fsize->index >= uformat->num_frames)
429		return -EINVAL;
430
431	uframe = find_frame_by_index(uvc, uformat, fsize->index + 1);
432	if (!uframe)
433		return -EINVAL;
434
435	fsize->type = V4L2_FRMSIZE_TYPE_DISCRETE;
436	fsize->discrete.width = uframe->frame.w_width;
437	fsize->discrete.height = uframe->frame.w_height;
438
439	return 0;
440}
441
442static int
443uvc_v4l2_enum_format(struct file *file, void *fh, struct v4l2_fmtdesc *f)
444{
445	struct video_device *vdev = video_devdata(file);
446	struct uvc_device *uvc = video_get_drvdata(vdev);
447	const struct uvc_format_desc *fmtdesc;
448	struct uvcg_format *uformat;
449
450	if (f->index >= uvc->header->num_fmt)
451		return -EINVAL;
452
453	uformat = find_format_by_index(uvc, f->index + 1);
454	if (!uformat)
455		return -EINVAL;
456
457	fmtdesc = to_uvc_format(uformat);
458	if (IS_ERR(fmtdesc))
459		return PTR_ERR(fmtdesc);
460
461	f->pixelformat = fmtdesc->fcc;
462
463	return 0;
464}
465
466static int
467uvc_v4l2_reqbufs(struct file *file, void *fh, struct v4l2_requestbuffers *b)
468{
469	struct video_device *vdev = video_devdata(file);
470	struct uvc_device *uvc = video_get_drvdata(vdev);
471	struct uvc_video *video = &uvc->video;
472
473	if (b->type != video->queue.queue.type)
474		return -EINVAL;
475
476	return uvcg_alloc_buffers(&video->queue, b);
477}
478
479static int
480uvc_v4l2_querybuf(struct file *file, void *fh, struct v4l2_buffer *b)
481{
482	struct video_device *vdev = video_devdata(file);
483	struct uvc_device *uvc = video_get_drvdata(vdev);
484	struct uvc_video *video = &uvc->video;
485
486	return uvcg_query_buffer(&video->queue, b);
487}
488
489static int
490uvc_v4l2_qbuf(struct file *file, void *fh, struct v4l2_buffer *b)
491{
492	struct video_device *vdev = video_devdata(file);
493	struct uvc_device *uvc = video_get_drvdata(vdev);
494	struct uvc_video *video = &uvc->video;
495	int ret;
496
497	ret = uvcg_queue_buffer(&video->queue, b);
498	if (ret < 0)
499		return ret;
500
501	if (uvc->state == UVC_STATE_STREAMING)
502		queue_work(video->async_wq, &video->pump);
503
504	return ret;
505}
506
507static int
508uvc_v4l2_dqbuf(struct file *file, void *fh, struct v4l2_buffer *b)
509{
510	struct video_device *vdev = video_devdata(file);
511	struct uvc_device *uvc = video_get_drvdata(vdev);
512	struct uvc_video *video = &uvc->video;
513
514	return uvcg_dequeue_buffer(&video->queue, b, file->f_flags & O_NONBLOCK);
515}
516
517static int
518uvc_v4l2_streamon(struct file *file, void *fh, enum v4l2_buf_type type)
519{
520	struct video_device *vdev = video_devdata(file);
521	struct uvc_device *uvc = video_get_drvdata(vdev);
522	struct uvc_video *video = &uvc->video;
523	int ret;
524
525	if (type != video->queue.queue.type)
526		return -EINVAL;
527
528	/* Enable UVC video. */
529	ret = uvcg_video_enable(video);
530	if (ret < 0)
531		return ret;
532
533	/*
534	 * Complete the alternate setting selection setup phase now that
535	 * userspace is ready to provide video frames.
536	 */
537	uvc_function_setup_continue(uvc, 0);
538	uvc->state = UVC_STATE_STREAMING;
539
540	return 0;
541}
542
543static int
544uvc_v4l2_streamoff(struct file *file, void *fh, enum v4l2_buf_type type)
545{
546	struct video_device *vdev = video_devdata(file);
547	struct uvc_device *uvc = video_get_drvdata(vdev);
548	struct uvc_video *video = &uvc->video;
549	int ret = 0;
550
551	if (type != video->queue.queue.type)
552		return -EINVAL;
553
554	ret = uvcg_video_disable(video);
555	if (ret < 0)
556		return ret;
557
558	if (uvc->state != UVC_STATE_STREAMING)
559		return 0;
560
561	uvc->state = UVC_STATE_CONNECTED;
562	uvc_function_setup_continue(uvc, 1);
563	return 0;
564}
565
566static int
567uvc_v4l2_subscribe_event(struct v4l2_fh *fh,
568			 const struct v4l2_event_subscription *sub)
569{
570	struct uvc_device *uvc = video_get_drvdata(fh->vdev);
571	struct uvc_file_handle *handle = to_uvc_file_handle(fh);
572	int ret;
573
574	if (sub->type < UVC_EVENT_FIRST || sub->type > UVC_EVENT_LAST)
575		return -EINVAL;
576
577	guard(mutex)(&uvc->lock);
578
579	if (sub->type == UVC_EVENT_SETUP && uvc->func_connected)
580		return -EBUSY;
581
582	ret = v4l2_event_subscribe(fh, sub, 2, NULL);
583	if (ret < 0)
584		return ret;
585
586	if (sub->type == UVC_EVENT_SETUP) {
587		uvc->func_connected = true;
588		handle->is_uvc_app_handle = true;
589		uvc_function_connect(uvc);
590	}
591
592	return 0;
593}
594
595static void uvc_v4l2_disable(struct uvc_device *uvc)
596{
597	uvc_function_disconnect(uvc);
598	uvcg_video_disable(&uvc->video);
599	uvcg_free_buffers(&uvc->video.queue);
600	scoped_guard(mutex, &uvc->lock)
601		uvc->func_connected = false;
602	wake_up_interruptible(&uvc->func_connected_queue);
603}
604
605static int
606uvc_v4l2_unsubscribe_event(struct v4l2_fh *fh,
607			   const struct v4l2_event_subscription *sub)
608{
609	struct uvc_device *uvc = video_get_drvdata(fh->vdev);
610	struct uvc_file_handle *handle = to_uvc_file_handle(fh);
611	int ret;
612
613	ret = v4l2_event_unsubscribe(fh, sub);
614	if (ret < 0)
615		return ret;
616
617	if (sub->type == UVC_EVENT_SETUP && handle->is_uvc_app_handle) {
618		uvc_v4l2_disable(uvc);
619		handle->is_uvc_app_handle = false;
620	}
621
622	return 0;
623}
624
625static long
626uvc_v4l2_ioctl_default(struct file *file, void *fh, bool valid_prio,
627		       unsigned int cmd, void *arg)
628{
629	struct video_device *vdev = video_devdata(file);
630	struct uvc_device *uvc = video_get_drvdata(vdev);
631
632	switch (cmd) {
633	case UVCIOC_SEND_RESPONSE:
634		return uvc_send_response(uvc, arg);
635
636	default:
637		return -ENOIOCTLCMD;
638	}
639}
640
641const struct v4l2_ioctl_ops uvc_v4l2_ioctl_ops = {
642	.vidioc_querycap = uvc_v4l2_querycap,
643	.vidioc_try_fmt_vid_out = uvc_v4l2_try_format,
644	.vidioc_g_fmt_vid_out = uvc_v4l2_get_format,
645	.vidioc_s_fmt_vid_out = uvc_v4l2_set_format,
646	.vidioc_enum_frameintervals = uvc_v4l2_enum_frameintervals,
647	.vidioc_enum_framesizes = uvc_v4l2_enum_framesizes,
648	.vidioc_enum_fmt_vid_out = uvc_v4l2_enum_format,
649	.vidioc_reqbufs = uvc_v4l2_reqbufs,
650	.vidioc_querybuf = uvc_v4l2_querybuf,
651	.vidioc_qbuf = uvc_v4l2_qbuf,
652	.vidioc_dqbuf = uvc_v4l2_dqbuf,
653	.vidioc_streamon = uvc_v4l2_streamon,
654	.vidioc_streamoff = uvc_v4l2_streamoff,
655	.vidioc_s_parm = uvc_v4l2_s_parm,
656	.vidioc_g_parm = uvc_v4l2_g_parm,
657	.vidioc_subscribe_event = uvc_v4l2_subscribe_event,
658	.vidioc_unsubscribe_event = uvc_v4l2_unsubscribe_event,
659	.vidioc_default = uvc_v4l2_ioctl_default,
660};
661
662/* --------------------------------------------------------------------------
663 * V4L2
664 */
665
666static int
667uvc_v4l2_open(struct file *file)
668{
669	struct video_device *vdev = video_devdata(file);
670	struct uvc_device *uvc = video_get_drvdata(vdev);
671	struct uvc_file_handle *handle;
672
673	handle = kzalloc(sizeof(*handle), GFP_KERNEL);
674	if (handle == NULL)
675		return -ENOMEM;
676
677	v4l2_fh_init(&handle->vfh, vdev);
678	v4l2_fh_add(&handle->vfh, file);
679
680	handle->device = &uvc->video;
681
682	return 0;
683}
684
685static int
686uvc_v4l2_release(struct file *file)
687{
688	struct video_device *vdev = video_devdata(file);
689	struct uvc_device *uvc = video_get_drvdata(vdev);
690	struct uvc_file_handle *handle = file_to_uvc_file_handle(file);
691	struct uvc_video *video = handle->device;
692
693	mutex_lock(&video->mutex);
694	if (handle->is_uvc_app_handle)
695		uvc_v4l2_disable(uvc);
696	mutex_unlock(&video->mutex);
697
698	v4l2_fh_del(&handle->vfh, file);
699	v4l2_fh_exit(&handle->vfh);
700	kfree(handle);
701
702	return 0;
703}
704
705static int
706uvc_v4l2_mmap(struct file *file, struct vm_area_struct *vma)
707{
708	struct video_device *vdev = video_devdata(file);
709	struct uvc_device *uvc = video_get_drvdata(vdev);
710
711	return uvcg_queue_mmap(&uvc->video.queue, vma);
712}
713
714static __poll_t
715uvc_v4l2_poll(struct file *file, poll_table *wait)
716{
717	struct video_device *vdev = video_devdata(file);
718	struct uvc_device *uvc = video_get_drvdata(vdev);
719
720	return uvcg_queue_poll(&uvc->video.queue, file, wait);
721}
722
723#ifndef CONFIG_MMU
724static unsigned long uvcg_v4l2_get_unmapped_area(struct file *file,
725		unsigned long addr, unsigned long len, unsigned long pgoff,
726		unsigned long flags)
727{
728	struct video_device *vdev = video_devdata(file);
729	struct uvc_device *uvc = video_get_drvdata(vdev);
730
731	return uvcg_queue_get_unmapped_area(&uvc->video.queue, pgoff);
732}
733#endif
734
735const struct v4l2_file_operations uvc_v4l2_fops = {
736	.owner		= THIS_MODULE,
737	.open		= uvc_v4l2_open,
738	.release	= uvc_v4l2_release,
739	.unlocked_ioctl	= video_ioctl2,
740	.mmap		= uvc_v4l2_mmap,
741	.poll		= uvc_v4l2_poll,
742#ifndef CONFIG_MMU
743	.get_unmapped_area = uvcg_v4l2_get_unmapped_area,
744#endif
745};