[mirror_ubuntu-bionic-kernel.git] / drivers / media / video / v4l2-dev.c

/*
 * Video capture interface for Linux version 2
 *
 *	A generic video device interface for the LINUX operating system
 *	using a set of device structures/vectors for low level operations.
 *
 *	This program is free software; you can redistribute it and/or
 *	modify it under the terms of the GNU General Public License
 *	as published by the Free Software Foundation; either version
 *	2 of the License, or (at your option) any later version.
 *
 * Authors:	Alan Cox, <alan@redhat.com> (version 1)
 *              Mauro Carvalho Chehab <mchehab@infradead.org> (version 2)
 *
 * Fixes:	20000516  Claudio Matsuoka <claudio@conectiva.com>
 *		- Added procfs support
 */

#include <linux/module.h>
#include <linux/types.h>
#include <linux/kernel.h>
#include <linux/mm.h>
#include <linux/string.h>
#include <linux/errno.h>
#include <linux/init.h>
#include <linux/kmod.h>
#include <linux/slab.h>
#include <linux/smp_lock.h>
#include <asm/uaccess.h>
#include <asm/system.h>

#include <media/v4l2-common.h>

#define VIDEO_NUM_DEVICES	256
#define VIDEO_NAME              "video4linux"

/*
 *	sysfs stuff
 */

static ssize_t show_index(struct device *cd,
			 struct device_attribute *attr, char *buf)
{
	struct video_device *vfd = container_of(cd, struct video_device, dev);

	return sprintf(buf, "%i\n", vfd->index);
}

static ssize_t show_name(struct device *cd,
			 struct device_attribute *attr, char *buf)
{
	struct video_device *vfd = container_of(cd, struct video_device, dev);

	return sprintf(buf, "%.*s\n", (int)sizeof(vfd->name), vfd->name);
}

static struct device_attribute video_device_attrs[] = {
	__ATTR(name, S_IRUGO, show_name, NULL),
	__ATTR(index, S_IRUGO, show_index, NULL),
	__ATTR_NULL
};

/*
 *	Active devices
 */
static struct video_device *video_device[VIDEO_NUM_DEVICES];
static DEFINE_MUTEX(videodev_lock);

struct video_device *video_device_alloc(void)
{
	return kzalloc(sizeof(struct video_device), GFP_KERNEL);
}
EXPORT_SYMBOL(video_device_alloc);

void video_device_release(struct video_device *vfd)
{
	kfree(vfd);
}
EXPORT_SYMBOL(video_device_release);

void video_device_release_empty(struct video_device *vfd)
{
	/* Do nothing */
	/* Only valid when the video_device struct is a static. */
}
EXPORT_SYMBOL(video_device_release_empty);

/* Called when the last user of the character device is gone. */
static void v4l2_chardev_release(struct kobject *kobj)
{
	struct video_device *vfd = container_of(kobj, struct video_device, cdev.kobj);

	mutex_lock(&videodev_lock);
	if (video_device[vfd->minor] != vfd)
		panic("videodev: bad release");

	/* Free up this device for reuse */
	video_device[vfd->minor] = NULL;
	mutex_unlock(&videodev_lock);

	/* Release the character device */
	vfd->cdev_release(kobj);
	/* Release video_device and perform other
	   cleanups as needed. */
	if (vfd->release)
		vfd->release(vfd);
}

/* The new kobj_type for the character device */
static struct kobj_type v4l2_ktype_cdev_default = {
	.release = v4l2_chardev_release,
};

static void video_release(struct device *cd)
{
	struct video_device *vfd = container_of(cd, struct video_device, dev);

	/* It's now safe to delete the char device.
	   This will either trigger the v4l2_chardev_release immediately (if
	   the refcount goes to 0) or later when the last user of the
	   character device closes it. */
	cdev_del(&vfd->cdev);
}

static struct class video_class = {
	.name = VIDEO_NAME,
	.dev_attrs = video_device_attrs,
	.dev_release = video_release,
};

