1 // SPDX-License-Identifier: GPL-2.0-or-later
2 /*
3  * Video capture interface for Linux version 2
4  *
5  *	A generic video device interface for the LINUX operating system
6  *	using a set of device structures/vectors for low level operations.
7  *
8  * Authors:	Alan Cox, <alan@lxorguk.ukuu.org.uk> (version 1)
9  *              Mauro Carvalho Chehab <mchehab@kernel.org> (version 2)
10  *
11  * Fixes:	20000516  Claudio Matsuoka <claudio@conectiva.com>
12  *		- Added procfs support
13  */
14 
15 #define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
16 
17 #include <linux/debugfs.h>
18 #include <linux/module.h>
19 #include <linux/types.h>
20 #include <linux/kernel.h>
21 #include <linux/mm.h>
22 #include <linux/string.h>
23 #include <linux/errno.h>
24 #include <linux/init.h>
25 #include <linux/kmod.h>
26 #include <linux/slab.h>
27 #include <linux/uaccess.h>
28 
29 #include <media/v4l2-common.h>
30 #include <media/v4l2-device.h>
31 #include <media/v4l2-ioctl.h>
32 #include <media/v4l2-event.h>
33 
34 #define VIDEO_NUM_DEVICES	256
35 #define VIDEO_NAME              "video4linux"
36 
37 #define dprintk(fmt, arg...) do {					\
38 		printk(KERN_DEBUG pr_fmt("%s: " fmt),			\
39 		       __func__, ##arg);				\
40 } while (0)
41 
42 /*
43  *	sysfs stuff
44  */
45 
46 static ssize_t index_show(struct device *cd,
47 			  struct device_attribute *attr, char *buf)
48 {
49 	struct video_device *vdev = to_video_device(cd);
50 
51 	return sprintf(buf, "%i\n", vdev->index);
52 }
53 static DEVICE_ATTR_RO(index);
54 
55 static ssize_t dev_debug_show(struct device *cd,
56 			  struct device_attribute *attr, char *buf)
57 {
58 	struct video_device *vdev = to_video_device(cd);
59 
60 	return sprintf(buf, "%i\n", vdev->dev_debug);
61 }
62 
63 static ssize_t dev_debug_store(struct device *cd, struct device_attribute *attr,
64 			  const char *buf, size_t len)
65 {
66 	struct video_device *vdev = to_video_device(cd);
67 	int res = 0;
68 	u16 value;
69 
70 	res = kstrtou16(buf, 0, &value);
71 	if (res)
72 		return res;
73 
74 	vdev->dev_debug = value;
75 	return len;
76 }
77 static DEVICE_ATTR_RW(dev_debug);
78 
79 static ssize_t name_show(struct device *cd,
80 			 struct device_attribute *attr, char *buf)
81 {
82 	struct video_device *vdev = to_video_device(cd);
83 
84 	return sprintf(buf, "%.*s\n", (int)sizeof(vdev->name), vdev->name);
85 }
86 static DEVICE_ATTR_RO(name);
87 
88 static struct attribute *video_device_attrs[] = {
89 	&dev_attr_name.attr,
90 	&dev_attr_dev_debug.attr,
91 	&dev_attr_index.attr,
92 	NULL,
93 };
94 ATTRIBUTE_GROUPS(video_device);
95 
96 /*
97  *	Active devices
98  */
99 static struct video_device *video_devices[VIDEO_NUM_DEVICES];
100 static DEFINE_MUTEX(videodev_lock);
101 static DECLARE_BITMAP(devnode_nums[VFL_TYPE_MAX], VIDEO_NUM_DEVICES);
102 
103 /* Device node utility functions */
104 
105 /* Note: these utility functions all assume that vfl_type is in the range
106    [0, VFL_TYPE_MAX-1]. */
107 
108 #ifdef CONFIG_VIDEO_FIXED_MINOR_RANGES
109 /* Return the bitmap corresponding to vfl_type. */
110 static inline unsigned long *devnode_bits(enum vfl_devnode_type vfl_type)
111 {
112 	/* Any types not assigned to fixed minor ranges must be mapped to
113 	   one single bitmap for the purposes of finding a free node number
114 	   since all those unassigned types use the same minor range. */
115 	int idx = (vfl_type > VFL_TYPE_RADIO) ? VFL_TYPE_MAX - 1 : vfl_type;
116 
117 	return devnode_nums[idx];
118 }
119 #else
120 /* Return the bitmap corresponding to vfl_type. */
121 static inline unsigned long *devnode_bits(enum vfl_devnode_type vfl_type)
122 {
123 	return devnode_nums[vfl_type];
124 }
125 #endif
126 
127 /* Mark device node number vdev->num as used */
128 static inline void devnode_set(struct video_device *vdev)
129 {
130 	set_bit(vdev->num, devnode_bits(vdev->vfl_type));
131 }
132 
133 /* Mark device node number vdev->num as unused */
134 static inline void devnode_clear(struct video_device *vdev)
135 {
136 	clear_bit(vdev->num, devnode_bits(vdev->vfl_type));
137 }
138 
139 /* Try to find a free device node number in the range [from, to> */
140 static inline int devnode_find(struct video_device *vdev, int from, int to)
141 {
142 	return find_next_zero_bit(devnode_bits(vdev->vfl_type), to, from);
143 }
144 
145 struct video_device *video_device_alloc(void)
146 {
147 	return kzalloc(sizeof(struct video_device), GFP_KERNEL);
148 }
149 EXPORT_SYMBOL(video_device_alloc);
150 
151 void video_device_release(struct video_device *vdev)
152 {
153 	kfree(vdev);
154 }
155 EXPORT_SYMBOL(video_device_release);
156 
157 void video_device_release_empty(struct video_device *vdev)
158 {
159 	/* Do nothing */
160 	/* Only valid when the video_device struct is a static. */
161 }
162 EXPORT_SYMBOL(video_device_release_empty);
163 
164 static inline void video_get(struct video_device *vdev)
165 {
166 	get_device(&vdev->dev);
167 }
168 
169 static inline void video_put(struct video_device *vdev)
170 {
171 	put_device(&vdev->dev);
172 }
173 
174 /* Called when the last user of the video device exits. */
175 static void v4l2_device_release(struct device *cd)
176 {
177 	struct video_device *vdev = to_video_device(cd);
178 	struct v4l2_device *v4l2_dev = vdev->v4l2_dev;
179 
180 	mutex_lock(&videodev_lock);
181 	if (WARN_ON(video_devices[vdev->minor] != vdev)) {
182 		/* should not happen */
183 		mutex_unlock(&videodev_lock);
184 		return;
185 	}
186 
187 	/* Free up this device for reuse */
188 	video_devices[vdev->minor] = NULL;
189 
190 	/* Delete the cdev on this minor as well */
191 	cdev_del(vdev->cdev);
192 	/* Just in case some driver tries to access this from
193 	   the release() callback. */
194 	vdev->cdev = NULL;
195 
196 	/* Mark device node number as free */
197 	devnode_clear(vdev);
198 
199 	mutex_unlock(&videodev_lock);
200 
201 #if defined(CONFIG_MEDIA_CONTROLLER)
202 	if (v4l2_dev->mdev && vdev->vfl_dir != VFL_DIR_M2M) {
203 		/* Remove interfaces and interface links */
204 		media_devnode_remove(vdev->intf_devnode);
205 		if (vdev->entity.function != MEDIA_ENT_F_UNKNOWN)
206 			media_device_unregister_entity(&vdev->entity);
207 	}
208 #endif
209 
210 	/* Do not call v4l2_device_put if there is no release callback set.
211 	 * Drivers that have no v4l2_device release callback might free the
212 	 * v4l2_dev instance in the video_device release callback below, so we
213 	 * must perform this check here.
214 	 *
215 	 * TODO: In the long run all drivers that use v4l2_device should use the
216 	 * v4l2_device release callback. This check will then be unnecessary.
217 	 */
218 	if (v4l2_dev->release == NULL)
219 		v4l2_dev = NULL;
220 
221 	/* Release video_device and perform other
222 	   cleanups as needed. */
223 	vdev->release(vdev);
224 
225 	/* Decrease v4l2_device refcount */
226 	if (v4l2_dev)
227 		v4l2_device_put(v4l2_dev);
228 }
229 
230 static struct class video_class = {
231 	.name = VIDEO_NAME,
232 	.dev_groups = video_device_groups,
233 };
234 
235 struct video_device *video_devdata(struct file *file)
236 {
237 	return video_devices[iminor(file_inode(file))];
238 }
239 EXPORT_SYMBOL(video_devdata);
240 
241 
242 /* Priority handling */
243 
244 static inline bool prio_is_valid(enum v4l2_priority prio)
245 {
246 	return prio == V4L2_PRIORITY_BACKGROUND ||
247 	       prio == V4L2_PRIORITY_INTERACTIVE ||
248 	       prio == V4L2_PRIORITY_RECORD;
249 }
250 
251 void v4l2_prio_init(struct v4l2_prio_state *global)
252 {
253 	memset(global, 0, sizeof(*global));
254 }
255 EXPORT_SYMBOL(v4l2_prio_init);
256 
257 int v4l2_prio_change(struct v4l2_prio_state *global, enum v4l2_priority *local,
258 		     enum v4l2_priority new)
259 {
260 	if (!prio_is_valid(new))
261 		return -EINVAL;
262 	if (*local == new)
263 		return 0;
264 
265 	atomic_inc(&global->prios[new]);
266 	if (prio_is_valid(*local))
267 		atomic_dec(&global->prios[*local]);
268 	*local = new;
269 	return 0;
270 }
271 EXPORT_SYMBOL(v4l2_prio_change);
272 
273 void v4l2_prio_open(struct v4l2_prio_state *global, enum v4l2_priority *local)
274 {
275 	v4l2_prio_change(global, local, V4L2_PRIORITY_DEFAULT);
276 }
277 EXPORT_SYMBOL(v4l2_prio_open);
278 
279 void v4l2_prio_close(struct v4l2_prio_state *global, enum v4l2_priority local)
280 {
281 	if (prio_is_valid(local))
282 		atomic_dec(&global->prios[local]);
283 }
284 EXPORT_SYMBOL(v4l2_prio_close);
285 
286 enum v4l2_priority v4l2_prio_max(struct v4l2_prio_state *global)
287 {
288 	if (atomic_read(&global->prios[V4L2_PRIORITY_RECORD]) > 0)
289 		return V4L2_PRIORITY_RECORD;
290 	if (atomic_read(&global->prios[V4L2_PRIORITY_INTERACTIVE]) > 0)
291 		return V4L2_PRIORITY_INTERACTIVE;
292 	if (atomic_read(&global->prios[V4L2_PRIORITY_BACKGROUND]) > 0)
293 		return V4L2_PRIORITY_BACKGROUND;
294 	return V4L2_PRIORITY_UNSET;
295 }
296 EXPORT_SYMBOL(v4l2_prio_max);
297 
298 int v4l2_prio_check(struct v4l2_prio_state *global, enum v4l2_priority local)
299 {
300 	return (local < v4l2_prio_max(global)) ? -EBUSY : 0;
301 }
302 EXPORT_SYMBOL(v4l2_prio_check);
303 
304 
305 static ssize_t v4l2_read(struct file *filp, char __user *buf,
306 		size_t sz, loff_t *off)
307 {
308 	struct video_device *vdev = video_devdata(filp);
309 	int ret = -ENODEV;
310 
311 	if (!vdev->fops->read)
312 		return -EINVAL;
313 	if (video_is_registered(vdev))
314 		ret = vdev->fops->read(filp, buf, sz, off);
315 	if ((vdev->dev_debug & V4L2_DEV_DEBUG_FOP) &&
316 	    (vdev->dev_debug & V4L2_DEV_DEBUG_STREAMING))
317 		dprintk("%s: read: %zd (%d)\n",
318 			video_device_node_name(vdev), sz, ret);
319 	return ret;
320 }
321 
322 static ssize_t v4l2_write(struct file *filp, const char __user *buf,
323 		size_t sz, loff_t *off)
324 {
325 	struct video_device *vdev = video_devdata(filp);
326 	int ret = -ENODEV;
327 
328 	if (!vdev->fops->write)
329 		return -EINVAL;
330 	if (video_is_registered(vdev))
331 		ret = vdev->fops->write(filp, buf, sz, off);
332 	if ((vdev->dev_debug & V4L2_DEV_DEBUG_FOP) &&
333 	    (vdev->dev_debug & V4L2_DEV_DEBUG_STREAMING))
334 		dprintk("%s: write: %zd (%d)\n",
335 			video_device_node_name(vdev), sz, ret);
336 	return ret;
337 }
338 
339 static __poll_t v4l2_poll(struct file *filp, struct poll_table_struct *poll)
340 {
341 	struct video_device *vdev = video_devdata(filp);
342 	__poll_t res = EPOLLERR | EPOLLHUP | EPOLLPRI;
343 
344 	if (video_is_registered(vdev)) {
345 		if (!vdev->fops->poll)
346 			res = DEFAULT_POLLMASK;
347 		else
348 			res = vdev->fops->poll(filp, poll);
349 	}
350 	if (vdev->dev_debug & V4L2_DEV_DEBUG_POLL)
351 		dprintk("%s: poll: %08x %08x\n",
352 			video_device_node_name(vdev), res,
353 			poll_requested_events(poll));
354 	return res;
355 }
356 
357 static long v4l2_ioctl(struct file *filp, unsigned int cmd, unsigned long arg)
358 {
359 	struct video_device *vdev = video_devdata(filp);
360 	int ret = -ENODEV;
361 
362 	if (vdev->fops->unlocked_ioctl) {
363 		if (video_is_registered(vdev))
364 			ret = vdev->fops->unlocked_ioctl(filp, cmd, arg);
365 	} else
366 		ret = -ENOTTY;
367 
368 	return ret;
369 }
370 
371 #ifdef CONFIG_MMU
372 #define v4l2_get_unmapped_area NULL
373 #else
374 static unsigned long v4l2_get_unmapped_area(struct file *filp,
375 		unsigned long addr, unsigned long len, unsigned long pgoff,
376 		unsigned long flags)
377 {
378 	struct video_device *vdev = video_devdata(filp);
379 	int ret;
380 
381 	if (!vdev->fops->get_unmapped_area)
382 		return -ENOSYS;
383 	if (!video_is_registered(vdev))
384 		return -ENODEV;
385 	ret = vdev->fops->get_unmapped_area(filp, addr, len, pgoff, flags);
386 	if (vdev->dev_debug & V4L2_DEV_DEBUG_FOP)
387 		dprintk("%s: get_unmapped_area (%d)\n",
388 			video_device_node_name(vdev), ret);
389 	return ret;
390 }
391 #endif
392 
393 static int v4l2_mmap(struct file *filp, struct vm_area_struct *vm)
394 {
395 	struct video_device *vdev = video_devdata(filp);
396 	int ret = -ENODEV;
397 
398 	if (!vdev->fops->mmap)
399 		return -ENODEV;
400 	if (video_is_registered(vdev))
401 		ret = vdev->fops->mmap(filp, vm);
402 	if (vdev->dev_debug & V4L2_DEV_DEBUG_FOP)
403 		dprintk("%s: mmap (%d)\n",
404 			video_device_node_name(vdev), ret);
405 	return ret;
406 }
407 
408 /* Override for the open function */
409 static int v4l2_open(struct inode *inode, struct file *filp)
410 {
411 	struct video_device *vdev;
412 	int ret = 0;
413 
414 	/* Check if the video device is available */
415 	mutex_lock(&videodev_lock);
416 	vdev = video_devdata(filp);
417 	/* return ENODEV if the video device has already been removed. */
418 	if (vdev == NULL || !video_is_registered(vdev)) {
419 		mutex_unlock(&videodev_lock);
420 		return -ENODEV;
421 	}
422 	/* and increase the device refcount */
423 	video_get(vdev);
424 	mutex_unlock(&videodev_lock);
425 	if (vdev->fops->open) {
426 		if (video_is_registered(vdev))
427 			ret = vdev->fops->open(filp);
428 		else
429 			ret = -ENODEV;
430 	}
431 
432 	if (vdev->dev_debug & V4L2_DEV_DEBUG_FOP)
433 		dprintk("%s: open (%d)\n",
434 			video_device_node_name(vdev), ret);
435 	/* decrease the refcount in case of an error */
436 	if (ret)
437 		video_put(vdev);
438 	return ret;
439 }
440 
441 /* Override for the release function */
442 static int v4l2_release(struct inode *inode, struct file *filp)
443 {
444 	struct video_device *vdev = video_devdata(filp);
445 	int ret = 0;
446 
447 	/*
448 	 * We need to serialize the release() with queueing new requests.
449 	 * The release() may trigger the cancellation of a streaming
450 	 * operation, and that should not be mixed with queueing a new
451 	 * request at the same time.
452 	 */
453 	if (vdev->fops->release) {
454 		if (v4l2_device_supports_requests(vdev->v4l2_dev)) {
455 			mutex_lock(&vdev->v4l2_dev->mdev->req_queue_mutex);
456 			ret = vdev->fops->release(filp);
457 			mutex_unlock(&vdev->v4l2_dev->mdev->req_queue_mutex);
458 		} else {
459 			ret = vdev->fops->release(filp);
460 		}
461 	}
462 
463 	if (vdev->dev_debug & V4L2_DEV_DEBUG_FOP)
464 		dprintk("%s: release\n",
465 			video_device_node_name(vdev));
466 
467 	/* decrease the refcount unconditionally since the release()
468 	   return value is ignored. */
469 	video_put(vdev);
470 	return ret;
471 }
472 
473 static const struct file_operations v4l2_fops = {
474 	.owner = THIS_MODULE,
475 	.read = v4l2_read,
476 	.write = v4l2_write,
477 	.open = v4l2_open,
478 	.get_unmapped_area = v4l2_get_unmapped_area,
479 	.mmap = v4l2_mmap,
480 	.unlocked_ioctl = v4l2_ioctl,
481 #ifdef CONFIG_COMPAT
482 	.compat_ioctl = v4l2_compat_ioctl32,
483 #endif
484 	.release = v4l2_release,
485 	.poll = v4l2_poll,
486 	.llseek = no_llseek,
487 };
488 
489 /**
490  * get_index - assign stream index number based on v4l2_dev
491  * @vdev: video_device to assign index number to, vdev->v4l2_dev should be assigned
492  *
493  * Note that when this is called the new device has not yet been registered
494  * in the video_device array, but it was able to obtain a minor number.
495  *
496  * This means that we can always obtain a free stream index number since
497  * the worst case scenario is that there are VIDEO_NUM_DEVICES - 1 slots in
498  * use of the video_device array.
499  *
500  * Returns a free index number.
501  */
502 static int get_index(struct video_device *vdev)
503 {
504 	/* This can be static since this function is called with the global
505 	   videodev_lock held. */
506 	static DECLARE_BITMAP(used, VIDEO_NUM_DEVICES);
507 	int i;
508 
509 	bitmap_zero(used, VIDEO_NUM_DEVICES);
510 
511 	for (i = 0; i < VIDEO_NUM_DEVICES; i++) {
512 		if (video_devices[i] != NULL &&
513 		    video_devices[i]->v4l2_dev == vdev->v4l2_dev) {
514 			__set_bit(video_devices[i]->index, used);
515 		}
516 	}
517 
518 	return find_first_zero_bit(used, VIDEO_NUM_DEVICES);
519 }
520 
521 #define SET_VALID_IOCTL(ops, cmd, op) \
522 	do { if ((ops)->op) __set_bit(_IOC_NR(cmd), valid_ioctls); } while (0)
523 
524 /* This determines which ioctls are actually implemented in the driver.
525    It's a one-time thing which simplifies video_ioctl2 as it can just do
526    a bit test.
527 
528    Note that drivers can override this by setting bits to 1 in
529    vdev->valid_ioctls. If an ioctl is marked as 1 when this function is
530    called, then that ioctl will actually be marked as unimplemented.
531 
532    It does that by first setting up the local valid_ioctls bitmap, and
533    at the end do a:
534 
535    vdev->valid_ioctls = valid_ioctls & ~(vdev->valid_ioctls)
536  */
537 static void determine_valid_ioctls(struct video_device *vdev)
538 {
539 	const u32 vid_caps = V4L2_CAP_VIDEO_CAPTURE |
540 			     V4L2_CAP_VIDEO_CAPTURE_MPLANE |
541 			     V4L2_CAP_VIDEO_OUTPUT |
542 			     V4L2_CAP_VIDEO_OUTPUT_MPLANE |
543 			     V4L2_CAP_VIDEO_M2M | V4L2_CAP_VIDEO_M2M_MPLANE;
544 	const u32 meta_caps = V4L2_CAP_META_CAPTURE |
545 			      V4L2_CAP_META_OUTPUT;
546 	DECLARE_BITMAP(valid_ioctls, BASE_VIDIOC_PRIVATE);
547 	const struct v4l2_ioctl_ops *ops = vdev->ioctl_ops;
548 	bool is_vid = vdev->vfl_type == VFL_TYPE_VIDEO &&
549 		      (vdev->device_caps & vid_caps);
550 	bool is_vbi = vdev->vfl_type == VFL_TYPE_VBI;
551 	bool is_radio = vdev->vfl_type == VFL_TYPE_RADIO;
552 	bool is_sdr = vdev->vfl_type == VFL_TYPE_SDR;
553 	bool is_tch = vdev->vfl_type == VFL_TYPE_TOUCH;
554 	bool is_meta = vdev->vfl_type == VFL_TYPE_VIDEO &&
555 		       (vdev->device_caps & meta_caps);
556 	bool is_rx = vdev->vfl_dir != VFL_DIR_TX;
557 	bool is_tx = vdev->vfl_dir != VFL_DIR_RX;
558 	bool is_io_mc = vdev->device_caps & V4L2_CAP_IO_MC;
559 	bool has_streaming = vdev->device_caps & V4L2_CAP_STREAMING;
560 
561 	bitmap_zero(valid_ioctls, BASE_VIDIOC_PRIVATE);
562 
563 	/* vfl_type and vfl_dir independent ioctls */
564 
565 	SET_VALID_IOCTL(ops, VIDIOC_QUERYCAP, vidioc_querycap);
566 	__set_bit(_IOC_NR(VIDIOC_G_PRIORITY), valid_ioctls);
567 	__set_bit(_IOC_NR(VIDIOC_S_PRIORITY), valid_ioctls);
568 
569 	/* Note: the control handler can also be passed through the filehandle,
570 	   and that can't be tested here. If the bit for these control ioctls
571 	   is set, then the ioctl is valid. But if it is 0, then it can still
572 	   be valid if the filehandle passed the control handler. */
573 	if (vdev->ctrl_handler || ops->vidioc_queryctrl)
574 		__set_bit(_IOC_NR(VIDIOC_QUERYCTRL), valid_ioctls);
575 	if (vdev->ctrl_handler || ops->vidioc_query_ext_ctrl)
576 		__set_bit(_IOC_NR(VIDIOC_QUERY_EXT_CTRL), valid_ioctls);
577 	if (vdev->ctrl_handler || ops->vidioc_g_ctrl || ops->vidioc_g_ext_ctrls)
578 		__set_bit(_IOC_NR(VIDIOC_G_CTRL), valid_ioctls);
579 	if (vdev->ctrl_handler || ops->vidioc_s_ctrl || ops->vidioc_s_ext_ctrls)
580 		__set_bit(_IOC_NR(VIDIOC_S_CTRL), valid_ioctls);
581 	if (vdev->ctrl_handler || ops->vidioc_g_ext_ctrls)
582 		__set_bit(_IOC_NR(VIDIOC_G_EXT_CTRLS), valid_ioctls);
583 	if (vdev->ctrl_handler || ops->vidioc_s_ext_ctrls)
584 		__set_bit(_IOC_NR(VIDIOC_S_EXT_CTRLS), valid_ioctls);
585 	if (vdev->ctrl_handler || ops->vidioc_try_ext_ctrls)
586 		__set_bit(_IOC_NR(VIDIOC_TRY_EXT_CTRLS), valid_ioctls);
587 	if (vdev->ctrl_handler || ops->vidioc_querymenu)
588 		__set_bit(_IOC_NR(VIDIOC_QUERYMENU), valid_ioctls);
589 	if (!is_tch) {
590 		SET_VALID_IOCTL(ops, VIDIOC_G_FREQUENCY, vidioc_g_frequency);
591 		SET_VALID_IOCTL(ops, VIDIOC_S_FREQUENCY, vidioc_s_frequency);
592 	}
593 	SET_VALID_IOCTL(ops, VIDIOC_LOG_STATUS, vidioc_log_status);
594 #ifdef CONFIG_VIDEO_ADV_DEBUG
595 	__set_bit(_IOC_NR(VIDIOC_DBG_G_CHIP_INFO), valid_ioctls);
596 	__set_bit(_IOC_NR(VIDIOC_DBG_G_REGISTER), valid_ioctls);
597 	__set_bit(_IOC_NR(VIDIOC_DBG_S_REGISTER), valid_ioctls);
598 #endif
599 	/* yes, really vidioc_subscribe_event */
600 	SET_VALID_IOCTL(ops, VIDIOC_DQEVENT, vidioc_subscribe_event);
601 	SET_VALID_IOCTL(ops, VIDIOC_SUBSCRIBE_EVENT, vidioc_subscribe_event);
602 	SET_VALID_IOCTL(ops, VIDIOC_UNSUBSCRIBE_EVENT, vidioc_unsubscribe_event);
603 	if (ops->vidioc_enum_freq_bands || ops->vidioc_g_tuner || ops->vidioc_g_modulator)
604 		__set_bit(_IOC_NR(VIDIOC_ENUM_FREQ_BANDS), valid_ioctls);
605 
606 	if (is_vid) {
607 		/* video specific ioctls */
608 		if ((is_rx && (ops->vidioc_enum_fmt_vid_cap ||
609 			       ops->vidioc_enum_fmt_vid_overlay)) ||
610 		    (is_tx && ops->vidioc_enum_fmt_vid_out))
611 			__set_bit(_IOC_NR(VIDIOC_ENUM_FMT), valid_ioctls);
612 		if ((is_rx && (ops->vidioc_g_fmt_vid_cap ||
613 			       ops->vidioc_g_fmt_vid_cap_mplane ||
614 			       ops->vidioc_g_fmt_vid_overlay)) ||
615 		    (is_tx && (ops->vidioc_g_fmt_vid_out ||
616 			       ops->vidioc_g_fmt_vid_out_mplane ||
617 			       ops->vidioc_g_fmt_vid_out_overlay)))
618 			__set_bit(_IOC_NR(VIDIOC_G_FMT), valid_ioctls);
619 		if ((is_rx && (ops->vidioc_s_fmt_vid_cap ||
620 			       ops->vidioc_s_fmt_vid_cap_mplane ||
621 			       ops->vidioc_s_fmt_vid_overlay)) ||
622 		    (is_tx && (ops->vidioc_s_fmt_vid_out ||
623 			       ops->vidioc_s_fmt_vid_out_mplane ||
624 			       ops->vidioc_s_fmt_vid_out_overlay)))
625 			__set_bit(_IOC_NR(VIDIOC_S_FMT), valid_ioctls);
626 		if ((is_rx && (ops->vidioc_try_fmt_vid_cap ||
627 			       ops->vidioc_try_fmt_vid_cap_mplane ||
628 			       ops->vidioc_try_fmt_vid_overlay)) ||
629 		    (is_tx && (ops->vidioc_try_fmt_vid_out ||
630 			       ops->vidioc_try_fmt_vid_out_mplane ||
631 			       ops->vidioc_try_fmt_vid_out_overlay)))
632 			__set_bit(_IOC_NR(VIDIOC_TRY_FMT), valid_ioctls);
633 		SET_VALID_IOCTL(ops, VIDIOC_OVERLAY, vidioc_overlay);
634 		SET_VALID_IOCTL(ops, VIDIOC_G_FBUF, vidioc_g_fbuf);
635 		SET_VALID_IOCTL(ops, VIDIOC_S_FBUF, vidioc_s_fbuf);
636 		SET_VALID_IOCTL(ops, VIDIOC_G_JPEGCOMP, vidioc_g_jpegcomp);
637 		SET_VALID_IOCTL(ops, VIDIOC_S_JPEGCOMP, vidioc_s_jpegcomp);
638 		SET_VALID_IOCTL(ops, VIDIOC_G_ENC_INDEX, vidioc_g_enc_index);
639 		SET_VALID_IOCTL(ops, VIDIOC_ENCODER_CMD, vidioc_encoder_cmd);
640 		SET_VALID_IOCTL(ops, VIDIOC_TRY_ENCODER_CMD, vidioc_try_encoder_cmd);
641 		SET_VALID_IOCTL(ops, VIDIOC_DECODER_CMD, vidioc_decoder_cmd);
642 		SET_VALID_IOCTL(ops, VIDIOC_TRY_DECODER_CMD, vidioc_try_decoder_cmd);
643 		SET_VALID_IOCTL(ops, VIDIOC_ENUM_FRAMESIZES, vidioc_enum_framesizes);
644 		SET_VALID_IOCTL(ops, VIDIOC_ENUM_FRAMEINTERVALS, vidioc_enum_frameintervals);
645 		if (ops->vidioc_g_selection) {
646 			__set_bit(_IOC_NR(VIDIOC_G_CROP), valid_ioctls);
647 			__set_bit(_IOC_NR(VIDIOC_CROPCAP), valid_ioctls);
648 		}
649 		if (ops->vidioc_s_selection)
650 			__set_bit(_IOC_NR(VIDIOC_S_CROP), valid_ioctls);
651 		SET_VALID_IOCTL(ops, VIDIOC_G_SELECTION, vidioc_g_selection);
652 		SET_VALID_IOCTL(ops, VIDIOC_S_SELECTION, vidioc_s_selection);
653 	}
654 	if (is_meta && is_rx) {
655 		/* metadata capture specific ioctls */
656 		SET_VALID_IOCTL(ops, VIDIOC_ENUM_FMT, vidioc_enum_fmt_meta_cap);
657 		SET_VALID_IOCTL(ops, VIDIOC_G_FMT, vidioc_g_fmt_meta_cap);
658 		SET_VALID_IOCTL(ops, VIDIOC_S_FMT, vidioc_s_fmt_meta_cap);
659 		SET_VALID_IOCTL(ops, VIDIOC_TRY_FMT, vidioc_try_fmt_meta_cap);
660 	} else if (is_meta && is_tx) {
661 		/* metadata output specific ioctls */
662 		SET_VALID_IOCTL(ops, VIDIOC_ENUM_FMT, vidioc_enum_fmt_meta_out);
663 		SET_VALID_IOCTL(ops, VIDIOC_G_FMT, vidioc_g_fmt_meta_out);
664 		SET_VALID_IOCTL(ops, VIDIOC_S_FMT, vidioc_s_fmt_meta_out);
665 		SET_VALID_IOCTL(ops, VIDIOC_TRY_FMT, vidioc_try_fmt_meta_out);
666 	}
667 	if (is_vbi) {
668 		/* vbi specific ioctls */
669 		if ((is_rx && (ops->vidioc_g_fmt_vbi_cap ||
670 			       ops->vidioc_g_fmt_sliced_vbi_cap)) ||
671 		    (is_tx && (ops->vidioc_g_fmt_vbi_out ||
672 			       ops->vidioc_g_fmt_sliced_vbi_out)))
673 			__set_bit(_IOC_NR(VIDIOC_G_FMT), valid_ioctls);
674 		if ((is_rx && (ops->vidioc_s_fmt_vbi_cap ||
675 			       ops->vidioc_s_fmt_sliced_vbi_cap)) ||
676 		    (is_tx && (ops->vidioc_s_fmt_vbi_out ||
677 			       ops->vidioc_s_fmt_sliced_vbi_out)))
678 			__set_bit(_IOC_NR(VIDIOC_S_FMT), valid_ioctls);
679 		if ((is_rx && (ops->vidioc_try_fmt_vbi_cap ||
680 			       ops->vidioc_try_fmt_sliced_vbi_cap)) ||
681 		    (is_tx && (ops->vidioc_try_fmt_vbi_out ||
682 			       ops->vidioc_try_fmt_sliced_vbi_out)))
683 			__set_bit(_IOC_NR(VIDIOC_TRY_FMT), valid_ioctls);
684 		SET_VALID_IOCTL(ops, VIDIOC_G_SLICED_VBI_CAP, vidioc_g_sliced_vbi_cap);
685 	} else if (is_tch) {
686 		/* touch specific ioctls */
687 		SET_VALID_IOCTL(ops, VIDIOC_ENUM_FMT, vidioc_enum_fmt_vid_cap);
688 		SET_VALID_IOCTL(ops, VIDIOC_G_FMT, vidioc_g_fmt_vid_cap);
689 		SET_VALID_IOCTL(ops, VIDIOC_S_FMT, vidioc_s_fmt_vid_cap);
690 		SET_VALID_IOCTL(ops, VIDIOC_TRY_FMT, vidioc_try_fmt_vid_cap);
691 		SET_VALID_IOCTL(ops, VIDIOC_ENUM_FRAMESIZES, vidioc_enum_framesizes);
692 		SET_VALID_IOCTL(ops, VIDIOC_ENUM_FRAMEINTERVALS, vidioc_enum_frameintervals);
693 		SET_VALID_IOCTL(ops, VIDIOC_ENUMINPUT, vidioc_enum_input);
694 		SET_VALID_IOCTL(ops, VIDIOC_G_INPUT, vidioc_g_input);
695 		SET_VALID_IOCTL(ops, VIDIOC_S_INPUT, vidioc_s_input);
696 		SET_VALID_IOCTL(ops, VIDIOC_G_PARM, vidioc_g_parm);
697 		SET_VALID_IOCTL(ops, VIDIOC_S_PARM, vidioc_s_parm);
698 	} else if (is_sdr && is_rx) {
699 		/* SDR receiver specific ioctls */
700 		SET_VALID_IOCTL(ops, VIDIOC_ENUM_FMT, vidioc_enum_fmt_sdr_cap);
701 		SET_VALID_IOCTL(ops, VIDIOC_G_FMT, vidioc_g_fmt_sdr_cap);
702 		SET_VALID_IOCTL(ops, VIDIOC_S_FMT, vidioc_s_fmt_sdr_cap);
703 		SET_VALID_IOCTL(ops, VIDIOC_TRY_FMT, vidioc_try_fmt_sdr_cap);
704 	} else if (is_sdr && is_tx) {
705 		/* SDR transmitter specific ioctls */
706 		SET_VALID_IOCTL(ops, VIDIOC_ENUM_FMT, vidioc_enum_fmt_sdr_out);
707 		SET_VALID_IOCTL(ops, VIDIOC_G_FMT, vidioc_g_fmt_sdr_out);
708 		SET_VALID_IOCTL(ops, VIDIOC_S_FMT, vidioc_s_fmt_sdr_out);
709 		SET_VALID_IOCTL(ops, VIDIOC_TRY_FMT, vidioc_try_fmt_sdr_out);
710 	}
711 
712 	if (has_streaming) {
713 		/* ioctls valid for streaming I/O */
714 		SET_VALID_IOCTL(ops, VIDIOC_REQBUFS, vidioc_reqbufs);
715 		SET_VALID_IOCTL(ops, VIDIOC_QUERYBUF, vidioc_querybuf);
716 		SET_VALID_IOCTL(ops, VIDIOC_QBUF, vidioc_qbuf);
717 		SET_VALID_IOCTL(ops, VIDIOC_EXPBUF, vidioc_expbuf);
718 		SET_VALID_IOCTL(ops, VIDIOC_DQBUF, vidioc_dqbuf);
719 		SET_VALID_IOCTL(ops, VIDIOC_CREATE_BUFS, vidioc_create_bufs);
720 		SET_VALID_IOCTL(ops, VIDIOC_PREPARE_BUF, vidioc_prepare_buf);
721 		SET_VALID_IOCTL(ops, VIDIOC_STREAMON, vidioc_streamon);
722 		SET_VALID_IOCTL(ops, VIDIOC_STREAMOFF, vidioc_streamoff);
723 	}
724 
725 	if (is_vid || is_vbi || is_meta) {
726 		/* ioctls valid for video, vbi and metadata */
727 		if (ops->vidioc_s_std)
728 			__set_bit(_IOC_NR(VIDIOC_ENUMSTD), valid_ioctls);
729 		SET_VALID_IOCTL(ops, VIDIOC_S_STD, vidioc_s_std);
730 		SET_VALID_IOCTL(ops, VIDIOC_G_STD, vidioc_g_std);
731 		if (is_rx) {
732 			SET_VALID_IOCTL(ops, VIDIOC_QUERYSTD, vidioc_querystd);
733 			if (is_io_mc) {
734 				__set_bit(_IOC_NR(VIDIOC_ENUMINPUT), valid_ioctls);
735 				__set_bit(_IOC_NR(VIDIOC_G_INPUT), valid_ioctls);
736 				__set_bit(_IOC_NR(VIDIOC_S_INPUT), valid_ioctls);
737 			} else {
738 				SET_VALID_IOCTL(ops, VIDIOC_ENUMINPUT, vidioc_enum_input);
739 				SET_VALID_IOCTL(ops, VIDIOC_G_INPUT, vidioc_g_input);
740 				SET_VALID_IOCTL(ops, VIDIOC_S_INPUT, vidioc_s_input);
741 			}
742 			SET_VALID_IOCTL(ops, VIDIOC_ENUMAUDIO, vidioc_enumaudio);
743 			SET_VALID_IOCTL(ops, VIDIOC_G_AUDIO, vidioc_g_audio);
744 			SET_VALID_IOCTL(ops, VIDIOC_S_AUDIO, vidioc_s_audio);
745 			SET_VALID_IOCTL(ops, VIDIOC_QUERY_DV_TIMINGS, vidioc_query_dv_timings);
746 			SET_VALID_IOCTL(ops, VIDIOC_S_EDID, vidioc_s_edid);
747 		}
748 		if (is_tx) {
749 			if (is_io_mc) {
750 				__set_bit(_IOC_NR(VIDIOC_ENUMOUTPUT), valid_ioctls);
751 				__set_bit(_IOC_NR(VIDIOC_G_OUTPUT), valid_ioctls);
752 				__set_bit(_IOC_NR(VIDIOC_S_OUTPUT), valid_ioctls);
753 			} else {
754 				SET_VALID_IOCTL(ops, VIDIOC_ENUMOUTPUT, vidioc_enum_output);
755 				SET_VALID_IOCTL(ops, VIDIOC_G_OUTPUT, vidioc_g_output);
756 				SET_VALID_IOCTL(ops, VIDIOC_S_OUTPUT, vidioc_s_output);
757 			}
758 			SET_VALID_IOCTL(ops, VIDIOC_ENUMAUDOUT, vidioc_enumaudout);
759 			SET_VALID_IOCTL(ops, VIDIOC_G_AUDOUT, vidioc_g_audout);
760 			SET_VALID_IOCTL(ops, VIDIOC_S_AUDOUT, vidioc_s_audout);
761 		}
762 		if (ops->vidioc_g_parm || ops->vidioc_g_std)
763 			__set_bit(_IOC_NR(VIDIOC_G_PARM), valid_ioctls);
764 		SET_VALID_IOCTL(ops, VIDIOC_S_PARM, vidioc_s_parm);
765 		SET_VALID_IOCTL(ops, VIDIOC_S_DV_TIMINGS, vidioc_s_dv_timings);
766 		SET_VALID_IOCTL(ops, VIDIOC_G_DV_TIMINGS, vidioc_g_dv_timings);
767 		SET_VALID_IOCTL(ops, VIDIOC_ENUM_DV_TIMINGS, vidioc_enum_dv_timings);
768 		SET_VALID_IOCTL(ops, VIDIOC_DV_TIMINGS_CAP, vidioc_dv_timings_cap);
769 		SET_VALID_IOCTL(ops, VIDIOC_G_EDID, vidioc_g_edid);
770 	}
771 	if (is_tx && (is_radio || is_sdr)) {
772 		/* radio transmitter only ioctls */
773 		SET_VALID_IOCTL(ops, VIDIOC_G_MODULATOR, vidioc_g_modulator);
774 		SET_VALID_IOCTL(ops, VIDIOC_S_MODULATOR, vidioc_s_modulator);
775 	}
776 	if (is_rx && !is_tch) {
777 		/* receiver only ioctls */
778 		SET_VALID_IOCTL(ops, VIDIOC_G_TUNER, vidioc_g_tuner);
779 		SET_VALID_IOCTL(ops, VIDIOC_S_TUNER, vidioc_s_tuner);
780 		SET_VALID_IOCTL(ops, VIDIOC_S_HW_FREQ_SEEK, vidioc_s_hw_freq_seek);
781 	}
782 
783 	bitmap_andnot(vdev->valid_ioctls, valid_ioctls, vdev->valid_ioctls,
784 			BASE_VIDIOC_PRIVATE);
785 }
786 
787 static int video_register_media_controller(struct video_device *vdev)
788 {
789 #if defined(CONFIG_MEDIA_CONTROLLER)
790 	u32 intf_type;
791 	int ret;
792 
793 	/* Memory-to-memory devices are more complex and use
794 	 * their own function to register its mc entities.
795 	 */
796 	if (!vdev->v4l2_dev->mdev || vdev->vfl_dir == VFL_DIR_M2M)
797 		return 0;
798 
799 	vdev->entity.obj_type = MEDIA_ENTITY_TYPE_VIDEO_DEVICE;
800 	vdev->entity.function = MEDIA_ENT_F_UNKNOWN;
801 
802 	switch (vdev->vfl_type) {
803 	case VFL_TYPE_VIDEO:
804 		intf_type = MEDIA_INTF_T_V4L_VIDEO;
805 		vdev->entity.function = MEDIA_ENT_F_IO_V4L;
806 		break;
807 	case VFL_TYPE_VBI:
808 		intf_type = MEDIA_INTF_T_V4L_VBI;
809 		vdev->entity.function = MEDIA_ENT_F_IO_VBI;
810 		break;
811 	case VFL_TYPE_SDR:
812 		intf_type = MEDIA_INTF_T_V4L_SWRADIO;
813 		vdev->entity.function = MEDIA_ENT_F_IO_SWRADIO;
814 		break;
815 	case VFL_TYPE_TOUCH:
816 		intf_type = MEDIA_INTF_T_V4L_TOUCH;
817 		vdev->entity.function = MEDIA_ENT_F_IO_V4L;
818 		break;
819 	case VFL_TYPE_RADIO:
820 		intf_type = MEDIA_INTF_T_V4L_RADIO;
821 		/*
822 		 * Radio doesn't have an entity at the V4L2 side to represent
823 		 * radio input or output. Instead, the audio input/output goes
824 		 * via either physical wires or ALSA.
825 		 */
826 		break;
827 	case VFL_TYPE_SUBDEV:
828 		intf_type = MEDIA_INTF_T_V4L_SUBDEV;
829 		/* Entity will be created via v4l2_device_register_subdev() */
830 		break;
831 	default:
832 		return 0;
833 	}
834 
835 	if (vdev->entity.function != MEDIA_ENT_F_UNKNOWN) {
836 		vdev->entity.name = vdev->name;
837 
838 		/* Needed just for backward compatibility with legacy MC API */
839 		vdev->entity.info.dev.major = VIDEO_MAJOR;
840 		vdev->entity.info.dev.minor = vdev->minor;
841 
842 		ret = media_device_register_entity(vdev->v4l2_dev->mdev,
843 						   &vdev->entity);
844 		if (ret < 0) {
845 			pr_warn("%s: media_device_register_entity failed\n",
846 				__func__);
847 			return ret;
848 		}
849 	}
850 
851 	vdev->intf_devnode = media_devnode_create(vdev->v4l2_dev->mdev,
852 						  intf_type,
853 						  0, VIDEO_MAJOR,
854 						  vdev->minor);
855 	if (!vdev->intf_devnode) {
856 		media_device_unregister_entity(&vdev->entity);
857 		return -ENOMEM;
858 	}
859 
860 	if (vdev->entity.function != MEDIA_ENT_F_UNKNOWN) {
861 		struct media_link *link;
862 
863 		link = media_create_intf_link(&vdev->entity,
864 					      &vdev->intf_devnode->intf,
865 					      MEDIA_LNK_FL_ENABLED |
866 					      MEDIA_LNK_FL_IMMUTABLE);
867 		if (!link) {
868 			media_devnode_remove(vdev->intf_devnode);
869 			media_device_unregister_entity(&vdev->entity);
870 			return -ENOMEM;
871 		}
872 	}
873 
874 	/* FIXME: how to create the other interface links? */
875 
876 #endif
877 	return 0;
878 }
879 
880 int __video_register_device(struct video_device *vdev,
881 			    enum vfl_devnode_type type,
882 			    int nr, int warn_if_nr_in_use,
883 			    struct module *owner)
884 {
885 	int i = 0;
886 	int ret;
887 	int minor_offset = 0;
888 	int minor_cnt = VIDEO_NUM_DEVICES;
889 	const char *name_base;
890 
891 	/* A minor value of -1 marks this video device as never
892 	   having been registered */
893 	vdev->minor = -1;
894 
895 	/* the release callback MUST be present */
896 	if (WARN_ON(!vdev->release))
897 		return -EINVAL;
898 	/* the v4l2_dev pointer MUST be present */
899 	if (WARN_ON(!vdev->v4l2_dev))
900 		return -EINVAL;
901 	/* the device_caps field MUST be set for all but subdevs */
902 	if (WARN_ON(type != VFL_TYPE_SUBDEV && !vdev->device_caps))
903 		return -EINVAL;
904 
905 	/* v4l2_fh support */
906 	spin_lock_init(&vdev->fh_lock);
907 	INIT_LIST_HEAD(&vdev->fh_list);
908 
909 	/* Part 1: check device type */
910 	switch (type) {
911 	case VFL_TYPE_VIDEO:
912 		name_base = "video";
913 		break;
914 	case VFL_TYPE_VBI:
915 		name_base = "vbi";
916 		break;
917 	case VFL_TYPE_RADIO:
918 		name_base = "radio";
919 		break;
920 	case VFL_TYPE_SUBDEV:
921 		name_base = "v4l-subdev";
922 		break;
923 	case VFL_TYPE_SDR:
924 		/* Use device name 'swradio' because 'sdr' was already taken. */
925 		name_base = "swradio";
926 		break;
927 	case VFL_TYPE_TOUCH:
928 		name_base = "v4l-touch";
929 		break;
930 	default:
931 		pr_err("%s called with unknown type: %d\n",
932 		       __func__, type);
933 		return -EINVAL;
934 	}
935 
936 	vdev->vfl_type = type;
937 	vdev->cdev = NULL;
938 	if (vdev->dev_parent == NULL)
939 		vdev->dev_parent = vdev->v4l2_dev->dev;
940 	if (vdev->ctrl_handler == NULL)
941 		vdev->ctrl_handler = vdev->v4l2_dev->ctrl_handler;
942 	/* If the prio state pointer is NULL, then use the v4l2_device
943 	   prio state. */
944 	if (vdev->prio == NULL)
945 		vdev->prio = &vdev->v4l2_dev->prio;
946 
947 	/* Part 2: find a free minor, device node number and device index. */
948 #ifdef CONFIG_VIDEO_FIXED_MINOR_RANGES
949 	/* Keep the ranges for the first four types for historical
950 	 * reasons.
951 	 * Newer devices (not yet in place) should use the range
952 	 * of 128-191 and just pick the first free minor there
953 	 * (new style). */
954 	switch (type) {
955 	case VFL_TYPE_VIDEO:
956 		minor_offset = 0;
957 		minor_cnt = 64;
958 		break;
959 	case VFL_TYPE_RADIO:
960 		minor_offset = 64;
961 		minor_cnt = 64;
962 		break;
963 	case VFL_TYPE_VBI:
964 		minor_offset = 224;
965 		minor_cnt = 32;
966 		break;
967 	default:
968 		minor_offset = 128;
969 		minor_cnt = 64;
970 		break;
971 	}
972 #endif
973 
974 	/* Pick a device node number */
975 	mutex_lock(&videodev_lock);
976 	nr = devnode_find(vdev, nr == -1 ? 0 : nr, minor_cnt);
977 	if (nr == minor_cnt)
978 		nr = devnode_find(vdev, 0, minor_cnt);
979 	if (nr == minor_cnt) {
980 		pr_err("could not get a free device node number\n");
981 		mutex_unlock(&videodev_lock);
982 		return -ENFILE;
983 	}
984 #ifdef CONFIG_VIDEO_FIXED_MINOR_RANGES
985 	/* 1-on-1 mapping of device node number to minor number */
986 	i = nr;
987 #else
988 	/* The device node number and minor numbers are independent, so
989 	   we just find the first free minor number. */
990 	for (i = 0; i < VIDEO_NUM_DEVICES; i++)
991 		if (video_devices[i] == NULL)
992 			break;
993 	if (i == VIDEO_NUM_DEVICES) {
994 		mutex_unlock(&videodev_lock);
995 		pr_err("could not get a free minor\n");
996 		return -ENFILE;
997 	}
998 #endif
999 	vdev->minor = i + minor_offset;
1000 	vdev->num = nr;
1001 
1002 	/* Should not happen since we thought this minor was free */
1003 	if (WARN_ON(video_devices[vdev->minor])) {
1004 		mutex_unlock(&videodev_lock);
1005 		pr_err("video_device not empty!\n");
1006 		return -ENFILE;
1007 	}
1008 	devnode_set(vdev);
1009 	vdev->index = get_index(vdev);
1010 	video_devices[vdev->minor] = vdev;
1011 	mutex_unlock(&videodev_lock);
1012 
1013 	if (vdev->ioctl_ops)
1014 		determine_valid_ioctls(vdev);
1015 
1016 	/* Part 3: Initialize the character device */
1017 	vdev->cdev = cdev_alloc();
1018 	if (vdev->cdev == NULL) {
1019 		ret = -ENOMEM;
1020 		goto cleanup;
1021 	}
1022 	vdev->cdev->ops = &v4l2_fops;
1023 	vdev->cdev->owner = owner;
1024 	ret = cdev_add(vdev->cdev, MKDEV(VIDEO_MAJOR, vdev->minor), 1);
1025 	if (ret < 0) {
1026 		pr_err("%s: cdev_add failed\n", __func__);
1027 		kfree(vdev->cdev);
1028 		vdev->cdev = NULL;
1029 		goto cleanup;
1030 	}
1031 
1032 	/* Part 4: register the device with sysfs */
1033 	vdev->dev.class = &video_class;
1034 	vdev->dev.devt = MKDEV(VIDEO_MAJOR, vdev->minor);
1035 	vdev->dev.parent = vdev->dev_parent;
1036 	dev_set_name(&vdev->dev, "%s%d", name_base, vdev->num);
1037 	ret = device_register(&vdev->dev);
1038 	if (ret < 0) {
1039 		pr_err("%s: device_register failed\n", __func__);
1040 		goto cleanup;
1041 	}
1042 	/* Register the release callback that will be called when the last
1043 	   reference to the device goes away. */
1044 	vdev->dev.release = v4l2_device_release;
1045 
1046 	if (nr != -1 && nr != vdev->num && warn_if_nr_in_use)
1047 		pr_warn("%s: requested %s%d, got %s\n", __func__,
1048 			name_base, nr, video_device_node_name(vdev));
1049 
1050 	/* Increase v4l2_device refcount */
1051 	v4l2_device_get(vdev->v4l2_dev);
1052 
1053 	/* Part 5: Register the entity. */
1054 	ret = video_register_media_controller(vdev);
1055 
1056 	/* Part 6: Activate this minor. The char device can now be used. */
1057 	set_bit(V4L2_FL_REGISTERED, &vdev->flags);
1058 
1059 	return 0;
1060 
1061 cleanup:
1062 	mutex_lock(&videodev_lock);
1063 	if (vdev->cdev)
1064 		cdev_del(vdev->cdev);
1065 	video_devices[vdev->minor] = NULL;
1066 	devnode_clear(vdev);
1067 	mutex_unlock(&videodev_lock);
1068 	/* Mark this video device as never having been registered. */
1069 	vdev->minor = -1;
1070 	return ret;
1071 }
1072 EXPORT_SYMBOL(__video_register_device);
1073 
1074 /**
1075  *	video_unregister_device - unregister a video4linux device
1076  *	@vdev: the device to unregister
1077  *
1078  *	This unregisters the passed device. Future open calls will
1079  *	be met with errors.
1080  */
1081 void video_unregister_device(struct video_device *vdev)
1082 {
1083 	/* Check if vdev was ever registered at all */
1084 	if (!vdev || !video_is_registered(vdev))
1085 		return;
1086 
1087 	mutex_lock(&videodev_lock);
1088 	/* This must be in a critical section to prevent a race with v4l2_open.
1089 	 * Once this bit has been cleared video_get may never be called again.
1090 	 */
1091 	clear_bit(V4L2_FL_REGISTERED, &vdev->flags);
1092 	mutex_unlock(&videodev_lock);
1093 	if (test_bit(V4L2_FL_USES_V4L2_FH, &vdev->flags))
1094 		v4l2_event_wake_all(vdev);
1095 	device_unregister(&vdev->dev);
1096 }
1097 EXPORT_SYMBOL(video_unregister_device);
1098 
1099 #if defined(CONFIG_MEDIA_CONTROLLER)
1100 
1101 __must_check int video_device_pipeline_start(struct video_device *vdev,
1102 					     struct media_pipeline *pipe)
1103 {
1104 	struct media_entity *entity = &vdev->entity;
1105 
1106 	if (entity->num_pads != 1)
1107 		return -ENODEV;
1108 
1109 	return media_pipeline_start(&entity->pads[0], pipe);
1110 }
1111 EXPORT_SYMBOL_GPL(video_device_pipeline_start);
1112 
1113 __must_check int __video_device_pipeline_start(struct video_device *vdev,
1114 					       struct media_pipeline *pipe)
1115 {
1116 	struct media_entity *entity = &vdev->entity;
1117 
1118 	if (entity->num_pads != 1)
1119 		return -ENODEV;
1120 
1121 	return __media_pipeline_start(&entity->pads[0], pipe);
1122 }
1123 EXPORT_SYMBOL_GPL(__video_device_pipeline_start);
1124 
1125 void video_device_pipeline_stop(struct video_device *vdev)
1126 {
1127 	struct media_entity *entity = &vdev->entity;
1128 
1129 	if (WARN_ON(entity->num_pads != 1))
1130 		return;
1131 
1132 	return media_pipeline_stop(&entity->pads[0]);
1133 }
1134 EXPORT_SYMBOL_GPL(video_device_pipeline_stop);
1135 
1136 void __video_device_pipeline_stop(struct video_device *vdev)
1137 {
1138 	struct media_entity *entity = &vdev->entity;
1139 
1140 	if (WARN_ON(entity->num_pads != 1))
1141 		return;
1142 
1143 	return __media_pipeline_stop(&entity->pads[0]);
1144 }
1145 EXPORT_SYMBOL_GPL(__video_device_pipeline_stop);
1146 
1147 __must_check int video_device_pipeline_alloc_start(struct video_device *vdev)
1148 {
1149 	struct media_entity *entity = &vdev->entity;
1150 
1151 	if (entity->num_pads != 1)
1152 		return -ENODEV;
1153 
1154 	return media_pipeline_alloc_start(&entity->pads[0]);
1155 }
1156 EXPORT_SYMBOL_GPL(video_device_pipeline_alloc_start);
1157 
1158 struct media_pipeline *video_device_pipeline(struct video_device *vdev)
1159 {
1160 	struct media_entity *entity = &vdev->entity;
1161 
1162 	if (WARN_ON(entity->num_pads != 1))
1163 		return NULL;
1164 
1165 	return media_pad_pipeline(&entity->pads[0]);
1166 }
1167 EXPORT_SYMBOL_GPL(video_device_pipeline);
1168 
1169 #endif /* CONFIG_MEDIA_CONTROLLER */
1170 
1171 /*
1172  *	Initialise video for linux
1173  */
1174 static int __init videodev_init(void)
1175 {
1176 	dev_t dev = MKDEV(VIDEO_MAJOR, 0);
1177 	int ret;
1178 
1179 	pr_info("Linux video capture interface: v2.00\n");
1180 	ret = register_chrdev_region(dev, VIDEO_NUM_DEVICES, VIDEO_NAME);
1181 	if (ret < 0) {
1182 		pr_warn("videodev: unable to get major %d\n",
1183 				VIDEO_MAJOR);
1184 		return ret;
1185 	}
1186 
1187 	ret = class_register(&video_class);
1188 	if (ret < 0) {
1189 		unregister_chrdev_region(dev, VIDEO_NUM_DEVICES);
1190 		pr_warn("video_dev: class_register failed\n");
1191 		return -EIO;
1192 	}
1193 
1194 	return 0;
1195 }
1196 
1197 static void __exit videodev_exit(void)
1198 {
1199 	dev_t dev = MKDEV(VIDEO_MAJOR, 0);
1200 
1201 	class_unregister(&video_class);
1202 	unregister_chrdev_region(dev, VIDEO_NUM_DEVICES);
1203 }
1204 
1205 subsys_initcall(videodev_init);
1206 module_exit(videodev_exit)
1207 
1208 MODULE_AUTHOR("Alan Cox, Mauro Carvalho Chehab <mchehab@kernel.org>, Bill Dirks, Justin Schoeman, Gerd Knorr");
1209 MODULE_DESCRIPTION("Video4Linux2 core driver");
1210 MODULE_LICENSE("GPL");
1211 MODULE_ALIAS_CHARDEV_MAJOR(VIDEO_MAJOR);
1212