[mirror_ubuntu-hirsute-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
};

struct video_device *video_device_alloc(void)
{
	struct video_device *vfd;

	vfd = kzalloc(sizeof(*vfd), GFP_KERNEL);
	return vfd;
}
EXPORT_SYMBOL(video_device_alloc);

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

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

#if 1
	/* needed until all drivers are fixed */
	if (!vfd->release)
		return;
#endif
	vfd->release(vfd);
}

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

/*
 *	Active devices
 */

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

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

/*
 *	Open a video device - FIXME: Obsoleted
 */
static int video_open(struct inode *inode, struct file *file)
{
	unsigned int minor = iminor(inode);
	int err = 0;
	struct video_device *vfl;
	const struct file_operations *old_fops;

	if (minor >= VIDEO_NUM_DEVICES)
		return -ENODEV;
	lock_kernel();
	mutex_lock(&videodev_lock);
	vfl = video_device[minor];
	if (vfl == NULL) {
		mutex_unlock(&videodev_lock);
		request_module("char-major-%d-%d", VIDEO_MAJOR, minor);
		mutex_lock(&videodev_lock);
		vfl = video_device[minor];
		if (vfl == NULL) {
			mutex_unlock(&videodev_lock);
			unlock_kernel();
			return -ENODEV;
		}
	}
	old_fops = file->f_op;
	file->f_op = fops_get(vfl->fops);
	if (file->f_op->open)
		err = file->f_op->open(inode, file);
	if (err) {
		fops_put(file->f_op);
		file->f_op = fops_get(old_fops);
	}
	fops_put(old_fops);
	mutex_unlock(&videodev_lock);
	unlock_kernel();
	return err;
}

/*
 * open/release helper functions -- handle exclusive opens
 * Should be removed soon
 */
int video_exclusive_open(struct inode *inode, struct file *file)
{
	struct video_device *vfl = video_devdata(file);
	int retval = 0;

	mutex_lock(&vfl->lock);
	if (vfl->users)
		retval = -EBUSY;
	else
		vfl->users++;
	mutex_unlock(&vfl->lock);
	return retval;
}
EXPORT_SYMBOL(video_exclusive_open);

int video_exclusive_release(struct inode *inode, struct file *file)
{
	struct video_device *vfl = video_devdata(file);

	vfl->users--;
	return 0;
}
EXPORT_SYMBOL(video_exclusive_release);

/**
 * 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 - 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)
 *
 *	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;

	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 -1;
	}

	/* 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->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;
	}

	mutex_init(&vfd->lock);

	/* sysfs class */
	memset(&vfd->dev, 0x00, sizeof(vfd->dev));
	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 fail_minor;
	}

#if 1
	/* needed until all drivers are fixed */
	if (!vfd->release)
		printk(KERN_WARNING "videodev: \"%s\" has no release callback. "
		       "Please fix your driver for proper sysfs support, see "
		       "http://lwn.net/Articles/36850/\n", vfd->name);
#endif
	return 0;

fail_minor:
	mutex_lock(&videodev_lock);
	video_device[vfd->minor] = NULL;
	vfd->minor = -1;
	mutex_unlock(&videodev_lock);
	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)
{
	mutex_lock(&videodev_lock);
	if (video_device[vfd->minor] != vfd)
		panic("videodev: bad unregister");

	video_device[vfd->minor] = NULL;
	device_unregister(&vfd->dev);
	mutex_unlock(&videodev_lock);
}
EXPORT_SYMBOL(video_unregister_device);

/*
 * Video fs operations
 */
static const struct file_operations video_fops = {
	.owner		= THIS_MODULE,
	.llseek		= no_llseek,
	.open		= video_open,
};

/*
 *	Initialise video for linux
 */

static int __init videodev_init(void)
{
	int ret;

	printk(KERN_INFO "Linux video capture interface: v2.00\n");
	if (register_chrdev(VIDEO_MAJOR, VIDEO_NAME, &video_fops)) {
		printk(KERN_WARNING "video_dev: unable to get major %d\n", VIDEO_MAJOR);
		return -EIO;
	}

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

	return 0;
}

