[net-next-2.6.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_VTX) ? 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;

	/* Allow ioctl to continue even if the device was unregistered.
	   Things like dequeueing buffers might still be useful. */
	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;
}

#ifdef CONFIG_MMU
#define v4l2_get_unmapped_area NULL
#else
static unsigned long v4l2_get_unmapped_area(struct file *filp,
		unsigned long addr, unsigned long len, unsigned long pgoff,
		unsigned long flags)
{
	struct video_device *vdev = video_devdata(filp);

	if (!vdev->fops->get_unmapped_area)
		return -ENOSYS;
	if (!video_is_registered(vdev))
		return -ENODEV;
	return vdev->fops->get_unmapped_area(filp, addr, len, pgoff, flags);
}
#endif

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,
	.get_unmapped_area = v4l2_get_unmapped_area,
	.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_VTX - A teletext device
 *
 *	%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 = video_get_drvdata(vdev);

	/* 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_VTX:
		name_base = "vtx";
		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 && vdev->v4l2_dev->dev)
		vdev->parent = vdev->v4l2_dev->dev;

	/* 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_VTX:
		minor_offset = 192;
		minor_cnt = 32;
		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 drvdata, so
	   put back the copy we made earlier. */
	video_set_drvdata(vdev, 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. */
	84	int idx = (vfl_type > VFL_TYPE_VTX) ? VFL_TYPE_MAX - 1 : vfl_type;
	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
dc93a70c HV	224	/* Allow ioctl to continue even if the device was unregistered.
dc93a70c HV	225	Things like dequeueing buffers might still be useful. */
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
c01f1a5a DG	239	#ifdef CONFIG_MMU
	240	#define v4l2_get_unmapped_area NULL
	241	#else
	242	static unsigned long v4l2_get_unmapped_area(struct file *filp,
	243	unsigned long addr, unsigned long len, unsigned long pgoff,
	244	unsigned long flags)
	245	{
	246	struct video_device *vdev = video_devdata(filp);
	247
	248	if (!vdev->fops->get_unmapped_area)
	249	return -ENOSYS;
957b4aa9	250	if (!video_is_registered(vdev))
c01f1a5a DG	251	return -ENODEV;
	252	return vdev->fops->get_unmapped_area(filp, addr, len, pgoff, flags);
	253	}
	254	#endif
	255
dc93a70c HV	256	static int v4l2_mmap(struct file filp, struct vm_area_struct vm)
	257	{
	258	struct video_device *vdev = video_devdata(filp);
	259
957b4aa9	260	if (!vdev->fops->mmap \|\| !video_is_registered(vdev))
dc93a70c HV	261	return -ENODEV;
	262	return vdev->fops->mmap(filp, vm);
	263	}
	264
	265	/* Override for the open function */
	266	static int v4l2_open(struct inode inode, struct file filp)
	267	{
	268	struct video_device *vdev;
65d9ff9c	269	int ret = 0;
dc93a70c HV	270
	271	/* Check if the video device is available */
	272	mutex_lock(&videodev_lock);
	273	vdev = video_devdata(filp);
	274	/* return ENODEV if the video device has been removed
	275	already or if it is not registered anymore. */
957b4aa9	276	if (vdev == NULL \|\| !video_is_registered(vdev)) {
dc93a70c HV	277	mutex_unlock(&videodev_lock);
	278	return -ENODEV;
	279	}
	280	/* and increase the device refcount */
	281	video_get(vdev);
	282	mutex_unlock(&videodev_lock);
65d9ff9c HV	283	if (vdev->fops->open)
	284	ret = vdev->fops->open(filp);
	285
dc93a70c HV	286	/* decrease the refcount in case of an error */
	287	if (ret)
	288	video_put(vdev);
	289	return ret;
	290	}
	291
	292	/* Override for the release function */
	293	static int v4l2_release(struct inode inode, struct file filp)
	294	{
	295	struct video_device *vdev = video_devdata(filp);
65d9ff9c HV	296	int ret = 0;
	297
	298	if (vdev->fops->release)
	299	vdev->fops->release(filp);
dc93a70c HV	300
	301	/* decrease the refcount unconditionally since the release()
	302	return value is ignored. */
	303	video_put(vdev);
	304	return ret;
	305	}
	306
dc93a70c HV	307	static const struct file_operations v4l2_fops = {
	308	.owner = THIS_MODULE,
	309	.read = v4l2_read,
	310	.write = v4l2_write,
	311	.open = v4l2_open,
c01f1a5a	312	.get_unmapped_area = v4l2_get_unmapped_area,
dc93a70c	313	.mmap = v4l2_mmap,
86a5ef7d	314	.unlocked_ioctl = v4l2_ioctl,
dc93a70c	315	#ifdef CONFIG_COMPAT
9bb7cde7	316	.compat_ioctl = v4l2_compat_ioctl32,
dc93a70c HV	317	#endif
	318	.release = v4l2_release,
	319	.poll = v4l2_poll,
	320	.llseek = no_llseek,
	321	};
	322
27a5e6d3	323	/**
7ae0cd9b	324	* get_index - assign stream index number based on parent device
dc93a70c	325	* @vdev: video_device to assign index number to, vdev->parent should be assigned
27a5e6d3	326	*
dc93a70c	327	* Note that when this is called the new device has not yet been registered
7ae0cd9b	328	* in the video_device array, but it was able to obtain a minor number.
27a5e6d3	329	*
7ae0cd9b HV	330	* This means that we can always obtain a free stream index number since
	331	* the worst case scenario is that there are VIDEO_NUM_DEVICES - 1 slots in
	332	* use of the video_device array.
	333	*
	334	* Returns a free index number.
27a5e6d3	335	*/
7ae0cd9b	336	static int get_index(struct video_device *vdev)
27a5e6d3	337	{
775a05dd HV	338	/* This can be static since this function is called with the global
	339	videodev_lock held. */
	340	static DECLARE_BITMAP(used, VIDEO_NUM_DEVICES);
27a5e6d3 HV	341	int i;
27a5e6d3 HV	342
7ae0cd9b	343	/* Some drivers do not set the parent. In that case always return 0. */
806e5b7c	344	if (vdev->parent == NULL)
7ae0cd9b	345	return 0;
775a05dd HV	346
775a05dd HV	347	bitmap_zero(used, VIDEO_NUM_DEVICES);
806e5b7c	348
27a5e6d3 HV	349	for (i = 0; i < VIDEO_NUM_DEVICES; i++) {
27a5e6d3 HV	350	if (video_device[i] != NULL &&
5e85e732	351	video_device[i]->parent == vdev->parent) {
775a05dd	352	set_bit(video_device[i]->index, used);
27a5e6d3 HV	353	}
	354	}
	355
7ae0cd9b	356	return find_first_zero_bit(used, VIDEO_NUM_DEVICES);
27a5e6d3 HV	357	}
27a5e6d3 HV	358
27a5e6d3	359	/**
7ae0cd9b	360	* video_register_device - register video4linux devices
dc93a70c	361	* @vdev: video device structure we want to register
27a5e6d3	362	* @type: type of device to register
22e22125	363	* @nr: which device node number (0 == /dev/video0, 1 == /dev/video1, ...
27a5e6d3	364	* -1 == first free)
6b5270d2 HV	365	* @warn_if_nr_in_use: warn if the desired device node number
6b5270d2 HV	366	* was already in use and another number was chosen instead.
27a5e6d3	367	*
22e22125 HV	368	* The registration code assigns minor numbers and device node numbers
	369	* based on the requested type and registers the new device node with
	370	* the kernel.
	371	* An error is returned if no free minor or device node number could be
	372	* found, or if the registration of the device node failed.
27a5e6d3 HV	373	*
	374	* Zero is returned on success.
	375	*
	376	* Valid types are
	377	*
	378	* %VFL_TYPE_GRABBER - A frame grabber
	379	*
	380	* %VFL_TYPE_VTX - A teletext device
	381	*
	382	* %VFL_TYPE_VBI - Vertical blank data (undecoded)
	383	*
	384	* %VFL_TYPE_RADIO - A radio card
	385	*/
6b5270d2 HV	386	static int __video_register_device(struct video_device *vdev, int type, int nr,
6b5270d2 HV	387	int warn_if_nr_in_use)
27a5e6d3 HV	388	{
27a5e6d3 HV	389	int i = 0;
27a5e6d3	390	int ret;
dd89601d HV	391	int minor_offset = 0;
	392	int minor_cnt = VIDEO_NUM_DEVICES;
	393	const char *name_base;
dc93a70c	394	void *priv = video_get_drvdata(vdev);
27a5e6d3	395
dc93a70c HV	396	/* A minor value of -1 marks this video device as never
dc93a70c HV	397	having been registered */
428c8d19	398	vdev->minor = -1;
ee7aa9f8	399
dc93a70c	400	/* the release callback MUST be present */
428c8d19 TP	401	WARN_ON(!vdev->release);
428c8d19 TP	402	if (!vdev->release)
f3b9f50e HK	403	return -EINVAL;
f3b9f50e HK	404
1babcb46 SA	405	/* v4l2_fh support */
	406	spin_lock_init(&vdev->fh_lock);
	407	INIT_LIST_HEAD(&vdev->fh_list);
	408
dc93a70c	409	/* Part 1: check device type */
27a5e6d3 HV	410	switch (type) {
27a5e6d3 HV	411	case VFL_TYPE_GRABBER:
27a5e6d3 HV	412	name_base = "video";
	413	break;
	414	case VFL_TYPE_VTX:
27a5e6d3 HV	415	name_base = "vtx";
	416	break;
	417	case VFL_TYPE_VBI:
27a5e6d3 HV	418	name_base = "vbi";
	419	break;
	420	case VFL_TYPE_RADIO:
27a5e6d3 HV	421	name_base = "radio";
	422	break;
	423	default:
	424	printk(KERN_ERR "%s called with unknown type: %d\n",
	425	__func__, type);
46f2c21c	426	return -EINVAL;
27a5e6d3 HV	427	}
27a5e6d3 HV	428
dc93a70c HV	429	vdev->vfl_type = type;
dc93a70c HV	430	vdev->cdev = NULL;
00575961	431	if (vdev->v4l2_dev && vdev->v4l2_dev->dev)
9bea3514	432	vdev->parent = vdev->v4l2_dev->dev;
dd89601d	433
22e22125	434	/* Part 2: find a free minor, device node number and device index. */
dd89601d HV	435	#ifdef CONFIG_VIDEO_FIXED_MINOR_RANGES
	436	/* Keep the ranges for the first four types for historical
	437	* reasons.
	438	* Newer devices (not yet in place) should use the range
	439	* of 128-191 and just pick the first free minor there
	440	* (new style). */
	441	switch (type) {
	442	case VFL_TYPE_GRABBER:
	443	minor_offset = 0;
	444	minor_cnt = 64;
	445	break;
	446	case VFL_TYPE_RADIO:
	447	minor_offset = 64;
	448	minor_cnt = 64;
	449	break;
	450	case VFL_TYPE_VTX:
	451	minor_offset = 192;
	452	minor_cnt = 32;
	453	break;
	454	case VFL_TYPE_VBI:
	455	minor_offset = 224;
	456	minor_cnt = 32;
	457	break;
	458	default:
	459	minor_offset = 128;
	460	minor_cnt = 64;
	461	break;
	462	}
	463	#endif
	464
22e22125	465	/* Pick a device node number */
27a5e6d3	466	mutex_lock(&videodev_lock);
5062cb70	467	nr = devnode_find(vdev, nr == -1 ? 0 : nr, minor_cnt);
dd89601d	468	if (nr == minor_cnt)
5062cb70	469	nr = devnode_find(vdev, 0, minor_cnt);
dd89601d	470	if (nr == minor_cnt) {
22e22125	471	printk(KERN_ERR "could not get a free device node number\n");
dd89601d HV	472	mutex_unlock(&videodev_lock);
dd89601d HV	473	return -ENFILE;
27a5e6d3	474	}
dd89601d	475	#ifdef CONFIG_VIDEO_FIXED_MINOR_RANGES
22e22125	476	/* 1-on-1 mapping of device node number to minor number */
dd89601d HV	477	i = nr;
dd89601d HV	478	#else
22e22125 HV	479	/* The device node number and minor numbers are independent, so
22e22125 HV	480	we just find the first free minor number. */
dd89601d HV	481	for (i = 0; i < VIDEO_NUM_DEVICES; i++)
	482	if (video_device[i] == NULL)
	483	break;
	484	if (i == VIDEO_NUM_DEVICES) {
	485	mutex_unlock(&videodev_lock);
	486	printk(KERN_ERR "could not get a free minor\n");
	487	return -ENFILE;
	488	}
	489	#endif
dc93a70c HV	490	vdev->minor = i + minor_offset;
dc93a70c HV	491	vdev->num = nr;
5062cb70 HV	492	devnode_set(vdev);
5062cb70 HV	493
dc93a70c HV	494	/* Should not happen since we thought this minor was free */
dc93a70c HV	495	WARN_ON(video_device[vdev->minor] != NULL);
7ae0cd9b	496	vdev->index = get_index(vdev);
27a5e6d3 HV	497	mutex_unlock(&videodev_lock);
27a5e6d3 HV	498
dc93a70c HV	499	/* Part 3: Initialize the character device */
	500	vdev->cdev = cdev_alloc();
	501	if (vdev->cdev == NULL) {
	502	ret = -ENOMEM;
	503	goto cleanup;
	504	}
86a5ef7d	505	vdev->cdev->ops = &v4l2_fops;
dc93a70c HV	506	vdev->cdev->owner = vdev->fops->owner;
dc93a70c HV	507	ret = cdev_add(vdev->cdev, MKDEV(VIDEO_MAJOR, vdev->minor), 1);
7f8ecfab HV	508	if (ret < 0) {
7f8ecfab HV	509	printk(KERN_ERR "%s: cdev_add failed\n", __func__);
dc93a70c HV	510	kfree(vdev->cdev);
	511	vdev->cdev = NULL;
	512	goto cleanup;
7f8ecfab	513	}
dc93a70c HV	514
	515	/* Part 4: register the device with sysfs */
	516	memset(&vdev->dev, 0, sizeof(vdev->dev));
9d95af9d HV	517	/* The memset above cleared the device's drvdata, so
9d95af9d HV	518	put back the copy we made earlier. */
dc93a70c HV	519	video_set_drvdata(vdev, priv);
	520	vdev->dev.class = &video_class;
	521	vdev->dev.devt = MKDEV(VIDEO_MAJOR, vdev->minor);
	522	if (vdev->parent)
	523	vdev->dev.parent = vdev->parent;
22e22125	524	dev_set_name(&vdev->dev, "%s%d", name_base, vdev->num);
dc93a70c	525	ret = device_register(&vdev->dev);
27a5e6d3 HV	526	if (ret < 0) {
27a5e6d3 HV	527	printk(KERN_ERR "%s: device_register failed\n", __func__);
dc93a70c	528	goto cleanup;
27a5e6d3	529	}
dc93a70c HV	530	/* Register the release callback that will be called when the last
	531	reference to the device goes away. */
	532	vdev->dev.release = v4l2_device_release;
27a5e6d3	533
6b5270d2	534	if (nr != -1 && nr != vdev->num && warn_if_nr_in_use)
eac8ea53 LP	535	printk(KERN_WARNING "%s: requested %s%d, got %s\n", __func__,
eac8ea53 LP	536	name_base, nr, video_device_node_name(vdev));
6b5270d2	537
dc93a70c	538	/* Part 5: Activate this minor. The char device can now be used. */
957b4aa9	539	set_bit(V4L2_FL_REGISTERED, &vdev->flags);
dc93a70c HV	540	mutex_lock(&videodev_lock);
	541	video_device[vdev->minor] = vdev;
	542	mutex_unlock(&videodev_lock);
	543	return 0;
7f8ecfab	544
dc93a70c	545	cleanup:
27a5e6d3	546	mutex_lock(&videodev_lock);
dc93a70c HV	547	if (vdev->cdev)
dc93a70c HV	548	cdev_del(vdev->cdev);
5062cb70	549	devnode_clear(vdev);
27a5e6d3	550	mutex_unlock(&videodev_lock);
dc93a70c HV	551	/* Mark this video device as never having been registered. */
dc93a70c HV	552	vdev->minor = -1;
27a5e6d3 HV	553	return ret;
27a5e6d3 HV	554	}
6b5270d2 HV	555
	556	int video_register_device(struct video_device *vdev, int type, int nr)
	557	{
	558	return __video_register_device(vdev, type, nr, 1);
	559	}
7ae0cd9b	560	EXPORT_SYMBOL(video_register_device);
27a5e6d3	561
6b5270d2 HV	562	int video_register_device_no_warn(struct video_device *vdev, int type, int nr)
	563	{
	564	return __video_register_device(vdev, type, nr, 0);
	565	}
	566	EXPORT_SYMBOL(video_register_device_no_warn);
	567
27a5e6d3 HV	568	/**
27a5e6d3 HV	569	* video_unregister_device - unregister a video4linux device
dc93a70c	570	* @vdev: the device to unregister
27a5e6d3	571	*
dc93a70c HV	572	* This unregisters the passed device. Future open calls will
dc93a70c HV	573	* be met with errors.
27a5e6d3	574	*/
dc93a70c	575	void video_unregister_device(struct video_device *vdev)
27a5e6d3	576	{
dc93a70c	577	/* Check if vdev was ever registered at all */
957b4aa9	578	if (!vdev \|\| !video_is_registered(vdev))
dc93a70c HV	579	return;
dc93a70c HV	580
957b4aa9	581	clear_bit(V4L2_FL_REGISTERED, &vdev->flags);
dc93a70c	582	device_unregister(&vdev->dev);
27a5e6d3 HV	583	}
	584	EXPORT_SYMBOL(video_unregister_device);
	585
27a5e6d3 HV	586	/*
	587	* Initialise video for linux
	588	*/
27a5e6d3 HV	589	static int __init videodev_init(void)
27a5e6d3 HV	590	{
7f8ecfab	591	dev_t dev = MKDEV(VIDEO_MAJOR, 0);
27a5e6d3 HV	592	int ret;
	593
	594	printk(KERN_INFO "Linux video capture interface: v2.00\n");
7f8ecfab HV	595	ret = register_chrdev_region(dev, VIDEO_NUM_DEVICES, VIDEO_NAME);
	596	if (ret < 0) {
	597	printk(KERN_WARNING "videodev: unable to get major %d\n",
	598	VIDEO_MAJOR);
	599	return ret;
27a5e6d3 HV	600	}
	601
	602	ret = class_register(&video_class);
	603	if (ret < 0) {
7f8ecfab	604	unregister_chrdev_region(dev, VIDEO_NUM_DEVICES);
27a5e6d3 HV	605	printk(KERN_WARNING "video_dev: class_register failed\n");
	606	return -EIO;
	607	}
	608
	609	return 0;
	610	}
	611
	612	static void __exit videodev_exit(void)
	613	{
7f8ecfab HV	614	dev_t dev = MKDEV(VIDEO_MAJOR, 0);
7f8ecfab HV	615
27a5e6d3	616	class_unregister(&video_class);
7f8ecfab	617	unregister_chrdev_region(dev, VIDEO_NUM_DEVICES);
27a5e6d3 HV	618	}
	619
	620	module_init(videodev_init)
	621	module_exit(videodev_exit)
	622
	623	MODULE_AUTHOR("Alan Cox, Mauro Carvalho Chehab <mchehab@infradead.org>");
	624	MODULE_DESCRIPTION("Device registrar for Video4Linux drivers v2");
	625	MODULE_LICENSE("GPL");
cbb72b0f	626	MODULE_ALIAS_CHARDEV_MAJOR(VIDEO_MAJOR);
27a5e6d3 HV	627
	628
	629	/*
	630	* Local variables:
	631	* c-basic-offset: 8
	632	* End:
	633	*/