struct video_device *video_devdata(struct file *file)
{
	return video_device[iminor(file->f_path.dentry->d_inode)];
}
EXPORT_SYMBOL(video_devdata);

/**
 * get_index - assign stream number based on parent device
 * @vdev: video_device to assign index number to, vdev->dev should be assigned
 * @num: -1 if auto assign, requested number otherwise
 *
 *
 * returns -ENFILE if num is already in use, a free index number if
 * successful.
 */
static int get_index(struct video_device *vdev, int num)
{
	u32 used = 0;
	const int max_index = sizeof(used) * 8 - 1;
	int i;

	/* Currently a single v4l driver instance cannot create more than
	   32 devices.
	   Increase to u64 or an array of u32 if more are needed. */
	if (num > max_index) {
		printk(KERN_ERR "videodev: %s num is too large\n", __func__);
		return -EINVAL;
	}

	for (i = 0; i < VIDEO_NUM_DEVICES; i++) {
		if (video_device[i] != NULL &&
		    video_device[i] != vdev &&
		    video_device[i]->parent == vdev->parent) {
			used |= 1 << video_device[i]->index;
		}
	}

	if (num >= 0) {
		if (used & (1 << num))
			return -ENFILE;
		return num;
	}

	i = ffz(used);
	return i > max_index ? -ENFILE : i;
}

static const struct file_operations video_fops;

int video_register_device(struct video_device *vfd, int type, int nr)
{
	return video_register_device_index(vfd, type, nr, -1);
}
EXPORT_SYMBOL(video_register_device);

/**
 *	video_register_device_index - register video4linux devices
 *	@vfd:  video device structure we want to register
 *	@type: type of device to register
 *	@nr:   which device number (0 == /dev/video0, 1 == /dev/video1, ...
 *             -1 == first free)
 *	@index: stream number based on parent device;
 *		-1 if auto assign, requested number otherwise
 *
 *	The registration code assigns minor numbers based on the type
 *	requested. -ENFILE is returned in all the device slots for this
 *	category are full. If not then the minor field is set and the
 *	driver initialize function is called (if non %NULL).
 *
 *	Zero is returned on success.
 *
 *	Valid types are
 *
 *	%VFL_TYPE_GRABBER - A frame grabber
 *
 *	%VFL_TYPE_VTX - A teletext device
 *
 *	%VFL_TYPE_VBI - Vertical blank data (undecoded)
 *
 *	%VFL_TYPE_RADIO - A radio card
 */

