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
32static int
33uvc_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
53struct uvc_format {
54	u8 bpp;
55	u32 fcc;
56};
57
58static struct uvc_format uvc_formats[] = {
59	{ 16, V4L2_PIX_FMT_YUYV  },
60	{ 0,  V4L2_PIX_FMT_MJPEG },
61};
62
63static int
64uvc_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
77static int
78uvc_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
96static int
97uvc_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
137static int
138uvc_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
150static int
151uvc_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
160static int
161uvc_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	schedule_work(&video->pump);
173
174	return ret;
175}
176
177static int
178uvc_v4l2_dqbuf(struct file *file, void *fh, struct v4l2_buffer *b)
179{
180	struct video_device *vdev = video_devdata(file);
181	struct uvc_device *uvc = video_get_drvdata(vdev);
182	struct uvc_video *video = &uvc->video;
183
184	return uvcg_dequeue_buffer(&video->queue, b, file->f_flags & O_NONBLOCK);
185}
186
187static int
188uvc_v4l2_streamon(struct file *file, void *fh, enum v4l2_buf_type type)
189{
190	struct video_device *vdev = video_devdata(file);
191	struct uvc_device *uvc = video_get_drvdata(vdev);
192	struct uvc_video *video = &uvc->video;
193	int ret;
194
195	if (type != video->queue.queue.type)
196		return -EINVAL;
197
198	/* Enable UVC video. */
199	ret = uvcg_video_enable(video, 1);
200	if (ret < 0)
201		return ret;
202
203	/*
204	 * Complete the alternate setting selection setup phase now that
205	 * userspace is ready to provide video frames.
206	 */
207	uvc_function_setup_continue(uvc);
208	uvc->state = UVC_STATE_STREAMING;
209
210	return 0;
211}
212
213static int
214uvc_v4l2_streamoff(struct file *file, void *fh, enum v4l2_buf_type type)
215{
216	struct video_device *vdev = video_devdata(file);
217	struct uvc_device *uvc = video_get_drvdata(vdev);
218	struct uvc_video *video = &uvc->video;
219
220	if (type != video->queue.queue.type)
221		return -EINVAL;
222
223	return uvcg_video_enable(video, 0);
224}
225
226static int
227uvc_v4l2_subscribe_event(struct v4l2_fh *fh,
228			 const struct v4l2_event_subscription *sub)
229{
230	struct uvc_device *uvc = video_get_drvdata(fh->vdev);
231	struct uvc_file_handle *handle = to_uvc_file_handle(fh);
232	int ret;
233
234	if (sub->type < UVC_EVENT_FIRST || sub->type > UVC_EVENT_LAST)
235		return -EINVAL;
236
237	if (sub->type == UVC_EVENT_SETUP && uvc->func_connected)
238		return -EBUSY;
239
240	ret = v4l2_event_subscribe(fh, sub, 2, NULL);
241	if (ret < 0)
242		return ret;
243
244	if (sub->type == UVC_EVENT_SETUP) {
245		uvc->func_connected = true;
246		handle->is_uvc_app_handle = true;
247		uvc_function_connect(uvc);
248	}
249
250	return 0;
251}
252
253static void uvc_v4l2_disable(struct uvc_device *uvc)
254{
255	uvc_function_disconnect(uvc);
256	uvcg_video_enable(&uvc->video, 0);
257	uvcg_free_buffers(&uvc->video.queue);
258	uvc->func_connected = false;
259	wake_up_interruptible(&uvc->func_connected_queue);
260}
261
262static int
263uvc_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
282static long
283uvc_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
298const 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
317static int
318uvc_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
337static int
338uvc_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
358static int
359uvc_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
367static __poll_t
368uvc_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
377static 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
388const 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
400