[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@lxorguk.ukuu.org.uk> (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>
#include <media/v4l2-device.h>
#include <media/v4l2-ioctl.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 *vdev = to_video_device(cd);

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

static ssize_t show_name(struct device *cd,
			 struct device_attribute *attr, char *buf)
{
	struct video_device *vdev = to_video_device(cd);

	return sprintf(buf, "%.*s\n", (int)sizeof(vdev->name), vdev->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);
static DECLARE_BITMAP(devnode_nums[VFL_TYPE_MAX], VIDEO_NUM_DEVICES);

/* Device node utility functions */

/* Note: these utility functions all assume that vfl_type is in the range
   [0, VFL_TYPE_MAX-1]. */

#ifdef CONFIG_VIDEO_FIXED_MINOR_RANGES
/* Return the bitmap corresponding to vfl_type. */
static inline unsigned long *devnode_bits(int vfl_type)
{
	/* Any types not assigned to fixed minor ranges must be mapped to
	   one single bitmap for the purposes of finding a free node number
	   since all those unassigned types use the same minor range. */
	int idx = (vfl_type > VFL_TYPE_RADIO) ? VFL_TYPE_MAX - 1 : vfl_type;

	return devnode_nums[idx];
}
#else
/* Return the bitmap corresponding to vfl_type. */
static inline unsigned long *devnode_bits(int vfl_type)
{
	return devnode_nums[vfl_type];
}
#endif

/* Mark device node number vdev->num as used */
static inline void devnode_set(struct video_device *vdev)
{
	set_bit(vdev->num, devnode_bits(vdev->vfl_type));
}

/* Mark device node number vdev->num as unused */
static inline void devnode_clear(struct video_device *vdev)
{
	clear_bit(vdev->num, devnode_bits(vdev->vfl_type));
}

/* Try to find a free device node number in the range [from, to> */
static inline int devnode_find(struct video_device *vdev, int from, int to)
{
	return find_next_zero_bit(devnode_bits(vdev->vfl_type), to, from);
}

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 *vdev)
{
	kfree(vdev);
}
EXPORT_SYMBOL(video_device_release);

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

static inline void video_get(struct video_device *vdev)
{
	get_device(&vdev->dev);
}

static inline void video_put(struct video_device *vdev)
{
	put_device(&vdev->dev);
}

/* Called when the last user of the video device exits. */
static void v4l2_device_release(struct device *cd)
{
	struct video_device *vdev = to_video_device(cd);

	mutex_lock(&videodev_lock);
	if (video_device[vdev->minor] != vdev) {
		mutex_unlock(&videodev_lock);
		/* should not happen */
		WARN_ON(1);
		return;
	}

	/* Free up this device for reuse */
	video_device[vdev->minor] = NULL;

	/* Delete the cdev on this minor as well */
	cdev_del(vdev->cdev);
	/* Just in case some driver tries to access this from
	   the release() callback. */
	vdev->cdev = NULL;

	/* Mark device node number as free */
	devnode_clear(vdev);

	mutex_unlock(&videodev_lock);

	/* Release video_device and perform other
	   cleanups as needed. */
	vdev->release(vdev);
}

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

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

static ssize_t v4l2_read(struct file *filp, char __user *buf,
		size_t sz, loff_t *off)
{
	struct video_device *vdev = video_devdata(filp);

	if (!vdev->fops->read)
		return -EINVAL;
	if (!video_is_registered(vdev))
		return -EIO;
	return vdev->fops->read(filp, buf, sz, off);
}

static ssize_t v4l2_write(struct file *filp, const char __user *buf,
		size_t sz, loff_t *off)
{
	struct video_device *vdev = video_devdata(filp);

	if (!vdev->fops->write)
		return -EINVAL;
	if (!video_is_registered(vdev))
		return -EIO;
	return vdev->fops->write(filp, buf, sz, off);
}

static unsigned int v4l2_poll(struct file *filp, struct poll_table_struct *poll)
{
	struct video_device *vdev = video_devdata(filp);

	if (!vdev->fops->poll || !video_is_registered(vdev))
		return DEFAULT_POLLMASK;
	return vdev->fops->poll(filp, poll);
}

static long v4l2_ioctl(struct file *filp, unsigned int cmd, unsigned long arg)
{
	struct video_device *vdev = video_devdata(filp);
	int ret;

	if (!vdev->fops->ioctl)
		return -ENOTTY;
	if (vdev->fops->unlocked_ioctl) {
		ret = vdev->fops->unlocked_ioctl(filp, cmd, arg);
	} else if (vdev->fops->ioctl) {
		/* TODO: convert all drivers to unlocked_ioctl */
		lock_kernel();
		ret = vdev->fops->ioctl(filp, cmd, arg);
		unlock_kernel();
	} else
		ret = -ENOTTY;

	return ret;
}

static int v4l2_mmap(struct file *filp, struct vm_area_struct *vm)
{
	struct video_device *vdev = video_devdata(filp);

	if (!vdev->fops->mmap || !video_is_registered(vdev))
		return -ENODEV;
	return vdev->fops->mmap(filp, vm);
}

/* Override for the open function */
static int v4l2_open(struct inode *inode, struct file *filp)
{
	struct video_device *vdev;
	int ret = 0;

	/* Check if the video device is available */
	mutex_lock(&videodev_lock);
	vdev = video_devdata(filp);
	/* return ENODEV if the video device has been removed
	   already or if it is not registered anymore. */
	if (vdev == NULL || !video_is_registered(vdev)) {
		mutex_unlock(&videodev_lock);
		return -ENODEV;
	}
	/* and increase the device refcount */
	video_get(vdev);
	mutex_unlock(&videodev_lock);
	if (vdev->fops->open)
		ret = vdev->fops->open(filp);

	/* decrease the refcount in case of an error */
	if (ret)
		video_put(vdev);
	return ret;
}

/* Override for the release function */
static int v4l2_release(struct inode *inode, struct file *filp)
{
	struct video_device *vdev = video_devdata(filp);
	int ret = 0;

	if (vdev->fops->release)
		vdev->fops->release(filp);

	/* decrease the refcount unconditionally since the release()
	   return value is ignored. */
	video_put(vdev);
	return ret;
}

static const struct file_operations v4l2_fops = {
	.owner = THIS_MODULE,
	.read = v4l2_read,
	.write = v4l2_write,
	.open = v4l2_open,
	.mmap = v4l2_mmap,
	.unlocked_ioctl = v4l2_ioctl,
#ifdef CONFIG_COMPAT
	.compat_ioctl = v4l2_compat_ioctl32,
#endif
	.release = v4l2_release,
	.poll = v4l2_poll,
	.llseek = no_llseek,
};

/**
 * get_index - assign stream index number based on parent device
 * @vdev: video_device to assign index number to, vdev->parent should be assigned
 *
 * Note that when this is called the new device has not yet been registered
 * in the video_device array, but it was able to obtain a minor number.
 *
 * This means that we can always obtain a free stream index number since
 * the worst case scenario is that there are VIDEO_NUM_DEVICES - 1 slots in
 * use of the video_device array.
 *
 * Returns a free index number.
 */
static int get_index(struct video_device *vdev)
{
	/* This can be static since this function is called with the global
	   videodev_lock held. */
	static DECLARE_BITMAP(used, VIDEO_NUM_DEVICES);
	int i;

	/* Some drivers do not set the parent. In that case always return 0. */
	if (vdev->parent == NULL)
		return 0;

	bitmap_zero(used, VIDEO_NUM_DEVICES);

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

	return find_first_zero_bit(used, VIDEO_NUM_DEVICES);
}

/**
 *	video_register_device - register video4linux devices
 *	@vdev: video device structure we want to register
 *	@type: type of device to register
 *	@nr:   which device node number (0 == /dev/video0, 1 == /dev/video1, ...
 *             -1 == first free)
 *	@warn_if_nr_in_use: warn if the desired device node number
 *	       was already in use and another number was chosen instead.
 *
 *	The registration code assigns minor numbers and device node numbers
 *	based on the requested type and registers the new device node with
 *	the kernel.
 *	An error is returned if no free minor or device node number could be
 *	found, or if the registration of the device node failed.
 *
 *	Zero is returned on success.
 *
 *	Valid types are
 *
 *	%VFL_TYPE_GRABBER - A frame grabber
 *
 *	%VFL_TYPE_VBI - Vertical blank data (undecoded)
 *
 *	%VFL_TYPE_RADIO - A radio card
 */
static int __video_register_device(struct video_device *vdev, int type, int nr,
		int warn_if_nr_in_use)
{
	int i = 0;
	int ret;
	int minor_offset = 0;
	int minor_cnt = VIDEO_NUM_DEVICES;
	const char *name_base;
	void *priv = vdev->dev.p;

	/* A minor value of -1 marks this video device as never
	   having been registered */
	vdev->minor = -1;

	/* the release callback MUST be present */
	WARN_ON(!vdev->release);
	if (!vdev->release)
		return -EINVAL;

	/* v4l2_fh support */
	spin_lock_init(&vdev->fh_lock);
	INIT_LIST_HEAD(&vdev->fh_list);

	/* Part 1: check device type */
	switch (type) {
	case VFL_TYPE_GRABBER:
		name_base = "video";
		break;
	case VFL_TYPE_VBI:
		name_base = "vbi";
		break;
	case VFL_TYPE_RADIO:
		name_base = "radio";
		break;
	default:
		printk(KERN_ERR "%s called with unknown type: %d\n",
		       __func__, type);
		return -EINVAL;
	}

	vdev->vfl_type = type;
	vdev->cdev = NULL;
	if (vdev->v4l2_dev) {
		if (vdev->v4l2_dev->dev)
			vdev->parent = vdev->v4l2_dev->dev;
		if (vdev->ctrl_handler == NULL)
			vdev->ctrl_handler = vdev->v4l2_dev->ctrl_handler;
	}

	/* Part 2: find a free minor, device node number and device index. */
#ifdef CONFIG_VIDEO_FIXED_MINOR_RANGES
	/* Keep the ranges for the first four types for historical
	 * reasons.
	 * Newer devices (not yet in place) should use the range
	 * of 128-191 and just pick the first free minor there
	 * (new style). */
	switch (type) {
	case VFL_TYPE_GRABBER:
		minor_offset = 0;
		minor_cnt = 64;
		break;
	case VFL_TYPE_RADIO:
		minor_offset = 64;
		minor_cnt = 64;
		break;
	case VFL_TYPE_VBI:
		minor_offset = 224;
		minor_cnt = 32;
		break;
	default:
		minor_offset = 128;
		minor_cnt = 64;
		break;
	}
#endif

	/* Pick a device node number */
	mutex_lock(&videodev_lock);
	nr = devnode_find(vdev, nr == -1 ? 0 : nr, minor_cnt);
	if (nr == minor_cnt)
		nr = devnode_find(vdev, 0, minor_cnt);
	if (nr == minor_cnt) {
		printk(KERN_ERR "could not get a free device node number\n");
		mutex_unlock(&videodev_lock);
		return -ENFILE;
	}
#ifdef CONFIG_VIDEO_FIXED_MINOR_RANGES
	/* 1-on-1 mapping of device node number to minor number */
	i = nr;
#else
	/* The device node number and minor numbers are independent, so
	   we just find the first free minor number. */
	for (i = 0; i < VIDEO_NUM_DEVICES; i++)
		if (video_device[i] == NULL)
			break;
	if (i == VIDEO_NUM_DEVICES) {
		mutex_unlock(&videodev_lock);
		printk(KERN_ERR "could not get a free minor\n");
		return -ENFILE;
	}
#endif
	vdev->minor = i + minor_offset;
	vdev->num = nr;
	devnode_set(vdev);

	/* Should not happen since we thought this minor was free */
	WARN_ON(video_device[vdev->minor] != NULL);
	vdev->index = get_index(vdev);
	mutex_unlock(&videodev_lock);

	/* Part 3: Initialize the character device */
	vdev->cdev = cdev_alloc();
	if (vdev->cdev == NULL) {
		ret = -ENOMEM;
		goto cleanup;
	}
	vdev->cdev->ops = &v4l2_fops;
	vdev->cdev->owner = vdev->fops->owner;
	ret = cdev_add(vdev->cdev, MKDEV(VIDEO_MAJOR, vdev->minor), 1);
	if (ret < 0) {
		printk(KERN_ERR "%s: cdev_add failed\n", __func__);
		kfree(vdev->cdev);
		vdev->cdev = NULL;
		goto cleanup;
	}

	/* Part 4: register the device with sysfs */
	memset(&vdev->dev, 0, sizeof(vdev->dev));
	/* The memset above cleared the device's device_private, so
	   put back the copy we made earlier. */
	vdev->dev.p = priv;
	vdev->dev.class = &video_class;
	vdev->dev.devt = MKDEV(VIDEO_MAJOR, vdev->minor);
	if (vdev->parent)
		vdev->dev.parent = vdev->parent;
	dev_set_name(&vdev->dev, "%s%d", name_base, vdev->num);
	ret = device_register(&vdev->dev);
	if (ret < 0) {
		printk(KERN_ERR "%s: device_register failed\n", __func__);
		goto cleanup;
	}
	/* Register the release callback that will be called when the last
	   reference to the device goes away. */
	vdev->dev.release = v4l2_device_release;

	if (nr != -1 && nr != vdev->num && warn_if_nr_in_use)
		printk(KERN_WARNING "%s: requested %s%d, got %s\n", __func__,
			name_base, nr, video_device_node_name(vdev));

	/* Part 5: Activate this minor. The char device can now be used. */
	set_bit(V4L2_FL_REGISTERED, &vdev->flags);
	mutex_lock(&videodev_lock);
	video_device[vdev->minor] = vdev;
	mutex_unlock(&videodev_lock);
	return 0;

cleanup:
	mutex_lock(&videodev_lock);
	if (vdev->cdev)
		cdev_del(vdev->cdev);
	devnode_clear(vdev);
	mutex_unlock(&videodev_lock);
	/* Mark this video device as never having been registered. */
	vdev->minor = -1;
	return ret;
}

int video_register_device(struct video_device *vdev, int type, int nr)
{
	return __video_register_device(vdev, type, nr, 1);
}
EXPORT_SYMBOL(video_register_device);

int video_register_device_no_warn(struct video_device *vdev, int type, int nr)
{
	return __video_register_device(vdev, type, nr, 0);
}
EXPORT_SYMBOL(video_register_device_no_warn);

/**
 *	video_unregister_device - unregister a video4linux device
 *	@vdev: the device to unregister
 *
 *	This unregisters the passed device. Future open calls will
 *	be met with errors.
 */
void video_unregister_device(struct video_device *vdev)
{
	/* Check if vdev was ever registered at all */
	if (!vdev || !video_is_registered(vdev))
		return;

	clear_bit(V4L2_FL_REGISTERED, &vdev->flags);
	device_unregister(&vdev->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");
MODULE_ALIAS_CHARDEV_MAJOR(VIDEO_MAJOR);


/*
 * 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	*
d9b01449	12	* Authors: Alan Cox, <alan@lxorguk.ukuu.org.uk> (version 1)
27a5e6d3 HV	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>
86a5ef7d	28	#include <linux/smp_lock.h>
27a5e6d3 HV	29	#include <asm/uaccess.h>
	30	#include <asm/system.h>
	31
	32	#include <media/v4l2-common.h>
9bea3514	33	#include <media/v4l2-device.h>
bec43661	34	#include <media/v4l2-ioctl.h>
27a5e6d3 HV	35
	36	#define VIDEO_NUM_DEVICES 256
	37	#define VIDEO_NAME "video4linux"
	38
	39	/*
	40	* sysfs stuff
	41	*/
	42
	43	static ssize_t show_index(struct device *cd,
	44	struct device_attribute attr, char buf)
	45	{
dc93a70c	46	struct video_device *vdev = to_video_device(cd);
bfa8a273	47
dc93a70c	48	return sprintf(buf, "%i\n", vdev->index);
27a5e6d3 HV	49	}
	50
	51	static ssize_t show_name(struct device *cd,
	52	struct device_attribute attr, char buf)
	53	{
dc93a70c	54	struct video_device *vdev = to_video_device(cd);
bfa8a273	55
dc93a70c	56	return sprintf(buf, "%.*s\n", (int)sizeof(vdev->name), vdev->name);
27a5e6d3 HV	57	}
	58
	59	static struct device_attribute video_device_attrs[] = {
	60	__ATTR(name, S_IRUGO, show_name, NULL),
	61	__ATTR(index, S_IRUGO, show_index, NULL),
	62	__ATTR_NULL
	63	};
	64
7f8ecfab HV	65	/*
	66	* Active devices
	67	*/
	68	static struct video_device *video_device[VIDEO_NUM_DEVICES];
	69	static DEFINE_MUTEX(videodev_lock);
22e22125	70	static DECLARE_BITMAP(devnode_nums[VFL_TYPE_MAX], VIDEO_NUM_DEVICES);
7f8ecfab	71
5062cb70 HV	72	/* Device node utility functions */
	73
	74	/* Note: these utility functions all assume that vfl_type is in the range
	75	[0, VFL_TYPE_MAX-1]. */
	76
	77	#ifdef CONFIG_VIDEO_FIXED_MINOR_RANGES
	78	/* Return the bitmap corresponding to vfl_type. */
	79	static inline unsigned long *devnode_bits(int vfl_type)
	80	{
	81	/* Any types not assigned to fixed minor ranges must be mapped to
	82	one single bitmap for the purposes of finding a free node number
	83	since all those unassigned types use the same minor range. */
226c0eea	84	int idx = (vfl_type > VFL_TYPE_RADIO) ? VFL_TYPE_MAX - 1 : vfl_type;
5062cb70 HV	85
	86	return devnode_nums[idx];
	87	}
	88	#else
	89	/* Return the bitmap corresponding to vfl_type. */
	90	static inline unsigned long *devnode_bits(int vfl_type)
	91	{
	92	return devnode_nums[vfl_type];
	93	}
	94	#endif
	95
	96	/* Mark device node number vdev->num as used */
	97	static inline void devnode_set(struct video_device *vdev)
	98	{
	99	set_bit(vdev->num, devnode_bits(vdev->vfl_type));
	100	}
	101
	102	/* Mark device node number vdev->num as unused */
	103	static inline void devnode_clear(struct video_device *vdev)
	104	{
	105	clear_bit(vdev->num, devnode_bits(vdev->vfl_type));
	106	}
	107
	108	/* Try to find a free device node number in the range [from, to> */
	109	static inline int devnode_find(struct video_device *vdev, int from, int to)
	110	{
	111	return find_next_zero_bit(devnode_bits(vdev->vfl_type), to, from);
	112	}
	113
27a5e6d3 HV	114	struct video_device *video_device_alloc(void)
27a5e6d3 HV	115	{
bfa8a273	116	return kzalloc(sizeof(struct video_device), GFP_KERNEL);
27a5e6d3 HV	117	}
	118	EXPORT_SYMBOL(video_device_alloc);
	119
dc93a70c	120	void video_device_release(struct video_device *vdev)
27a5e6d3	121	{
dc93a70c	122	kfree(vdev);
27a5e6d3 HV	123	}
	124	EXPORT_SYMBOL(video_device_release);
	125
dc93a70c	126	void video_device_release_empty(struct video_device *vdev)
f9e86b5e HV	127	{
	128	/* Do nothing */
	129	/* Only valid when the video_device struct is a static. */
	130	}
	131	EXPORT_SYMBOL(video_device_release_empty);
	132
dc93a70c	133	static inline void video_get(struct video_device *vdev)
7f8ecfab	134	{
dc93a70c HV	135	get_device(&vdev->dev);
	136	}
	137
	138	static inline void video_put(struct video_device *vdev)
	139	{
	140	put_device(&vdev->dev);
	141	}
	142
	143	/* Called when the last user of the video device exits. */
	144	static void v4l2_device_release(struct device *cd)
	145	{
	146	struct video_device *vdev = to_video_device(cd);
7f8ecfab HV	147
7f8ecfab HV	148	mutex_lock(&videodev_lock);
dc93a70c	149	if (video_device[vdev->minor] != vdev) {
6ea9a182	150	mutex_unlock(&videodev_lock);
dc93a70c HV	151	/* should not happen */
dc93a70c HV	152	WARN_ON(1);
6ea9a182 HV	153	return;
6ea9a182 HV	154	}
7f8ecfab HV	155
7f8ecfab HV	156	/* Free up this device for reuse */
dc93a70c	157	video_device[vdev->minor] = NULL;
7f8ecfab	158
dc93a70c HV	159	/* Delete the cdev on this minor as well */
	160	cdev_del(vdev->cdev);
	161	/* Just in case some driver tries to access this from
	162	the release() callback. */
	163	vdev->cdev = NULL;
7f8ecfab	164
22e22125	165	/* Mark device node number as free */
5062cb70	166	devnode_clear(vdev);
7f8ecfab	167
dc93a70c	168	mutex_unlock(&videodev_lock);
27a5e6d3	169
dc93a70c HV	170	/* Release video_device and perform other
	171	cleanups as needed. */
	172	vdev->release(vdev);
27a5e6d3 HV	173	}
	174
	175	static struct class video_class = {
	176	.name = VIDEO_NAME,
	177	.dev_attrs = video_device_attrs,
27a5e6d3 HV	178	};
27a5e6d3 HV	179
27a5e6d3 HV	180	struct video_device video_devdata(struct file file)
	181	{
	182	return video_device[iminor(file->f_path.dentry->d_inode)];
	183	}
	184	EXPORT_SYMBOL(video_devdata);
	185
dc93a70c HV	186	static ssize_t v4l2_read(struct file filp, char __user buf,
	187	size_t sz, loff_t *off)
	188	{
	189	struct video_device *vdev = video_devdata(filp);
	190
	191	if (!vdev->fops->read)
	192	return -EINVAL;
957b4aa9	193	if (!video_is_registered(vdev))
dc93a70c HV	194	return -EIO;
	195	return vdev->fops->read(filp, buf, sz, off);
	196	}
	197
	198	static ssize_t v4l2_write(struct file filp, const char __user buf,
	199	size_t sz, loff_t *off)
	200	{
	201	struct video_device *vdev = video_devdata(filp);
	202
	203	if (!vdev->fops->write)
	204	return -EINVAL;
957b4aa9	205	if (!video_is_registered(vdev))
dc93a70c HV	206	return -EIO;
	207	return vdev->fops->write(filp, buf, sz, off);
	208	}
	209
	210	static unsigned int v4l2_poll(struct file filp, struct poll_table_struct poll)
	211	{
	212	struct video_device *vdev = video_devdata(filp);
	213
957b4aa9	214	if (!vdev->fops->poll \|\| !video_is_registered(vdev))
dc93a70c HV	215	return DEFAULT_POLLMASK;
	216	return vdev->fops->poll(filp, poll);
	217	}
	218
86a5ef7d	219	static long v4l2_ioctl(struct file *filp, unsigned int cmd, unsigned long arg)
dc93a70c HV	220	{
dc93a70c HV	221	struct video_device *vdev = video_devdata(filp);
86a5ef7d	222	int ret;
dc93a70c	223
d69f2718 HV	224	if (!vdev->fops->ioctl)
d69f2718 HV	225	return -ENOTTY;
86a5ef7d AB	226	if (vdev->fops->unlocked_ioctl) {
	227	ret = vdev->fops->unlocked_ioctl(filp, cmd, arg);
	228	} else if (vdev->fops->ioctl) {
	229	/* TODO: convert all drivers to unlocked_ioctl */
	230	lock_kernel();
	231	ret = vdev->fops->ioctl(filp, cmd, arg);
	232	unlock_kernel();
	233	} else
	234	ret = -ENOTTY;
dc93a70c	235
86a5ef7d	236	return ret;
dc93a70c HV	237	}
dc93a70c HV	238
dc93a70c HV	239	static int v4l2_mmap(struct file filp, struct vm_area_struct vm)
	240	{
	241	struct video_device *vdev = video_devdata(filp);
	242
957b4aa9	243	if (!vdev->fops->mmap \|\| !video_is_registered(vdev))
dc93a70c HV	244	return -ENODEV;
	245	return vdev->fops->mmap(filp, vm);
	246	}
	247
	248	/* Override for the open function */
	249	static int v4l2_open(struct inode inode, struct file filp)
	250	{
	251	struct video_device *vdev;
65d9ff9c	252	int ret = 0;
dc93a70c HV	253
	254	/* Check if the video device is available */
	255	mutex_lock(&videodev_lock);
	256	vdev = video_devdata(filp);
	257	/* return ENODEV if the video device has been removed
	258	already or if it is not registered anymore. */
957b4aa9	259	if (vdev == NULL \|\| !video_is_registered(vdev)) {
dc93a70c HV	260	mutex_unlock(&videodev_lock);
	261	return -ENODEV;
	262	}
	263	/* and increase the device refcount */
	264	video_get(vdev);
	265	mutex_unlock(&videodev_lock);
65d9ff9c HV	266	if (vdev->fops->open)
	267	ret = vdev->fops->open(filp);
	268
dc93a70c HV	269	/* decrease the refcount in case of an error */
	270	if (ret)
	271	video_put(vdev);
	272	return ret;
	273	}
	274
	275	/* Override for the release function */
	276	static int v4l2_release(struct inode inode, struct file filp)
	277	{
	278	struct video_device *vdev = video_devdata(filp);
65d9ff9c HV	279	int ret = 0;
	280
	281	if (vdev->fops->release)
	282	vdev->fops->release(filp);
dc93a70c HV	283
	284	/* decrease the refcount unconditionally since the release()
	285	return value is ignored. */
	286	video_put(vdev);
	287	return ret;
	288	}
	289
dc93a70c HV	290	static const struct file_operations v4l2_fops = {
	291	.owner = THIS_MODULE,
	292	.read = v4l2_read,
	293	.write = v4l2_write,
	294	.open = v4l2_open,
	295	.mmap = v4l2_mmap,
86a5ef7d	296	.unlocked_ioctl = v4l2_ioctl,
dc93a70c	297	#ifdef CONFIG_COMPAT
9bb7cde7	298	.compat_ioctl = v4l2_compat_ioctl32,
dc93a70c HV	299	#endif
	300	.release = v4l2_release,
	301	.poll = v4l2_poll,
	302	.llseek = no_llseek,
	303	};
	304
27a5e6d3	305	/**
7ae0cd9b	306	* get_index - assign stream index number based on parent device
dc93a70c	307	* @vdev: video_device to assign index number to, vdev->parent should be assigned
27a5e6d3	308	*
dc93a70c	309	* Note that when this is called the new device has not yet been registered
7ae0cd9b	310	* in the video_device array, but it was able to obtain a minor number.
27a5e6d3	311	*
7ae0cd9b HV	312	* This means that we can always obtain a free stream index number since
	313	* the worst case scenario is that there are VIDEO_NUM_DEVICES - 1 slots in
	314	* use of the video_device array.
	315	*
	316	* Returns a free index number.
27a5e6d3	317	*/
7ae0cd9b	318	static int get_index(struct video_device *vdev)
27a5e6d3	319	{
775a05dd HV	320	/* This can be static since this function is called with the global
	321	videodev_lock held. */
	322	static DECLARE_BITMAP(used, VIDEO_NUM_DEVICES);
27a5e6d3 HV	323	int i;
27a5e6d3 HV	324
7ae0cd9b	325	/* Some drivers do not set the parent. In that case always return 0. */
806e5b7c	326	if (vdev->parent == NULL)
7ae0cd9b	327	return 0;
775a05dd HV	328
775a05dd HV	329	bitmap_zero(used, VIDEO_NUM_DEVICES);
806e5b7c	330
27a5e6d3 HV	331	for (i = 0; i < VIDEO_NUM_DEVICES; i++) {
27a5e6d3 HV	332	if (video_device[i] != NULL &&
5e85e732	333	video_device[i]->parent == vdev->parent) {
775a05dd	334	set_bit(video_device[i]->index, used);
27a5e6d3 HV	335	}
	336	}
	337
7ae0cd9b	338	return find_first_zero_bit(used, VIDEO_NUM_DEVICES);
27a5e6d3 HV	339	}
27a5e6d3 HV	340
27a5e6d3	341	/**
7ae0cd9b	342	* video_register_device - register video4linux devices
dc93a70c	343	* @vdev: video device structure we want to register
27a5e6d3	344	* @type: type of device to register
22e22125	345	* @nr: which device node number (0 == /dev/video0, 1 == /dev/video1, ...
27a5e6d3	346	* -1 == first free)
6b5270d2 HV	347	* @warn_if_nr_in_use: warn if the desired device node number
6b5270d2 HV	348	* was already in use and another number was chosen instead.
27a5e6d3	349	*
22e22125 HV	350	* The registration code assigns minor numbers and device node numbers
	351	* based on the requested type and registers the new device node with
	352	* the kernel.
	353	* An error is returned if no free minor or device node number could be
	354	* found, or if the registration of the device node failed.
27a5e6d3 HV	355	*
	356	* Zero is returned on success.
	357	*
	358	* Valid types are
	359	*
	360	* %VFL_TYPE_GRABBER - A frame grabber
	361	*
27a5e6d3 HV	362	* %VFL_TYPE_VBI - Vertical blank data (undecoded)
	363	*
	364	* %VFL_TYPE_RADIO - A radio card
	365	*/
6b5270d2 HV	366	static int __video_register_device(struct video_device *vdev, int type, int nr,
6b5270d2 HV	367	int warn_if_nr_in_use)
27a5e6d3 HV	368	{
27a5e6d3 HV	369	int i = 0;
27a5e6d3	370	int ret;
dd89601d HV	371	int minor_offset = 0;
	372	int minor_cnt = VIDEO_NUM_DEVICES;
	373	const char *name_base;
1bb64194	374	void *priv = vdev->dev.p;
27a5e6d3	375
dc93a70c HV	376	/* A minor value of -1 marks this video device as never
dc93a70c HV	377	having been registered */
428c8d19	378	vdev->minor = -1;
ee7aa9f8	379
dc93a70c	380	/* the release callback MUST be present */
428c8d19 TP	381	WARN_ON(!vdev->release);
428c8d19 TP	382	if (!vdev->release)
f3b9f50e HK	383	return -EINVAL;
f3b9f50e HK	384
1babcb46 SA	385	/* v4l2_fh support */
	386	spin_lock_init(&vdev->fh_lock);
	387	INIT_LIST_HEAD(&vdev->fh_list);
	388
dc93a70c	389	/* Part 1: check device type */
27a5e6d3 HV	390	switch (type) {
27a5e6d3 HV	391	case VFL_TYPE_GRABBER:
27a5e6d3 HV	392	name_base = "video";
27a5e6d3 HV	393	break;
27a5e6d3	394	case VFL_TYPE_VBI:
27a5e6d3 HV	395	name_base = "vbi";
	396	break;
	397	case VFL_TYPE_RADIO:
27a5e6d3 HV	398	name_base = "radio";
	399	break;
	400	default:
	401	printk(KERN_ERR "%s called with unknown type: %d\n",
	402	__func__, type);
46f2c21c	403	return -EINVAL;
27a5e6d3 HV	404	}
27a5e6d3 HV	405
dc93a70c HV	406	vdev->vfl_type = type;
dc93a70c HV	407	vdev->cdev = NULL;
11bbc1ca HV	408	if (vdev->v4l2_dev) {
	409	if (vdev->v4l2_dev->dev)
	410	vdev->parent = vdev->v4l2_dev->dev;
	411	if (vdev->ctrl_handler == NULL)
	412	vdev->ctrl_handler = vdev->v4l2_dev->ctrl_handler;
	413	}
dd89601d	414
22e22125	415	/* Part 2: find a free minor, device node number and device index. */
dd89601d HV	416	#ifdef CONFIG_VIDEO_FIXED_MINOR_RANGES
	417	/* Keep the ranges for the first four types for historical
	418	* reasons.
	419	* Newer devices (not yet in place) should use the range
	420	* of 128-191 and just pick the first free minor there
	421	* (new style). */
	422	switch (type) {
	423	case VFL_TYPE_GRABBER:
	424	minor_offset = 0;
	425	minor_cnt = 64;
	426	break;
	427	case VFL_TYPE_RADIO:
	428	minor_offset = 64;
	429	minor_cnt = 64;
	430	break;
dd89601d HV	431	case VFL_TYPE_VBI:
	432	minor_offset = 224;
	433	minor_cnt = 32;
	434	break;
	435	default:
	436	minor_offset = 128;
	437	minor_cnt = 64;
	438	break;
	439	}
	440	#endif
	441
22e22125	442	/* Pick a device node number */
27a5e6d3	443	mutex_lock(&videodev_lock);
5062cb70	444	nr = devnode_find(vdev, nr == -1 ? 0 : nr, minor_cnt);
dd89601d	445	if (nr == minor_cnt)
5062cb70	446	nr = devnode_find(vdev, 0, minor_cnt);
dd89601d	447	if (nr == minor_cnt) {
22e22125	448	printk(KERN_ERR "could not get a free device node number\n");
dd89601d HV	449	mutex_unlock(&videodev_lock);
dd89601d HV	450	return -ENFILE;
27a5e6d3	451	}
dd89601d	452	#ifdef CONFIG_VIDEO_FIXED_MINOR_RANGES
22e22125	453	/* 1-on-1 mapping of device node number to minor number */
dd89601d HV	454	i = nr;
dd89601d HV	455	#else
22e22125 HV	456	/* The device node number and minor numbers are independent, so
22e22125 HV	457	we just find the first free minor number. */
dd89601d HV	458	for (i = 0; i < VIDEO_NUM_DEVICES; i++)
	459	if (video_device[i] == NULL)
	460	break;
	461	if (i == VIDEO_NUM_DEVICES) {
	462	mutex_unlock(&videodev_lock);
	463	printk(KERN_ERR "could not get a free minor\n");
	464	return -ENFILE;
	465	}
	466	#endif
dc93a70c HV	467	vdev->minor = i + minor_offset;
dc93a70c HV	468	vdev->num = nr;
5062cb70 HV	469	devnode_set(vdev);
5062cb70 HV	470
dc93a70c HV	471	/* Should not happen since we thought this minor was free */
dc93a70c HV	472	WARN_ON(video_device[vdev->minor] != NULL);
7ae0cd9b	473	vdev->index = get_index(vdev);
27a5e6d3 HV	474	mutex_unlock(&videodev_lock);
27a5e6d3 HV	475
dc93a70c HV	476	/* Part 3: Initialize the character device */
	477	vdev->cdev = cdev_alloc();
	478	if (vdev->cdev == NULL) {
	479	ret = -ENOMEM;
	480	goto cleanup;
	481	}
86a5ef7d	482	vdev->cdev->ops = &v4l2_fops;
dc93a70c HV	483	vdev->cdev->owner = vdev->fops->owner;
dc93a70c HV	484	ret = cdev_add(vdev->cdev, MKDEV(VIDEO_MAJOR, vdev->minor), 1);
7f8ecfab HV	485	if (ret < 0) {
7f8ecfab HV	486	printk(KERN_ERR "%s: cdev_add failed\n", __func__);
dc93a70c HV	487	kfree(vdev->cdev);
	488	vdev->cdev = NULL;
	489	goto cleanup;
7f8ecfab	490	}
dc93a70c HV	491
	492	/* Part 4: register the device with sysfs */
	493	memset(&vdev->dev, 0, sizeof(vdev->dev));
1bb64194	494	/* The memset above cleared the device's device_private, so
9d95af9d	495	put back the copy we made earlier. */
1bb64194	496	vdev->dev.p = priv;
dc93a70c HV	497	vdev->dev.class = &video_class;
	498	vdev->dev.devt = MKDEV(VIDEO_MAJOR, vdev->minor);
	499	if (vdev->parent)
	500	vdev->dev.parent = vdev->parent;
22e22125	501	dev_set_name(&vdev->dev, "%s%d", name_base, vdev->num);
dc93a70c	502	ret = device_register(&vdev->dev);
27a5e6d3 HV	503	if (ret < 0) {
27a5e6d3 HV	504	printk(KERN_ERR "%s: device_register failed\n", __func__);
dc93a70c	505	goto cleanup;
27a5e6d3	506	}
dc93a70c HV	507	/* Register the release callback that will be called when the last
	508	reference to the device goes away. */
	509	vdev->dev.release = v4l2_device_release;
27a5e6d3	510
6b5270d2	511	if (nr != -1 && nr != vdev->num && warn_if_nr_in_use)
eac8ea53 LP	512	printk(KERN_WARNING "%s: requested %s%d, got %s\n", __func__,
eac8ea53 LP	513	name_base, nr, video_device_node_name(vdev));
6b5270d2	514
dc93a70c	515	/* Part 5: Activate this minor. The char device can now be used. */
957b4aa9	516	set_bit(V4L2_FL_REGISTERED, &vdev->flags);
dc93a70c HV	517	mutex_lock(&videodev_lock);
	518	video_device[vdev->minor] = vdev;
	519	mutex_unlock(&videodev_lock);
	520	return 0;
7f8ecfab	521
dc93a70c	522	cleanup:
27a5e6d3	523	mutex_lock(&videodev_lock);
dc93a70c HV	524	if (vdev->cdev)
dc93a70c HV	525	cdev_del(vdev->cdev);
5062cb70	526	devnode_clear(vdev);
27a5e6d3	527	mutex_unlock(&videodev_lock);
dc93a70c HV	528	/* Mark this video device as never having been registered. */
dc93a70c HV	529	vdev->minor = -1;
27a5e6d3 HV	530	return ret;
27a5e6d3 HV	531	}
6b5270d2 HV	532
	533	int video_register_device(struct video_device *vdev, int type, int nr)
	534	{
	535	return __video_register_device(vdev, type, nr, 1);
	536	}
7ae0cd9b	537	EXPORT_SYMBOL(video_register_device);
27a5e6d3	538
6b5270d2 HV	539	int video_register_device_no_warn(struct video_device *vdev, int type, int nr)
	540	{
	541	return __video_register_device(vdev, type, nr, 0);
	542	}
	543	EXPORT_SYMBOL(video_register_device_no_warn);
	544
27a5e6d3 HV	545	/**
27a5e6d3 HV	546	* video_unregister_device - unregister a video4linux device
dc93a70c	547	* @vdev: the device to unregister
27a5e6d3	548	*
dc93a70c HV	549	* This unregisters the passed device. Future open calls will
dc93a70c HV	550	* be met with errors.
27a5e6d3	551	*/
dc93a70c	552	void video_unregister_device(struct video_device *vdev)
27a5e6d3	553	{
dc93a70c	554	/* Check if vdev was ever registered at all */
957b4aa9	555	if (!vdev \|\| !video_is_registered(vdev))
dc93a70c HV	556	return;
dc93a70c HV	557
957b4aa9	558	clear_bit(V4L2_FL_REGISTERED, &vdev->flags);
dc93a70c	559	device_unregister(&vdev->dev);
27a5e6d3 HV	560	}
	561	EXPORT_SYMBOL(video_unregister_device);
	562
27a5e6d3 HV	563	/*
	564	* Initialise video for linux
	565	*/
27a5e6d3 HV	566	static int __init videodev_init(void)
27a5e6d3 HV	567	{
7f8ecfab	568	dev_t dev = MKDEV(VIDEO_MAJOR, 0);
27a5e6d3 HV	569	int ret;
	570
	571	printk(KERN_INFO "Linux video capture interface: v2.00\n");
7f8ecfab HV	572	ret = register_chrdev_region(dev, VIDEO_NUM_DEVICES, VIDEO_NAME);
	573	if (ret < 0) {
	574	printk(KERN_WARNING "videodev: unable to get major %d\n",
	575	VIDEO_MAJOR);
	576	return ret;
27a5e6d3 HV	577	}
	578
	579	ret = class_register(&video_class);
	580	if (ret < 0) {
7f8ecfab	581	unregister_chrdev_region(dev, VIDEO_NUM_DEVICES);
27a5e6d3 HV	582	printk(KERN_WARNING "video_dev: class_register failed\n");
	583	return -EIO;
	584	}
	585
	586	return 0;
	587	}
	588
	589	static void __exit videodev_exit(void)
	590	{
7f8ecfab HV	591	dev_t dev = MKDEV(VIDEO_MAJOR, 0);
7f8ecfab HV	592
27a5e6d3	593	class_unregister(&video_class);
7f8ecfab	594	unregister_chrdev_region(dev, VIDEO_NUM_DEVICES);
27a5e6d3 HV	595	}
	596
	597	module_init(videodev_init)
	598	module_exit(videodev_exit)
	599
	600	MODULE_AUTHOR("Alan Cox, Mauro Carvalho Chehab <mchehab@infradead.org>");
	601	MODULE_DESCRIPTION("Device registrar for Video4Linux drivers v2");
	602	MODULE_LICENSE("GPL");
cbb72b0f	603	MODULE_ALIAS_CHARDEV_MAJOR(VIDEO_MAJOR);
27a5e6d3 HV	604
	605
	606	/*
	607	* Local variables:
	608	* c-basic-offset: 8
	609	* End:
	610	*/