int video_register_device_index(struct video_device *vfd, int type, int nr,
					int index)
{
	int i = 0;
	int base;
	int end;
	int ret;
	char *name_base;
	void *priv = video_get_drvdata(vfd);

	/* the release callback MUST be present */
	BUG_ON(!vfd->release);

	if (vfd == NULL)
		return -EINVAL;

	switch (type) {
	case VFL_TYPE_GRABBER:
		base = MINOR_VFL_TYPE_GRABBER_MIN;
		end = MINOR_VFL_TYPE_GRABBER_MAX+1;
		name_base = "video";
		break;
	case VFL_TYPE_VTX:
		base = MINOR_VFL_TYPE_VTX_MIN;
		end = MINOR_VFL_TYPE_VTX_MAX+1;
		name_base = "vtx";
		break;
	case VFL_TYPE_VBI:
		base = MINOR_VFL_TYPE_VBI_MIN;
		end = MINOR_VFL_TYPE_VBI_MAX+1;
		name_base = "vbi";
		break;
	case VFL_TYPE_RADIO:
		base = MINOR_VFL_TYPE_RADIO_MIN;
		end = MINOR_VFL_TYPE_RADIO_MAX+1;
		name_base = "radio";
		break;
	default:
		printk(KERN_ERR "%s called with unknown type: %d\n",
		       __func__, type);
		return -EINVAL;
	}

	/* Initialize the character device */
	cdev_init(&vfd->cdev, vfd->fops);
	vfd->cdev.owner = vfd->fops->owner;
	/* pick a minor number */
	mutex_lock(&videodev_lock);
	if (nr >= 0 && nr < end-base) {
		/* use the one the driver asked for */
		i = base + nr;
		if (NULL != video_device[i]) {
			mutex_unlock(&videodev_lock);
			return -ENFILE;
		}
	} else {
		/* use first free */
		for (i = base; i < end; i++)
			if (NULL == video_device[i])
				break;
		if (i == end) {
			mutex_unlock(&videodev_lock);
			return -ENFILE;
		}
	}
	video_device[i] = vfd;
	vfd->vfl_type = type;
	vfd->minor = i;

	ret = get_index(vfd, index);
	vfd->index = ret;

	mutex_unlock(&videodev_lock);

	if (ret < 0) {
		printk(KERN_ERR "%s: get_index failed\n", __func__);
		goto fail_minor;
	}

	ret = cdev_add(&vfd->cdev, MKDEV(VIDEO_MAJOR, vfd->minor), 1);
	if (ret < 0) {
		printk(KERN_ERR "%s: cdev_add failed\n", __func__);
		goto fail_minor;
	}
	/* sysfs class */
	memset(&vfd->dev, 0, sizeof(vfd->dev));
	/* The memset above cleared the device's drvdata, so
	   put back the copy we made earlier. */
	video_set_drvdata(vfd, priv);
	vfd->dev.class = &video_class;
	vfd->dev.devt = MKDEV(VIDEO_MAJOR, vfd->minor);
	if (vfd->parent)
		vfd->dev.parent = vfd->parent;
	sprintf(vfd->dev.bus_id, "%s%d", name_base, i - base);
	ret = device_register(&vfd->dev);
	if (ret < 0) {
		printk(KERN_ERR "%s: device_register failed\n", __func__);
		goto del_cdev;
	}
	/* Remember the cdev's release function */
	vfd->cdev_release = vfd->cdev.kobj.ktype->release;
	/* Install our own */
	vfd->cdev.kobj.ktype = &v4l2_ktype_cdev_default;
	return 0;

del_cdev:
	cdev_del(&vfd->cdev);

fail_minor:
	mutex_lock(&videodev_lock);
	video_device[vfd->minor] = NULL;
	mutex_unlock(&videodev_lock);
	vfd->minor = -1;
	return ret;
}
EXPORT_SYMBOL(video_register_device_index);

/**
 *	video_unregister_device - unregister a video4linux device
 *	@vfd: the device to unregister
 *
 *	This unregisters the passed device and deassigns the minor
 *	number. Future open calls will be met with errors.
 */

void video_unregister_device(struct video_device *vfd)
{
	device_unregister(&vfd->dev);
}
EXPORT_SYMBOL(video_unregister_device);

/*
 *	Initialise video for linux
 */
static int __init videodev_init(void)
{
	dev_t dev = MKDEV(VIDEO_MAJOR, 0);
	int ret;

	printk(KERN_INFO "Linux video capture interface: v2.00\n");
	ret = register_chrdev_region(dev, VIDEO_NUM_DEVICES, VIDEO_NAME);
	if (ret < 0) {
		printk(KERN_WARNING "videodev: unable to get major %d\n",
				VIDEO_MAJOR);
		return ret;
	}

	ret = class_register(&video_class);
	if (ret < 0) {
		unregister_chrdev_region(dev, VIDEO_NUM_DEVICES);
		printk(KERN_WARNING "video_dev: class_register failed\n");
		return -EIO;
	}

	return 0;
}

static void __exit videodev_exit(void)
{
	dev_t dev = MKDEV(VIDEO_MAJOR, 0);

	class_unregister(&video_class);
	unregister_chrdev_region(dev, VIDEO_NUM_DEVICES);
}

module_init(videodev_init)
module_exit(videodev_exit)

MODULE_AUTHOR("Alan Cox, Mauro Carvalho Chehab <mchehab@infradead.org>");
MODULE_DESCRIPTION("Device registrar for Video4Linux drivers v2");
MODULE_LICENSE("GPL");


