drivers/usb/gadget/function/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/videodev2.h>
  15 #include <linux/vmalloc.h>
  16 #include <linux/wait.h>
  17
  18 #include <media/v4l2-dev.h>
  19 #include <media/v4l2-event.h>
  20 #include <media/v4l2-ioctl.h>
  21
  22 #include "f_uvc.h"
  23 #include "uvc.h"
  24 #include "uvc_queue.h"
  25 #include "uvc_video.h"
  26 #include "uvc_v4l2.h"
  27
  28 /* --------------------------------------------------------------------------
  29  * Requests handling
  30  */
  31
  32 static int
  33 uvc_send_response(struct uvc_device *uvc, struct uvc_request_data *data)
  34 {
  35         struct usb_composite_dev *cdev = uvc->func.config->cdev;
  36         struct usb_request *req = uvc->control_req;
  37
  38         if (data->length < 0)
  39                 return usb_ep_set_halt(cdev->gadget->ep0);
  40
  41         req->length = min_t(unsigned int, uvc->event_length, data->length);
  42         req->zero = data->length < uvc->event_length;
  43
  44         memcpy(req->buf, data->data, req->length);
  45
  46         return usb_ep_queue(cdev->gadget->ep0, req, GFP_KERNEL);
  47 }
  48
  49 /* --------------------------------------------------------------------------
  50  * V4L2 ioctls
  51  */
  52
  53 struct uvc_format {
  54         u8 bpp;
  55         u32 fcc;
  56 };
  57
  58 static struct uvc_format uvc_formats[] = {
  59         { 16, V4L2_PIX_FMT_YUYV  },
  60         { 0,  V4L2_PIX_FMT_MJPEG },
  61 };
  62
  63 static int
  64 uvc_v4l2_querycap(struct file *file, void *fh, struct v4l2_capability *cap)
  65 {
  66         struct video_device *vdev = video_devdata(file);
  67         struct uvc_device *uvc = video_get_drvdata(vdev);
  68         struct usb_composite_dev *cdev = uvc->func.config->cdev;
  69
  70         strlcpy(cap->driver, "g_uvc", sizeof(cap->driver));
  71         strlcpy(cap->card, cdev->gadget->name, sizeof(cap->card));
  72         strlcpy(cap->bus_info, dev_name(&cdev->gadget->dev),
  73                 sizeof(cap->bus_info));
  74         return 0;
  75 }
  76
  77 static int
  78 uvc_v4l2_get_format(struct file *file, void *fh, struct v4l2_format *fmt)
  79 {
  80         struct video_device *vdev = video_devdata(file);
  81         struct uvc_device *uvc = video_get_drvdata(vdev);
  82         struct uvc_video *video = &uvc->video;
  83
  84         fmt->fmt.pix.pixelformat = video->fcc;
  85         fmt->fmt.pix.width = video->width;
  86         fmt->fmt.pix.height = video->height;
  87         fmt->fmt.pix.field = V4L2_FIELD_NONE;
  88         fmt->fmt.pix.bytesperline = video->bpp * video->width / 8;
  89         fmt->fmt.pix.sizeimage = video->imagesize;
  90         fmt->fmt.pix.colorspace = V4L2_COLORSPACE_SRGB;
  91         fmt->fmt.pix.priv = 0;
  92
  93         return 0;
  94 }
  95
  96 static int
  97 uvc_v4l2_set_format(struct file *file, void *fh, struct v4l2_format *fmt)
  98 {
  99         struct video_device *vdev = video_devdata(file);
 100         struct uvc_device *uvc = video_get_drvdata(vdev);
 101         struct uvc_video *video = &uvc->video;
 102         struct uvc_format *format;
 103         unsigned int imagesize;
 104         unsigned int bpl;
 105         unsigned int i;
 106
 107         for (i = 0; i < ARRAY_SIZE(uvc_formats); ++i) {
 108                 format = &uvc_formats[i];
 109                 if (format->fcc == fmt->fmt.pix.pixelformat)
 110                         break;
 111         }
 112
 113         if (i == ARRAY_SIZE(uvc_formats)) {
 114                 uvcg_info(&uvc->func, "Unsupported format 0x%08x.\n",
 115                           fmt->fmt.pix.pixelformat);
 116                 return -EINVAL;
 117         }
 118
 119         bpl = format->bpp * fmt->fmt.pix.width / 8;
 120         imagesize = bpl ? bpl * fmt->fmt.pix.height : fmt->fmt.pix.sizeimage;
 121
 122         video->fcc = format->fcc;
 123         video->bpp = format->bpp;
 124         video->width = fmt->fmt.pix.width;
 125         video->height = fmt->fmt.pix.height;
 126         video->imagesize = imagesize;
 127
 128         fmt->fmt.pix.field = V4L2_FIELD_NONE;
 129         fmt->fmt.pix.bytesperline = bpl;
 130         fmt->fmt.pix.sizeimage = imagesize;
 131         fmt->fmt.pix.colorspace = V4L2_COLORSPACE_SRGB;
 132         fmt->fmt.pix.priv = 0;
 133
 134         return 0;
 135 }
 136
 137 static int
 138 uvc_v4l2_reqbufs(struct file *file, void *fh, struct v4l2_requestbuffers *b)
 139 {
 140         struct video_device *vdev = video_devdata(file);
 141         struct uvc_device *uvc = video_get_drvdata(vdev);
 142         struct uvc_video *video = &uvc->video;
 143
 144         if (b->type != video->queue.queue.type)
 145                 return -EINVAL;
 146
 147         return uvcg_alloc_buffers(&video->queue, b);
 148 }
 149
 150 static int
 151 uvc_v4l2_querybuf(struct file *file, void *fh, struct v4l2_buffer *b)
 152 {
 153         struct video_device *vdev = video_devdata(file);
 154         struct uvc_device *uvc = video_get_drvdata(vdev);
 155         struct uvc_video *video = &uvc->video;
 156
 157         return uvcg_query_buffer(&video->queue, b);
 158 }
 159
 160 static int
 161 uvc_v4l2_qbuf(struct file *file, void *fh, struct v4l2_buffer *b)
 162 {
 163         struct video_device *vdev = video_devdata(file);
 164         struct uvc_device *uvc = video_get_drvdata(vdev);
 165         struct uvc_video *video = &uvc->video;
 166         int ret;
 167
 168         ret = uvcg_queue_buffer(&video->queue, b);
 169         if (ret < 0)
 170                 return ret;
 171
 172         if (uvc->state == UVC_STATE_STREAMING)
 173                 schedule_work(&video->pump);
 174
 175         return ret;
 176 }
 177
 178 static int
 179 uvc_v4l2_dqbuf(struct file *file, void *fh, struct v4l2_buffer *b)
 180 {
 181         struct video_device *vdev = video_devdata(file);
 182         struct uvc_device *uvc = video_get_drvdata(vdev);
 183         struct uvc_video *video = &uvc->video;
 184
 185         return uvcg_dequeue_buffer(&video->queue, b, file->f_flags & O_NONBLOCK);
 186 }
 187
 188 static int
 189 uvc_v4l2_streamon(struct file *file, void *fh, enum v4l2_buf_type type)
 190 {
 191         struct video_device *vdev = video_devdata(file);
 192         struct uvc_device *uvc = video_get_drvdata(vdev);
 193         struct uvc_video *video = &uvc->video;
 194         int ret;
 195
 196         if (type != video->queue.queue.type)
 197                 return -EINVAL;
 198
 199         /* Enable UVC video. */
 200         ret = uvcg_video_enable(video, 1);
 201         if (ret < 0)
 202                 return ret;
 203
 204         /*
 205          * Complete the alternate setting selection setup phase now that
 206          * userspace is ready to provide video frames.
 207          */
 208         uvc_function_setup_continue(uvc);
 209         uvc->state = UVC_STATE_STREAMING;
 210
 211         return 0;
 212 }
 213
 214 static int
 215 uvc_v4l2_streamoff(struct file *file, void *fh, enum v4l2_buf_type type)
 216 {
 217         struct video_device *vdev = video_devdata(file);
 218         struct uvc_device *uvc = video_get_drvdata(vdev);
 219         struct uvc_video *video = &uvc->video;
 220
 221         if (type != video->queue.queue.type)
 222                 return -EINVAL;
 223
 224         return uvcg_video_enable(video, 0);
 225 }
 226
 227 static int
 228 uvc_v4l2_subscribe_event(struct v4l2_fh *fh,
 229                          const struct v4l2_event_subscription *sub)
 230 {
 231         struct uvc_device *uvc = video_get_drvdata(fh->vdev);
 232         struct uvc_file_handle *handle = to_uvc_file_handle(fh);
 233         int ret;
 234
 235         if (sub->type < UVC_EVENT_FIRST || sub->type > UVC_EVENT_LAST)
 236                 return -EINVAL;
 237
 238         if (sub->type == UVC_EVENT_SETUP && uvc->func_connected)
 239                 return -EBUSY;
 240
 241         ret = v4l2_event_subscribe(fh, sub, 2, NULL);
 242         if (ret < 0)
 243                 return ret;
 244
 245         if (sub->type == UVC_EVENT_SETUP) {
 246                 uvc->func_connected = true;
 247                 handle->is_uvc_app_handle = true;
 248                 uvc_function_connect(uvc);
 249         }
 250
 251         return 0;
 252 }
 253
 254 static void uvc_v4l2_disable(struct uvc_device *uvc)
 255 {
 256         uvc->func_connected = false;
 257         uvc_function_disconnect(uvc);
 258         uvcg_video_enable(&uvc->video, 0);
 259         uvcg_free_buffers(&uvc->video.queue);
 260 }
 261
 262 static int
 263 uvc_v4l2_unsubscribe_event(struct v4l2_fh *fh,
 264                            const struct v4l2_event_subscription *sub)
 265 {
 266         struct uvc_device *uvc = video_get_drvdata(fh->vdev);
 267         struct uvc_file_handle *handle = to_uvc_file_handle(fh);
 268         int ret;
 269
 270         ret = v4l2_event_unsubscribe(fh, sub);
 271         if (ret < 0)
 272                 return ret;
 273
 274         if (sub->type == UVC_EVENT_SETUP && handle->is_uvc_app_handle) {
 275                 uvc_v4l2_disable(uvc);
 276                 handle->is_uvc_app_handle = false;
 277         }
 278
 279         return 0;
 280 }
 281
 282 static long
 283 uvc_v4l2_ioctl_default(struct file *file, void *fh, bool valid_prio,
 284                        unsigned int cmd, void *arg)
 285 {
 286         struct video_device *vdev = video_devdata(file);
 287         struct uvc_device *uvc = video_get_drvdata(vdev);
 288
 289         switch (cmd) {
 290         case UVCIOC_SEND_RESPONSE:
 291                 return uvc_send_response(uvc, arg);
 292
 293         default:
 294                 return -ENOIOCTLCMD;
 295         }
 296 }
 297
 298 const struct v4l2_ioctl_ops uvc_v4l2_ioctl_ops = {
 299         .vidioc_querycap = uvc_v4l2_querycap,
 300         .vidioc_g_fmt_vid_out = uvc_v4l2_get_format,
 301         .vidioc_s_fmt_vid_out = uvc_v4l2_set_format,
 302         .vidioc_reqbufs = uvc_v4l2_reqbufs,
 303         .vidioc_querybuf = uvc_v4l2_querybuf,
 304         .vidioc_qbuf = uvc_v4l2_qbuf,
 305         .vidioc_dqbuf = uvc_v4l2_dqbuf,
 306         .vidioc_streamon = uvc_v4l2_streamon,
 307         .vidioc_streamoff = uvc_v4l2_streamoff,
 308         .vidioc_subscribe_event = uvc_v4l2_subscribe_event,
 309         .vidioc_unsubscribe_event = uvc_v4l2_unsubscribe_event,
 310         .vidioc_default = uvc_v4l2_ioctl_default,
 311 };
 312
 313 /* --------------------------------------------------------------------------
 314  * V4L2
 315  */
 316
 317 static int
 318 uvc_v4l2_open(struct file *file)
 319 {
 320         struct video_device *vdev = video_devdata(file);
 321         struct uvc_device *uvc = video_get_drvdata(vdev);
 322         struct uvc_file_handle *handle;
 323
 324         handle = kzalloc(sizeof(*handle), GFP_KERNEL);
 325         if (handle == NULL)
 326                 return -ENOMEM;
 327
 328         v4l2_fh_init(&handle->vfh, vdev);
 329         v4l2_fh_add(&handle->vfh);
 330
 331         handle->device = &uvc->video;
 332         file->private_data = &handle->vfh;
 333
 334         return 0;
 335 }
 336
 337 static int
 338 uvc_v4l2_release(struct file *file)
 339 {
 340         struct video_device *vdev = video_devdata(file);
 341         struct uvc_device *uvc = video_get_drvdata(vdev);
 342         struct uvc_file_handle *handle = to_uvc_file_handle(file->private_data);
 343         struct uvc_video *video = handle->device;
 344
 345         mutex_lock(&video->mutex);
 346         if (handle->is_uvc_app_handle)
 347                 uvc_v4l2_disable(uvc);
 348         mutex_unlock(&video->mutex);
 349
 350         file->private_data = NULL;
 351         v4l2_fh_del(&handle->vfh);
 352         v4l2_fh_exit(&handle->vfh);
 353         kfree(handle);
 354
 355         return 0;
 356 }
 357
 358 static int
 359 uvc_v4l2_mmap(struct file *file, struct vm_area_struct *vma)
 360 {
 361         struct video_device *vdev = video_devdata(file);
 362         struct uvc_device *uvc = video_get_drvdata(vdev);
 363
 364         return uvcg_queue_mmap(&uvc->video.queue, vma);
 365 }
 366
 367 static __poll_t
 368 uvc_v4l2_poll(struct file *file, poll_table *wait)
 369 {
 370         struct video_device *vdev = video_devdata(file);
 371         struct uvc_device *uvc = video_get_drvdata(vdev);
 372
 373         return uvcg_queue_poll(&uvc->video.queue, file, wait);
 374 }
 375
 376 #ifndef CONFIG_MMU
 377 static unsigned long uvcg_v4l2_get_unmapped_area(struct file *file,
 378                 unsigned long addr, unsigned long len, unsigned long pgoff,
 379                 unsigned long flags)
 380 {
 381         struct video_device *vdev = video_devdata(file);
 382         struct uvc_device *uvc = video_get_drvdata(vdev);
 383
 384         return uvcg_queue_get_unmapped_area(&uvc->video.queue, pgoff);
 385 }
 386 #endif
 387
 388 const struct v4l2_file_operations uvc_v4l2_fops = {
 389         .owner          = THIS_MODULE,
 390         .open           = uvc_v4l2_open,
 391         .release        = uvc_v4l2_release,
 392         .unlocked_ioctl = video_ioctl2,
 393         .mmap           = uvc_v4l2_mmap,
 394         .poll           = uvc_v4l2_poll,
 395 #ifndef CONFIG_MMU
 396         .get_unmapped_area = uvcg_v4l2_get_unmapped_area,
 397 #endif
 398 };
 399