static void __exit videodev_exit(void)
{
	class_unregister(&video_class);
	unregister_chrdev(VIDEO_MAJOR, VIDEO_NAME);
}

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);
27a5e6d3 HV	45	return sprintf(buf, "%i\n", vfd->index);
	46	}
	47
	48	static ssize_t show_name(struct device *cd,
	49	struct device_attribute attr, char buf)
	50	{
22a04f10	51	struct video_device *vfd = container_of(cd, struct video_device, dev);
27a5e6d3 HV	52	return sprintf(buf, "%.*s\n", (int)sizeof(vfd->name), vfd->name);
	53	}
	54
	55	static struct device_attribute video_device_attrs[] = {
	56	__ATTR(name, S_IRUGO, show_name, NULL),
	57	__ATTR(index, S_IRUGO, show_index, NULL),
	58	__ATTR_NULL
	59	};
	60
	61	struct video_device *video_device_alloc(void)
	62	{
	63	struct video_device *vfd;
	64
	65	vfd = kzalloc(sizeof(*vfd), GFP_KERNEL);
	66	return vfd;
	67	}
	68	EXPORT_SYMBOL(video_device_alloc);
	69
	70	void video_device_release(struct video_device *vfd)
	71	{
	72	kfree(vfd);
	73	}
	74	EXPORT_SYMBOL(video_device_release);
	75
	76	static void video_release(struct device *cd)
	77	{
22a04f10	78	struct video_device *vfd = container_of(cd, struct video_device, dev);
27a5e6d3 HV	79
	80	#if 1
	81	/* needed until all drivers are fixed */
	82	if (!vfd->release)
	83	return;
	84	#endif
	85	vfd->release(vfd);
	86	}
	87
	88	static struct class video_class = {
	89	.name = VIDEO_NAME,
	90	.dev_attrs = video_device_attrs,
	91	.dev_release = video_release,
	92	};
	93
	94	/*
	95	* Active devices
	96	*/
	97
	98	static struct video_device *video_device[VIDEO_NUM_DEVICES];
	99	static DEFINE_MUTEX(videodev_lock);
	100
	101	struct video_device video_devdata(struct file file)
	102	{
	103	return video_device[iminor(file->f_path.dentry->d_inode)];
	104	}
	105	EXPORT_SYMBOL(video_devdata);
	106
	107	/*
	108	* Open a video device - FIXME: Obsoleted
	109	*/
	110	static int video_open(struct inode inode, struct file file)
	111	{
	112	unsigned int minor = iminor(inode);
	113	int err = 0;
	114	struct video_device *vfl;
	115	const struct file_operations *old_fops;
	116
	117	if (minor >= VIDEO_NUM_DEVICES)
	118	return -ENODEV;
	119	lock_kernel();
	120	mutex_lock(&videodev_lock);
	121	vfl = video_device[minor];
	122	if (vfl == NULL) {
	123	mutex_unlock(&videodev_lock);
	124	request_module("char-major-%d-%d", VIDEO_MAJOR, minor);
	125	mutex_lock(&videodev_lock);
	126	vfl = video_device[minor];
	127	if (vfl == NULL) {
	128	mutex_unlock(&videodev_lock);
	129	unlock_kernel();
	130	return -ENODEV;
	131	}
	132	}
	133	old_fops = file->f_op;
	134	file->f_op = fops_get(vfl->fops);
	135	if (file->f_op->open)
	136	err = file->f_op->open(inode, file);
	137	if (err) {
	138	fops_put(file->f_op);
	139	file->f_op = fops_get(old_fops);
	140	}
	141	fops_put(old_fops);
	142	mutex_unlock(&videodev_lock);
143	unlock_kernel();
144	return err;
145	}
146
147	/*
148	* open/release helper functions -- handle exclusive opens
149	* Should be removed soon
150	*/
151	int video_exclusive_open(struct inode inode, struct file file)
152	{
153	struct video_device *vfl = video_devdata(file);
154	int retval = 0;
155
156	mutex_lock(&vfl->lock);
157	if (vfl->users)
158	retval = -EBUSY;
159	else
160	vfl->users++;
161	mutex_unlock(&vfl->lock);
162	return retval;
163	}
164	EXPORT_SYMBOL(video_exclusive_open);
165
166	int video_exclusive_release(struct inode inode, struct file file)
167	{
168	struct video_device *vfl = video_devdata(file);
169
170	vfl->users--;
171	return 0;
172	}
173	EXPORT_SYMBOL(video_exclusive_release);
174
175	/**
176	* get_index - assign stream number based on parent device
177	* @vdev: video_device to assign index number to, vdev->dev should be assigned
178	* @num: -1 if auto assign, requested number otherwise
179	*
180	*
181	* returns -ENFILE if num is already in use, a free index number if
182	* successful.
183	*/
184	static int get_index(struct video_device *vdev, int num)
185	{
186	u32 used = 0;
187	const int max_index = sizeof(used) * 8 - 1;
188	int i;
189
190	/* Currently a single v4l driver instance cannot create more than
191	32 devices.
192	Increase to u64 or an array of u32 if more are needed. */
193	if (num > max_index) {
194	printk(KERN_ERR "videodev: %s num is too large\n", __func__);
195	return -EINVAL;
196	}
197
198	for (i = 0; i < VIDEO_NUM_DEVICES; i++) {
199	if (video_device[i] != NULL &&
200	video_device[i] != vdev &&
5e85e732	201	video_device[i]->parent == vdev->parent) {
27a5e6d3 HV	202	used \|= 1 << video_device[i]->index;
	203	}
	204	}
	205
	206	if (num >= 0) {
	207	if (used & (1 << num))
	208	return -ENFILE;
	209	return num;
	210	}
	211
	212	i = ffz(used);
	213	return i > max_index ? -ENFILE : i;
	214	}
	215
	216	static const struct file_operations video_fops;
	217
	218	int video_register_device(struct video_device *vfd, int type, int nr)
	219	{
	220	return video_register_device_index(vfd, type, nr, -1);
	221	}
	222	EXPORT_SYMBOL(video_register_device);
	223
	224	/**
	225	* video_register_device - register video4linux devices
	226	* @vfd: video device structure we want to register
	227	* @type: type of device to register
	228	* @nr: which device number (0 == /dev/video0, 1 == /dev/video1, ...
	229	* -1 == first free)
	230	*
	231	* The registration code assigns minor numbers based on the type
	232	* requested. -ENFILE is returned in all the device slots for this
	233	* category are full. If not then the minor field is set and the
	234	* driver initialize function is called (if non %NULL).
	235	*
	236	* Zero is returned on success.
	237	*
	238	* Valid types are
	239	*
	240	* %VFL_TYPE_GRABBER - A frame grabber
	241	*
	242	* %VFL_TYPE_VTX - A teletext device
	243	*
	244	* %VFL_TYPE_VBI - Vertical blank data (undecoded)
	245	*
	246	* %VFL_TYPE_RADIO - A radio card
	247	*/
	248
	249	int video_register_device_index(struct video_device *vfd, int type, int nr,
	250	int index)
	251	{
	252	int i = 0;
	253	int base;
	254	int end;
	255	int ret;
	256	char *name_base;
	257
	258	switch (type) {
	259	case VFL_TYPE_GRABBER:
	260	base = MINOR_VFL_TYPE_GRABBER_MIN;
	261	end = MINOR_VFL_TYPE_GRABBER_MAX+1;
	262	name_base = "video";
	263	break;
	264	case VFL_TYPE_VTX:
	265	base = MINOR_VFL_TYPE_VTX_MIN;
266	end = MINOR_VFL_TYPE_VTX_MAX+1;
267	name_base = "vtx";
268	break;
269	case VFL_TYPE_VBI:
270	base = MINOR_VFL_TYPE_VBI_MIN;
271	end = MINOR_VFL_TYPE_VBI_MAX+1;
272	name_base = "vbi";
273	break;
274	case VFL_TYPE_RADIO:
275	base = MINOR_VFL_TYPE_RADIO_MIN;
276	end = MINOR_VFL_TYPE_RADIO_MAX+1;
277	name_base = "radio";
278	break;
279	default:
280	printk(KERN_ERR "%s called with unknown type: %d\n",
281	__func__, type);
282	return -1;
283	}
284
285	/* pick a minor number */
286	mutex_lock(&videodev_lock);
287	if (nr >= 0 && nr < end-base) {
288	/* use the one the driver asked for */
289	i = base + nr;
290	if (NULL != video_device[i]) {
291	mutex_unlock(&videodev_lock);
292	return -ENFILE;
293	}
294	} else {
295	/* use first free */
296	for (i = base; i < end; i++)
297	if (NULL == video_device[i])
298	break;
299	if (i == end) {
300	mutex_unlock(&videodev_lock);
301	return -ENFILE;
302	}
303	}
304	video_device[i] = vfd;
305	vfd->minor = i;
306
307	ret = get_index(vfd, index);
308	vfd->index = ret;
309
310	mutex_unlock(&videodev_lock);
311
312	if (ret < 0) {
313	printk(KERN_ERR "%s: get_index failed\n", __func__);
314	goto fail_minor;
315	}
316
317	mutex_init(&vfd->lock);
318
319	/* sysfs class */
22a04f10 HV	320	memset(&vfd->dev, 0x00, sizeof(vfd->dev));
	321	vfd->dev.class = &video_class;
	322	vfd->dev.devt = MKDEV(VIDEO_MAJOR, vfd->minor);
5e85e732	323	if (vfd->parent)
22a04f10 HV	324	vfd->dev.parent = vfd->parent;
	325	sprintf(vfd->dev.bus_id, "%s%d", name_base, i - base);
	326	ret = device_register(&vfd->dev);
27a5e6d3 HV	327	if (ret < 0) {
	328	printk(KERN_ERR "%s: device_register failed\n", __func__);
	329	goto fail_minor;
	330	}
	331
	332	#if 1
	333	/* needed until all drivers are fixed */
	334	if (!vfd->release)
	335	printk(KERN_WARNING "videodev: \"%s\" has no release callback. "
	336	"Please fix your driver for proper sysfs support, see "
	337	"http://lwn.net/Articles/36850/\n", vfd->name);
	338	#endif
	339	return 0;
	340
	341	fail_minor:
	342	mutex_lock(&videodev_lock);
	343	video_device[vfd->minor] = NULL;
	344	vfd->minor = -1;
	345	mutex_unlock(&videodev_lock);
	346	return ret;
	347	}
	348	EXPORT_SYMBOL(video_register_device_index);
	349
	350	/**
	351	* video_unregister_device - unregister a video4linux device
	352	* @vfd: the device to unregister
	353	*
	354	* This unregisters the passed device and deassigns the minor
	355	* number. Future open calls will be met with errors.
	356	*/
	357
	358	void video_unregister_device(struct video_device *vfd)
	359	{
	360	mutex_lock(&videodev_lock);
	361	if (video_device[vfd->minor] != vfd)
	362	panic("videodev: bad unregister");
	363
	364	video_device[vfd->minor] = NULL;
22a04f10	365	device_unregister(&vfd->dev);
27a5e6d3 HV	366	mutex_unlock(&videodev_lock);
	367	}
	368	EXPORT_SYMBOL(video_unregister_device);
	369
	370	/*
	371	* Video fs operations
	372	*/
	373	static const struct file_operations video_fops = {
	374	.owner = THIS_MODULE,
	375	.llseek = no_llseek,
	376	.open = video_open,
	377	};
	378
	379	/*
	380	* Initialise video for linux
	381	*/
	382
	383	static int __init videodev_init(void)
	384	{
	385	int ret;
	386
	387	printk(KERN_INFO "Linux video capture interface: v2.00\n");
	388	if (register_chrdev(VIDEO_MAJOR, VIDEO_NAME, &video_fops)) {
	389	printk(KERN_WARNING "video_dev: unable to get major %d\n", VIDEO_MAJOR);
	390	return -EIO;
	391	}
	392
	393	ret = class_register(&video_class);
	394	if (ret < 0) {
	395	unregister_chrdev(VIDEO_MAJOR, VIDEO_NAME);
	396	printk(KERN_WARNING "video_dev: class_register failed\n");
	397	return -EIO;
	398	}
	399
	400	return 0;
	401	}
	402
	403	static void __exit videodev_exit(void)
	404	{
	405	class_unregister(&video_class);
	406	unregister_chrdev(VIDEO_MAJOR, VIDEO_NAME);
	407	}
	408
	409	module_init(videodev_init)
	410	module_exit(videodev_exit)
	411
	412	MODULE_AUTHOR("Alan Cox, Mauro Carvalho Chehab <mchehab@infradead.org>");
	413	MODULE_DESCRIPTION("Device registrar for Video4Linux drivers v2");
	414	MODULE_LICENSE("GPL");
	415
	416
	417	/*
	418	* Local variables:
	419	* c-basic-offset: 8
	420	* End:
	421	*/