/*
 * Local variables:
 * c-basic-offset: 8
 * End:
 */
Commit	Line	Data
27a5e6d3 HV	1	/*
	2	* Video capture interface for Linux version 2
	3	*
	4	* A generic video device interface for the LINUX operating system
	5	* using a set of device structures/vectors for low level operations.
	6	*
	7	* This program is free software; you can redistribute it and/or
	8	* modify it under the terms of the GNU General Public License
	9	* as published by the Free Software Foundation; either version
	10	* 2 of the License, or (at your option) any later version.
	11	*
	12	* Authors: Alan Cox, <alan@redhat.com> (version 1)
	13	* Mauro Carvalho Chehab <mchehab@infradead.org> (version 2)
	14	*
	15	* Fixes: 20000516 Claudio Matsuoka <claudio@conectiva.com>
	16	* - Added procfs support
	17	*/
	18
	19	#include <linux/module.h>
	20	#include <linux/types.h>
	21	#include <linux/kernel.h>
	22	#include <linux/mm.h>
	23	#include <linux/string.h>
	24	#include <linux/errno.h>
	25	#include <linux/init.h>
	26	#include <linux/kmod.h>
	27	#include <linux/slab.h>
	28	#include <linux/smp_lock.h>
	29	#include <asm/uaccess.h>
	30	#include <asm/system.h>
	31
	32	#include <media/v4l2-common.h>
	33
	34	#define VIDEO_NUM_DEVICES 256
	35	#define VIDEO_NAME "video4linux"
	36
	37	/*
	38	* sysfs stuff
	39	*/
	40
	41	static ssize_t show_index(struct device *cd,
	42	struct device_attribute attr, char buf)
	43	{
22a04f10	44	struct video_device *vfd = container_of(cd, struct video_device, dev);
bfa8a273	45
27a5e6d3 HV	46	return sprintf(buf, "%i\n", vfd->index);
	47	}
	48
	49	static ssize_t show_name(struct device *cd,
	50	struct device_attribute attr, char buf)
	51	{
22a04f10	52	struct video_device *vfd = container_of(cd, struct video_device, dev);
bfa8a273	53
27a5e6d3 HV	54	return sprintf(buf, "%.*s\n", (int)sizeof(vfd->name), vfd->name);
	55	}
	56
	57	static struct device_attribute video_device_attrs[] = {
	58	__ATTR(name, S_IRUGO, show_name, NULL),
	59	__ATTR(index, S_IRUGO, show_index, NULL),
	60	__ATTR_NULL
	61	};
	62
7f8ecfab HV	63	/*
	64	* Active devices
	65	*/
	66	static struct video_device *video_device[VIDEO_NUM_DEVICES];
	67	static DEFINE_MUTEX(videodev_lock);
	68
27a5e6d3 HV	69	struct video_device *video_device_alloc(void)
27a5e6d3 HV	70	{
bfa8a273	71	return kzalloc(sizeof(struct video_device), GFP_KERNEL);
27a5e6d3 HV	72	}
	73	EXPORT_SYMBOL(video_device_alloc);
	74
	75	void video_device_release(struct video_device *vfd)
	76	{
	77	kfree(vfd);
	78	}
	79	EXPORT_SYMBOL(video_device_release);
	80
f9e86b5e HV	81	void video_device_release_empty(struct video_device *vfd)
	82	{
	83	/* Do nothing */
	84	/* Only valid when the video_device struct is a static. */
	85	}
	86	EXPORT_SYMBOL(video_device_release_empty);
	87
7f8ecfab HV	88	/* Called when the last user of the character device is gone. */
	89	static void v4l2_chardev_release(struct kobject *kobj)
	90	{
	91	struct video_device *vfd = container_of(kobj, struct video_device, cdev.kobj);
	92
	93	mutex_lock(&videodev_lock);
	94	if (video_device[vfd->minor] != vfd)
	95	panic("videodev: bad release");
	96
	97	/* Free up this device for reuse */
	98	video_device[vfd->minor] = NULL;
	99	mutex_unlock(&videodev_lock);
	100
	101	/* Release the character device */
	102	vfd->cdev_release(kobj);
	103	/* Release video_device and perform other
	104	cleanups as needed. */
	105	if (vfd->release)
	106	vfd->release(vfd);
	107	}
	108
	109	/* The new kobj_type for the character device */
	110	static struct kobj_type v4l2_ktype_cdev_default = {
	111	.release = v4l2_chardev_release,
	112	};
	113
