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 30 static 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 60 static 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 76 static 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 85 static 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 102 static 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 124 static 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 145 static 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 193 static int 194 uvc_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 214 static int 215 uvc_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 228 static int 229 uvc_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 247 static int 248 uvc_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 305 static int 306 uvc_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 326 static 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 353 static 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 376 static int 377 uvc_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 415 static int 416 uvc_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 442 static int 443 uvc_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 466 static int 467 uvc_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 479 static int 480 uvc_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 489 static int 490 uvc_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 507 static int 508 uvc_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 517 static int 518 uvc_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 543 static int 544 uvc_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 566 static int 567 uvc_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 595 static 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 605 static int 606 uvc_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 625 static long 626 uvc_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 641 const 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 666 static int 667 uvc_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_obj(*handle); 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 685 static int 686 uvc_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 705 static int 706 uvc_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 714 static __poll_t 715 uvc_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 724 static 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 735 const 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 }; 746