1
2
3
4
5
6
7
8
9
10
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
33
34
35static int
36uvc_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
54
55
56struct uvc_format
57{
58 u8 bpp;
59 u32 fcc;
60};
61
62static struct uvc_format uvc_formats[] = {
63 { 16, V4L2_PIX_FMT_YUYV },
64 { 0, V4L2_PIX_FMT_MJPEG },
65};
66
67static int
68uvc_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
85static int
86uvc_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
104static int
105uvc_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
145static int
146uvc_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
158static int
159uvc_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
168static int
169uvc_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
183static int
184uvc_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
193static int
194uvc_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
205 ret = uvcg_video_enable(video, 1);
206 if (ret < 0)
207 return ret;
208
209
210
211
212
213 uvc_function_setup_continue(uvc);
214 uvc->state = UVC_STATE_STREAMING;
215
216 return 0;
217}
218
219static int
220uvc_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
232static int
233uvc_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
242static int
243uvc_v4l2_unsubscribe_event(struct v4l2_fh *fh,
244 const struct v4l2_event_subscription *sub)
245{
246 return v4l2_event_unsubscribe(fh, sub);
247}
248
249static long
250uvc_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
265const 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
282
283
284static int
285uvc_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
305static int
306uvc_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
328static int
329uvc_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
337static unsigned int
338uvc_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
347static 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
358struct 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
