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