27a5e6d3 HV	114	static void video_release(struct device *cd)
27a5e6d3 HV	115	{
22a04f10	116	struct video_device *vfd = container_of(cd, struct video_device, dev);
27a5e6d3	117
7f8ecfab HV	118	/* It's now safe to delete the char device.
	119	This will either trigger the v4l2_chardev_release immediately (if
	120	the refcount goes to 0) or later when the last user of the
	121	character device closes it. */
	122	cdev_del(&vfd->cdev);
27a5e6d3 HV	123	}
	124
	125	static struct class video_class = {
	126	.name = VIDEO_NAME,
	127	.dev_attrs = video_device_attrs,
	128	.dev_release = video_release,
	129	};
	130
27a5e6d3 HV	131	struct video_device video_devdata(struct file file)
	132	{
	133	return video_device[iminor(file->f_path.dentry->d_inode)];
	134	}
	135	EXPORT_SYMBOL(video_devdata);
	136
27a5e6d3 HV	137	/**
	138	* get_index - assign stream number based on parent device
	139	* @vdev: video_device to assign index number to, vdev->dev should be assigned
	140	* @num: -1 if auto assign, requested number otherwise
	141	*
	142	*
	143	* returns -ENFILE if num is already in use, a free index number if
	144	* successful.
	145	*/
	146	static int get_index(struct video_device *vdev, int num)
	147	{
	148	u32 used = 0;
	149	const int max_index = sizeof(used) * 8 - 1;
	150	int i;
	151
	152	/* Currently a single v4l driver instance cannot create more than
	153	32 devices.
	154	Increase to u64 or an array of u32 if more are needed. */
	155	if (num > max_index) {
	156	printk(KERN_ERR "videodev: %s num is too large\n", __func__);
	157	return -EINVAL;
	158	}
	159
	160	for (i = 0; i < VIDEO_NUM_DEVICES; i++) {
	161	if (video_device[i] != NULL &&
	162	video_device[i] != vdev &&
5e85e732	163	video_device[i]->parent == vdev->parent) {
27a5e6d3 HV	164	used \|= 1 << video_device[i]->index;
	165	}
	166	}
	167
	168	if (num >= 0) {
	169	if (used & (1 << num))
	170	return -ENFILE;
	171	return num;
	172	}
	173
	174	i = ffz(used);
	175	return i > max_index ? -ENFILE : i;
	176	}
	177
	178	static const struct file_operations video_fops;
	179
	180	int video_register_device(struct video_device *vfd, int type, int nr)
	181	{
	182	return video_register_device_index(vfd, type, nr, -1);
	183	}
	184	EXPORT_SYMBOL(video_register_device);
	185
	186	/**
edc9189c	187	* video_register_device_index - register video4linux devices
27a5e6d3 HV	188	* @vfd: video device structure we want to register
	189	* @type: type of device to register
	190	* @nr: which device number (0 == /dev/video0, 1 == /dev/video1, ...
	191	* -1 == first free)
edc9189c RD	192	* @index: stream number based on parent device;
edc9189c RD	193	* -1 if auto assign, requested number otherwise
27a5e6d3 HV	194	*
	195	* The registration code assigns minor numbers based on the type
	196	* requested. -ENFILE is returned in all the device slots for this
	197	* category are full. If not then the minor field is set and the
	198	* driver initialize function is called (if non %NULL).
	199	*
	200	* Zero is returned on success.
	201	*
	202	* Valid types are
	203	*
	204	* %VFL_TYPE_GRABBER - A frame grabber
	205	*
	206	* %VFL_TYPE_VTX - A teletext device
	207	*
	208	* %VFL_TYPE_VBI - Vertical blank data (undecoded)
	209	*
	210	* %VFL_TYPE_RADIO - A radio card
	211	*/
	212
	213	int video_register_device_index(struct video_device *vfd, int type, int nr,
	214	int index)
	215	{
	216	int i = 0;
	217	int base;
	218	int end;
	219	int ret;
	220	char *name_base;
9d95af9d	221	void *priv = video_get_drvdata(vfd);
27a5e6d3	222
d6e7497e HV	223	/* the release callback MUST be present */
d6e7497e HV	224	BUG_ON(!vfd->release);
ee7aa9f8	225
f3b9f50e HK	226	if (vfd == NULL)
	227	return -EINVAL;
	228
27a5e6d3 HV	229	switch (type) {
	230	case VFL_TYPE_GRABBER:
	231	base = MINOR_VFL_TYPE_GRABBER_MIN;
	232	end = MINOR_VFL_TYPE_GRABBER_MAX+1;
	233	name_base = "video";
	234	break;
	235	case VFL_TYPE_VTX:
	236	base = MINOR_VFL_TYPE_VTX_MIN;
	237	end = MINOR_VFL_TYPE_VTX_MAX+1;
	238	name_base = "vtx";
	239	break;
	240	case VFL_TYPE_VBI:
	241	base = MINOR_VFL_TYPE_VBI_MIN;
	242	end = MINOR_VFL_TYPE_VBI_MAX+1;
	243	name_base = "vbi";
	244	break;
	245	case VFL_TYPE_RADIO:
	246	base = MINOR_VFL_TYPE_RADIO_MIN;
	247	end = MINOR_VFL_TYPE_RADIO_MAX+1;
	248	name_base = "radio";
	249	break;
	250	default:
	251	printk(KERN_ERR "%s called with unknown type: %d\n",
	252	__func__, type);
46f2c21c	253	return -EINVAL;
27a5e6d3 HV	254	}
27a5e6d3 HV	255
7f8ecfab HV	256	/* Initialize the character device */
	257	cdev_init(&vfd->cdev, vfd->fops);
	258	vfd->cdev.owner = vfd->fops->owner;
27a5e6d3 HV	259	/* pick a minor number */
27a5e6d3 HV	260	mutex_lock(&videodev_lock);
bfa8a273	261	if (nr >= 0 && nr < end-base) {
27a5e6d3 HV	262	/* use the one the driver asked for */
	263	i = base + nr;
	264	if (NULL != video_device[i]) {
	265	mutex_unlock(&videodev_lock);
	266	return -ENFILE;
	267	}
	268	} else {
	269	/* use first free */
	270	for (i = base; i < end; i++)
	271	if (NULL == video_device[i])
	272	break;
	273	if (i == end) {
	274	mutex_unlock(&videodev_lock);
	275	return -ENFILE;
	276	}
	277	}
	278	video_device[i] = vfd;
0ea6bc8d	279	vfd->vfl_type = type;
27a5e6d3 HV	280	vfd->minor = i;
	281
	282	ret = get_index(vfd, index);
	283	vfd->index = ret;
	284
	285	mutex_unlock(&videodev_lock);
	286
	287	if (ret < 0) {
	288	printk(KERN_ERR "%s: get_index failed\n", __func__);
	289	goto fail_minor;
	290	}
	291
7f8ecfab HV	292	ret = cdev_add(&vfd->cdev, MKDEV(VIDEO_MAJOR, vfd->minor), 1);
	293	if (ret < 0) {
	294	printk(KERN_ERR "%s: cdev_add failed\n", __func__);
	295	goto fail_minor;
	296	}
27a5e6d3	297	/* sysfs class */
bfa8a273	298	memset(&vfd->dev, 0, sizeof(vfd->dev));
9d95af9d HV	299	/* The memset above cleared the device's drvdata, so
	300	put back the copy we made earlier. */
	301	video_set_drvdata(vfd, priv);
22a04f10 HV	302	vfd->dev.class = &video_class;
22a04f10 HV	303	vfd->dev.devt = MKDEV(VIDEO_MAJOR, vfd->minor);
5e85e732	304	if (vfd->parent)
22a04f10 HV	305	vfd->dev.parent = vfd->parent;
	306	sprintf(vfd->dev.bus_id, "%s%d", name_base, i - base);
	307	ret = device_register(&vfd->dev);
27a5e6d3 HV	308	if (ret < 0) {
27a5e6d3 HV	309	printk(KERN_ERR "%s: device_register failed\n", __func__);
7f8ecfab	310	goto del_cdev;
27a5e6d3	311	}
7f8ecfab HV	312	/* Remember the cdev's release function */
	313	vfd->cdev_release = vfd->cdev.kobj.ktype->release;
	314	/* Install our own */
	315	vfd->cdev.kobj.ktype = &v4l2_ktype_cdev_default;
27a5e6d3 HV	316	return 0;
27a5e6d3 HV	317
7f8ecfab HV	318	del_cdev:
	319	cdev_del(&vfd->cdev);
	320
27a5e6d3 HV	321	fail_minor:
	322	mutex_lock(&videodev_lock);
	323	video_device[vfd->minor] = NULL;
27a5e6d3	324	mutex_unlock(&videodev_lock);
bfa8a273	325	vfd->minor = -1;
27a5e6d3 HV	326	return ret;
	327	}
	328	EXPORT_SYMBOL(video_register_device_index);
	329
	330	/**
	331	* video_unregister_device - unregister a video4linux device
	332	* @vfd: the device to unregister
	333	*
	334	* This unregisters the passed device and deassigns the minor
	335	* number. Future open calls will be met with errors.
	336	*/
	337
	338	void video_unregister_device(struct video_device *vfd)
	339	{
22a04f10	340	device_unregister(&vfd->dev);
27a5e6d3 HV	341	}
	342	EXPORT_SYMBOL(video_unregister_device);
	343
