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