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_function_disconnect(uvc); 257 uvcg_video_enable(&uvc->video, 0); 258 uvcg_free_buffers(&uvc->video.queue); 259 uvc->func_connected = false; 260 wake_up_interruptible(&uvc->func_connected_queue); 261 } 262 263 static int 264 uvc_v4l2_unsubscribe_event(struct v4l2_fh *fh, 265 const struct v4l2_event_subscription *sub) 266 { 267 struct uvc_device *uvc = video_get_drvdata(fh->vdev); 268 struct uvc_file_handle *handle = to_uvc_file_handle(fh); 269 int ret; 270 271 ret = v4l2_event_unsubscribe(fh, sub); 272 if (ret < 0) 273 return ret; 274 275 if (sub->type == UVC_EVENT_SETUP && handle->is_uvc_app_handle) { 276 uvc_v4l2_disable(uvc); 277 handle->is_uvc_app_handle = false; 278 } 279 280 return 0; 281 } 282 283 static long 284 uvc_v4l2_ioctl_default(struct file *file, void *fh, bool valid_prio, 285 unsigned int cmd, void *arg) 286 { 287 struct video_device *vdev = video_devdata(file); 288 struct uvc_device *uvc = video_get_drvdata(vdev); 289 290 switch (cmd) { 291 case UVCIOC_SEND_RESPONSE: 292 return uvc_send_response(uvc, arg); 293 294 default: 295 return -ENOIOCTLCMD; 296 } 297 } 298 299 const struct v4l2_ioctl_ops uvc_v4l2_ioctl_ops = { 300 .vidioc_querycap = uvc_v4l2_querycap, 301 .vidioc_g_fmt_vid_out = uvc_v4l2_get_format, 302 .vidioc_s_fmt_vid_out = uvc_v4l2_set_format, 303 .vidioc_reqbufs = uvc_v4l2_reqbufs, 304 .vidioc_querybuf = uvc_v4l2_querybuf, 305 .vidioc_qbuf = uvc_v4l2_qbuf, 306 .vidioc_dqbuf = uvc_v4l2_dqbuf, 307 .vidioc_streamon = uvc_v4l2_streamon, 308 .vidioc_streamoff = uvc_v4l2_streamoff, 309 .vidioc_subscribe_event = uvc_v4l2_subscribe_event, 310 .vidioc_unsubscribe_event = uvc_v4l2_unsubscribe_event, 311 .vidioc_default = uvc_v4l2_ioctl_default, 312 }; 313 314 /* -------------------------------------------------------------------------- 315 * V4L2 316 */ 317 318 static int 319 uvc_v4l2_open(struct file *file) 320 { 321 struct video_device *vdev = video_devdata(file); 322 struct uvc_device *uvc = video_get_drvdata(vdev); 323 struct uvc_file_handle *handle; 324 325 handle = kzalloc(sizeof(*handle), GFP_KERNEL); 326 if (handle == NULL) 327 return -ENOMEM; 328 329 v4l2_fh_init(&handle->vfh, vdev); 330 v4l2_fh_add(&handle->vfh); 331 332 handle->device = &uvc->video; 333 file->private_data = &handle->vfh; 334 335 return 0; 336 } 337 338 static int 339 uvc_v4l2_release(struct file *file) 340 { 341 struct video_device *vdev = video_devdata(file); 342 struct uvc_device *uvc = video_get_drvdata(vdev); 343 struct uvc_file_handle *handle = to_uvc_file_handle(file->private_data); 344 struct uvc_video *video = handle->device; 345 346 mutex_lock(&video->mutex); 347 if (handle->is_uvc_app_handle) 348 uvc_v4l2_disable(uvc); 349 mutex_unlock(&video->mutex); 350 351 file->private_data = NULL; 352 v4l2_fh_del(&handle->vfh); 353 v4l2_fh_exit(&handle->vfh); 354 kfree(handle); 355 356 return 0; 357 } 358 359 static int 360 uvc_v4l2_mmap(struct file *file, struct vm_area_struct *vma) 361 { 362 struct video_device *vdev = video_devdata(file); 363 struct uvc_device *uvc = video_get_drvdata(vdev); 364 365 return uvcg_queue_mmap(&uvc->video.queue, vma); 366 } 367 368 static __poll_t 369 uvc_v4l2_poll(struct file *file, poll_table *wait) 370 { 371 struct video_device *vdev = video_devdata(file); 372 struct uvc_device *uvc = video_get_drvdata(vdev); 373 374 return uvcg_queue_poll(&uvc->video.queue, file, wait); 375 } 376 377 #ifndef CONFIG_MMU 378 static unsigned long uvcg_v4l2_get_unmapped_area(struct file *file, 379 unsigned long addr, unsigned long len, unsigned long pgoff, 380 unsigned long flags) 381 { 382 struct video_device *vdev = video_devdata(file); 383 struct uvc_device *uvc = video_get_drvdata(vdev); 384 385 return uvcg_queue_get_unmapped_area(&uvc->video.queue, pgoff); 386 } 387 #endif 388 389 const struct v4l2_file_operations uvc_v4l2_fops = { 390 .owner = THIS_MODULE, 391 .open = uvc_v4l2_open, 392 .release = uvc_v4l2_release, 393 .unlocked_ioctl = video_ioctl2, 394 .mmap = uvc_v4l2_mmap, 395 .poll = uvc_v4l2_poll, 396 #ifndef CONFIG_MMU 397 .get_unmapped_area = uvcg_v4l2_get_unmapped_area, 398 #endif 399 }; 400 401