27a5e6d3 HV	344	/*
	345	* Initialise video for linux
	346	*/
27a5e6d3 HV	347	static int __init videodev_init(void)
27a5e6d3 HV	348	{
7f8ecfab	349	dev_t dev = MKDEV(VIDEO_MAJOR, 0);
27a5e6d3 HV	350	int ret;
	351
	352	printk(KERN_INFO "Linux video capture interface: v2.00\n");
7f8ecfab HV	353	ret = register_chrdev_region(dev, VIDEO_NUM_DEVICES, VIDEO_NAME);
	354	if (ret < 0) {
	355	printk(KERN_WARNING "videodev: unable to get major %d\n",
	356	VIDEO_MAJOR);
	357	return ret;
27a5e6d3 HV	358	}
	359
	360	ret = class_register(&video_class);
	361	if (ret < 0) {
7f8ecfab	362	unregister_chrdev_region(dev, VIDEO_NUM_DEVICES);
27a5e6d3 HV	363	printk(KERN_WARNING "video_dev: class_register failed\n");
	364	return -EIO;
	365	}
	366
	367	return 0;
	368	}
	369
	370	static void __exit videodev_exit(void)
	371	{
7f8ecfab HV	372	dev_t dev = MKDEV(VIDEO_MAJOR, 0);
7f8ecfab HV	373
27a5e6d3	374	class_unregister(&video_class);
7f8ecfab	375	unregister_chrdev_region(dev, VIDEO_NUM_DEVICES);
27a5e6d3 HV	376	}
	377
	378	module_init(videodev_init)
	379	module_exit(videodev_exit)
	380
	381	MODULE_AUTHOR("Alan Cox, Mauro Carvalho Chehab <mchehab@infradead.org>");
	382	MODULE_DESCRIPTION("Device registrar for Video4Linux drivers v2");
	383	MODULE_LICENSE("GPL");
	384
	385
	386	/*
	387	* Local variables:
	388	* c-basic-offset: 8
	389	* End:
	390	*/