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 ([email protected])
   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
  75         cap->device_caps = V4L2_CAP_VIDEO_OUTPUT | V4L2_CAP_STREAMING;
  76         cap->capabilities = cap->device_caps | V4L2_CAP_DEVICE_CAPS;
  77
  78         return 0;
  79 }
  80
  81 static int
  82 uvc_v4l2_get_format(struct file *file, void *fh, struct v4l2_format *fmt)
  83 {
  84         struct video_device *vdev = video_devdata(file);
  85         struct uvc_device *uvc = video_get_drvdata(vdev);
  86         struct uvc_video *video = &uvc->video;
  87
  88         fmt->fmt.pix.pixelformat = video->fcc;
  89         fmt->fmt.pix.width = video->width;
  90         fmt->fmt.pix.height = video->height;
  91         fmt->fmt.pix.field = V4L2_FIELD_NONE;
  92         fmt->fmt.pix.bytesperline = video->bpp * video->width / 8;
  93         fmt->fmt.pix.sizeimage = video->imagesize;
  94         fmt->fmt.pix.colorspace = V4L2_COLORSPACE_SRGB;
  95         fmt->fmt.pix.priv = 0;
  96
  97         return 0;
  98 }
  99
 100 static int
 101 uvc_v4l2_set_format(struct file *file, void *fh, struct v4l2_format *fmt)
 102 {
 103         struct video_device *vdev = video_devdata(file);
 104         struct uvc_device *uvc = video_get_drvdata(vdev);
 105         struct uvc_video *video = &uvc->video;
 106         struct uvc_format *format;
 107         unsigned int imagesize;
 108         unsigned int bpl;
 109         unsigned int i;
 110
 111         for (i = 0; i < ARRAY_SIZE(uvc_formats); ++i) {
 112                 format = &uvc_formats[i];
 113                 if (format->fcc == fmt->fmt.pix.pixelformat)
 114                         break;
 115         }
 116
 117         if (i == ARRAY_SIZE(uvc_formats)) {
 118                 uvcg_info(&uvc->func, "Unsupported format 0x%08x.\n",
 119                           fmt->fmt.pix.pixelformat);
 120                 return -EINVAL;
 121         }
 122
 123         bpl = format->bpp * fmt->fmt.pix.width / 8;
 124         imagesize = bpl ? bpl * fmt->fmt.pix.height : fmt->fmt.pix.sizeimage;
 125
 126         video->fcc = format->fcc;
 127         video->bpp = format->bpp;
 128         video->width = fmt->fmt.pix.width;
 129         video->height = fmt->fmt.pix.height;
 130         video->imagesize = imagesize;
 131
 132         fmt->fmt.pix.field = V4L2_FIELD_NONE;
 133         fmt->fmt.pix.bytesperline = bpl;
 134         fmt->fmt.pix.sizeimage = imagesize;
 135         fmt->fmt.pix.colorspace = V4L2_COLORSPACE_SRGB;
 136         fmt->fmt.pix.priv = 0;
 137
 138         return 0;
 139 }
 140
 141 static int
 142 uvc_v4l2_reqbufs(struct file *file, void *fh, struct v4l2_requestbuffers *b)
 143 {
 144         struct video_device *vdev = video_devdata(file);
 145         struct uvc_device *uvc = video_get_drvdata(vdev);
 146         struct uvc_video *video = &uvc->video;
 147
 148         if (b->type != video->queue.queue.type)
 149                 return -EINVAL;
 150
 151         return uvcg_alloc_buffers(&video->queue, b);
 152 }
 153
 154 static int
 155 uvc_v4l2_querybuf(struct file *file, void *fh, struct v4l2_buffer *b)
 156 {
 157         struct video_device *vdev = video_devdata(file);
 158         struct uvc_device *uvc = video_get_drvdata(vdev);
 159         struct uvc_video *video = &uvc->video;
 160
 161         return uvcg_query_buffer(&video->queue, b);
 162 }
 163
 164 static int
 165 uvc_v4l2_qbuf(struct file *file, void *fh, struct v4l2_buffer *b)
 166 {
 167         struct video_device *vdev = video_devdata(file);
 168         struct uvc_device *uvc = video_get_drvdata(vdev);
 169         struct uvc_video *video = &uvc->video;
 170         int ret;
 171
 172         ret = uvcg_queue_buffer(&video->queue, b);
 173         if (ret < 0)
 174                 return ret;
 175
 176         return uvcg_video_pump(video);
 177 }
 178
 179 static int
 180 uvc_v4l2_dqbuf(struct file *file, void *fh, struct v4l2_buffer *b)
 181 {
 182         struct video_device *vdev = video_devdata(file);
 183         struct uvc_device *uvc = video_get_drvdata(vdev);
 184         struct uvc_video *video = &uvc->video;
 185
 186         return uvcg_dequeue_buffer(&video->queue, b, file->f_flags & O_NONBLOCK);
 187 }
 188
 189 static int
 190 uvc_v4l2_streamon(struct file *file, void *fh, enum v4l2_buf_type type)
 191 {
 192         struct video_device *vdev = video_devdata(file);
 193         struct uvc_device *uvc = video_get_drvdata(vdev);
 194         struct uvc_video *video = &uvc->video;
 195         int ret;
 196
 197         if (type != video->queue.queue.type)
 198                 return -EINVAL;
 199
 200         /* Enable UVC video. */
 201         ret = uvcg_video_enable(video, 1);
 202         if (ret < 0)
 203                 return ret;
 204
 205         /*
 206          * Complete the alternate setting selection setup phase now that
 207          * userspace is ready to provide video frames.
 208          */
 209         uvc_function_setup_continue(uvc);
 210         uvc->state = UVC_STATE_STREAMING;
 211
 212         return 0;
 213 }
 214
 215 static int
 216 uvc_v4l2_streamoff(struct file *file, void *fh, enum v4l2_buf_type type)
 217 {
 218         struct video_device *vdev = video_devdata(file);
 219         struct uvc_device *uvc = video_get_drvdata(vdev);
 220         struct uvc_video *video = &uvc->video;
 221
 222         if (type != video->queue.queue.type)
 223                 return -EINVAL;
 224
 225         return uvcg_video_enable(video, 0);
 226 }
 227
 228 static int
 229 uvc_v4l2_subscribe_event(struct v4l2_fh *fh,
 230                          const struct v4l2_event_subscription *sub)
 231 {
 232         if (sub->type < UVC_EVENT_FIRST || sub->type > UVC_EVENT_LAST)
 233                 return -EINVAL;
 234
 235         return v4l2_event_subscribe(fh, sub, 2, NULL);
 236 }
 237
 238 static int
 239 uvc_v4l2_unsubscribe_event(struct v4l2_fh *fh,
 240                            const struct v4l2_event_subscription *sub)
 241 {
 242         return v4l2_event_unsubscribe(fh, sub);
 243 }
 244
 245 static long
 246 uvc_v4l2_ioctl_default(struct file *file, void *fh, bool valid_prio,
 247                        unsigned int cmd, void *arg)
 248 {
 249         struct video_device *vdev = video_devdata(file);
 250         struct uvc_device *uvc = video_get_drvdata(vdev);
 251
 252         switch (cmd) {
 253         case UVCIOC_SEND_RESPONSE:
 254                 return uvc_send_response(uvc, arg);
 255
 256         default:
 257                 return -ENOIOCTLCMD;
 258         }
 259 }
 260
 261 const struct v4l2_ioctl_ops uvc_v4l2_ioctl_ops = {
 262         .vidioc_querycap = uvc_v4l2_querycap,
 263         .vidioc_g_fmt_vid_out = uvc_v4l2_get_format,
 264         .vidioc_s_fmt_vid_out = uvc_v4l2_set_format,
 265         .vidioc_reqbufs = uvc_v4l2_reqbufs,
 266         .vidioc_querybuf = uvc_v4l2_querybuf,
 267         .vidioc_qbuf = uvc_v4l2_qbuf,
 268         .vidioc_dqbuf = uvc_v4l2_dqbuf,
 269         .vidioc_streamon = uvc_v4l2_streamon,
 270         .vidioc_streamoff = uvc_v4l2_streamoff,
 271         .vidioc_subscribe_event = uvc_v4l2_subscribe_event,
 272         .vidioc_unsubscribe_event = uvc_v4l2_unsubscribe_event,
 273         .vidioc_default = uvc_v4l2_ioctl_default,
 274 };
 275
 276 /* --------------------------------------------------------------------------
 277  * V4L2
 278  */
 279
 280 static int
 281 uvc_v4l2_open(struct file *file)
 282 {
 283         struct video_device *vdev = video_devdata(file);
 284         struct uvc_device *uvc = video_get_drvdata(vdev);
 285         struct uvc_file_handle *handle;
 286
 287         handle = kzalloc(sizeof(*handle), GFP_KERNEL);
 288         if (handle == NULL)
 289                 return -ENOMEM;
 290
 291         v4l2_fh_init(&handle->vfh, vdev);
 292         v4l2_fh_add(&handle->vfh);
 293
 294         handle->device = &uvc->video;
 295         file->private_data = &handle->vfh;
 296
 297         uvc_function_connect(uvc);
 298         return 0;
 299 }
 300
 301 static int
 302 uvc_v4l2_release(struct file *file)
 303 {
 304         struct video_device *vdev = video_devdata(file);
 305         struct uvc_device *uvc = video_get_drvdata(vdev);
 306         struct uvc_file_handle *handle = to_uvc_file_handle(file->private_data);
 307         struct uvc_video *video = handle->device;
 308
 309         uvc_function_disconnect(uvc);
 310
 311         mutex_lock(&video->mutex);
 312         uvcg_video_enable(video, 0);
 313         uvcg_free_buffers(&video->queue);
 314         mutex_unlock(&video->mutex);
 315
 316         file->private_data = NULL;
 317         v4l2_fh_del(&handle->vfh);
 318         v4l2_fh_exit(&handle->vfh);
 319         kfree(handle);
 320
 321         return 0;
 322 }
 323
 324 static int
 325 uvc_v4l2_mmap(struct file *file, struct vm_area_struct *vma)
 326 {
 327         struct video_device *vdev = video_devdata(file);
 328         struct uvc_device *uvc = video_get_drvdata(vdev);
 329
 330         return uvcg_queue_mmap(&uvc->video.queue, vma);
 331 }
 332
 333 static __poll_t
 334 uvc_v4l2_poll(struct file *file, poll_table *wait)
 335 {
 336         struct video_device *vdev = video_devdata(file);
 337         struct uvc_device *uvc = video_get_drvdata(vdev);
 338
 339         return uvcg_queue_poll(&uvc->video.queue, file, wait);
 340 }
 341
 342 #ifndef CONFIG_MMU
 343 static unsigned long uvcg_v4l2_get_unmapped_area(struct file *file,
 344                 unsigned long addr, unsigned long len, unsigned long pgoff,
 345                 unsigned long flags)
 346 {
 347         struct video_device *vdev = video_devdata(file);
 348         struct uvc_device *uvc = video_get_drvdata(vdev);
 349
 350         return uvcg_queue_get_unmapped_area(&uvc->video.queue, pgoff);
 351 }
 352 #endif
 353
 354 const struct v4l2_file_operations uvc_v4l2_fops = {
 355         .owner          = THIS_MODULE,
 356         .open           = uvc_v4l2_open,
 357         .release        = uvc_v4l2_release,
 358         .unlocked_ioctl = video_ioctl2,
 359         .mmap           = uvc_v4l2_mmap,
 360         .poll           = uvc_v4l2_poll,
 361 #ifndef CONFIG_MMU
 362         .get_unmapped_area = uvcg_v4l2_get_unmapped_area,
 363 #endif
 364 };
 365