[linux-block.git] / drivers / media / dvb / dvb-core / dvbdev.c

/*
 * dvbdev.c
 *
 * Copyright (C) 2000 Ralph  Metzler <ralph@convergence.de>
 *                  & Marcus Metzler <marcus@convergence.de>
 *                    for convergence integrated media GmbH
 *
 * This program is free software; you can redistribute it and/or
 * modify it under the terms of the GNU Lesser General Public License
 * as published by the Free Software Foundation; either version 2.1
 * of the License, or (at your option) any later version.
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU Lesser General Public License
 * along with this program; if not, write to the Free Software
 * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
 *
 */

#include <linux/types.h>
#include <linux/errno.h>
#include <linux/string.h>
#include <linux/module.h>
#include <linux/moduleparam.h>
#include <linux/kernel.h>
#include <linux/sched.h>
#include <linux/init.h>
#include <linux/slab.h>
#include <linux/device.h>
#include <linux/fs.h>
#include <linux/cdev.h>

#include "dvbdev.h"

static int dvbdev_debug;

module_param(dvbdev_debug, int, 0644);
MODULE_PARM_DESC(dvbdev_debug, "Turn on/off device debugging (default:off).");

#define dprintk if (dvbdev_debug) printk

static LIST_HEAD(dvb_adapter_list);
static DECLARE_MUTEX(dvbdev_register_lock);

static const char * const dnames[] = {
        "video", "audio", "sec", "frontend", "demux", "dvr", "ca",
	"net", "osd"
};

#define DVB_MAX_ADAPTERS	8
#define DVB_MAX_IDS		4
#define nums2minor(num,type,id)	((num << 6) | (id << 4) | type)
#define MAX_DVB_MINORS		(DVB_MAX_ADAPTERS*64)

static struct class *dvb_class;

static struct dvb_device* dvbdev_find_device (int minor)
{
	struct list_head *entry;

	list_for_each (entry, &dvb_adapter_list) {
		struct list_head *entry0;
		struct dvb_adapter *adap;
		adap = list_entry (entry, struct dvb_adapter, list_head);
		list_for_each (entry0, &adap->device_list) {
			struct dvb_device *dev;
			dev = list_entry (entry0, struct dvb_device, list_head);
			if (nums2minor(adap->num, dev->type, dev->id) == minor)
				return dev;
		}
	}

	return NULL;
}


static int dvb_device_open(struct inode *inode, struct file *file)
{
	struct dvb_device *dvbdev;

	dvbdev = dvbdev_find_device (iminor(inode));

	if (dvbdev && dvbdev->fops) {
		int err = 0;
		struct file_operations *old_fops;

		file->private_data = dvbdev;
		old_fops = file->f_op;
                file->f_op = fops_get(dvbdev->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);
                return err;
	}
	return -ENODEV;
}


static struct file_operations dvb_device_fops =
{
	.owner =	THIS_MODULE,
	.open =		dvb_device_open,
};

static struct cdev dvb_device_cdev = {
	.kobj   = {.name = "dvb", },
	.owner  =       THIS_MODULE,
};

int dvb_generic_open(struct inode *inode, struct file *file)
{
        struct dvb_device *dvbdev = file->private_data;

        if (!dvbdev)
                return -ENODEV;

	if (!dvbdev->users)
                return -EBUSY;

	if ((file->f_flags & O_ACCMODE) == O_RDONLY) {
                if (!dvbdev->readers)
		        return -EBUSY;
		dvbdev->readers--;
	} else {
                if (!dvbdev->writers)
		        return -EBUSY;
		dvbdev->writers--;
	}

	dvbdev->users--;
	return 0;
}
EXPORT_SYMBOL(dvb_generic_open);


int dvb_generic_release(struct inode *inode, struct file *file)
{
        struct dvb_device *dvbdev = file->private_data;

	if (!dvbdev)
                return -ENODEV;

	if ((file->f_flags & O_ACCMODE) == O_RDONLY) {
		dvbdev->readers++;
	} else {
		dvbdev->writers++;
	}

	dvbdev->users++;
	return 0;
}
EXPORT_SYMBOL(dvb_generic_release);


int dvb_generic_ioctl(struct inode *inode, struct file *file,
		      unsigned int cmd, unsigned long arg)
{
        struct dvb_device *dvbdev = file->private_data;

        if (!dvbdev)
	        return -ENODEV;

	if (!dvbdev->kernel_ioctl)
		return -EINVAL;

	return dvb_usercopy (inode, file, cmd, arg, dvbdev->kernel_ioctl);
}
EXPORT_SYMBOL(dvb_generic_ioctl);


static int dvbdev_get_free_id (struct dvb_adapter *adap, int type)
{
	u32 id = 0;

	while (id < DVB_MAX_IDS) {
		struct list_head *entry;
		list_for_each (entry, &adap->device_list) {
			struct dvb_device *dev;
			dev = list_entry (entry, struct dvb_device, list_head);
			if (dev->type == type && dev->id == id)
				goto skip;
		}
		return id;
skip:
		id++;
	}
	return -ENFILE;
}


int dvb_register_device(struct dvb_adapter *adap, struct dvb_device **pdvbdev,
			const struct dvb_device *template, void *priv, int type)
{
	struct dvb_device *dvbdev;
	int id;

	if (down_interruptible (&dvbdev_register_lock))
		return -ERESTARTSYS;

	if ((id = dvbdev_get_free_id (adap, type)) < 0) {
		up (&dvbdev_register_lock);
		*pdvbdev = NULL;
		printk ("%s: could get find free device id...\n", __FUNCTION__);
		return -ENFILE;
	}

	*pdvbdev = dvbdev = kmalloc(sizeof(struct dvb_device), GFP_KERNEL);

	if (!dvbdev) {
		up(&dvbdev_register_lock);
		return -ENOMEM;
	}

	up (&dvbdev_register_lock);

	memcpy(dvbdev, template, sizeof(struct dvb_device));
	dvbdev->type = type;
	dvbdev->id = id;
	dvbdev->adapter = adap;
	dvbdev->priv = priv;

	dvbdev->fops->owner = adap->module;

	list_add_tail (&dvbdev->list_head, &adap->device_list);

	devfs_mk_cdev(MKDEV(DVB_MAJOR, nums2minor(adap->num, type, id)),
			S_IFCHR | S_IRUSR | S_IWUSR,
			"dvb/adapter%d/%s%d", adap->num, dnames[type], id);

	class_device_create(dvb_class, MKDEV(DVB_MAJOR, nums2minor(adap->num, type, id)),
			    NULL, "dvb%d.%s%d", adap->num, dnames[type], id);

	dprintk("DVB: register adapter%d/%s%d @ minor: %i (0x%02x)\n",
		adap->num, dnames[type], id, nums2minor(adap->num, type, id),
		nums2minor(adap->num, type, id));

	return 0;
}
EXPORT_SYMBOL(dvb_register_device);


void dvb_unregister_device(struct dvb_device *dvbdev)
{
	if (!dvbdev)
		return;

	devfs_remove("dvb/adapter%d/%s%d", dvbdev->adapter->num,
			dnames[dvbdev->type], dvbdev->id);

	class_device_destroy(dvb_class, MKDEV(DVB_MAJOR, nums2minor(dvbdev->adapter->num,
					dvbdev->type, dvbdev->id)));

	list_del (&dvbdev->list_head);
	kfree (dvbdev);
}
EXPORT_SYMBOL(dvb_unregister_device);


static int dvbdev_get_free_adapter_num (void)
{
	int num = 0;

	while (num < DVB_MAX_ADAPTERS) {
		struct list_head *entry;
		list_for_each (entry, &dvb_adapter_list) {
			struct dvb_adapter *adap;
			adap = list_entry (entry, struct dvb_adapter, list_head);
			if (adap->num == num)
				goto skip;
		}
		return num;
skip:
		num++;
	}

	return -ENFILE;
}


int dvb_register_adapter(struct dvb_adapter *adap, const char *name, struct module *module)
{
	int num;

	if (down_interruptible (&dvbdev_register_lock))
		return -ERESTARTSYS;

	if ((num = dvbdev_get_free_adapter_num ()) < 0) {
		up (&dvbdev_register_lock);
		return -ENFILE;
	}

	memset (adap, 0, sizeof(struct dvb_adapter));
	INIT_LIST_HEAD (&adap->device_list);

	printk ("DVB: registering new adapter (%s).\n", name);

	devfs_mk_dir("dvb/adapter%d", num);
	adap->num = num;
	adap->name = name;
	adap->module = module;

	list_add_tail (&adap->list_head, &dvb_adapter_list);

	up (&dvbdev_register_lock);

	return num;
}
EXPORT_SYMBOL(dvb_register_adapter);


int dvb_unregister_adapter(struct dvb_adapter *adap)
{
	devfs_remove("dvb/adapter%d", adap->num);

	if (down_interruptible (&dvbdev_register_lock))
		return -ERESTARTSYS;
	list_del (&adap->list_head);
	up (&dvbdev_register_lock);
	return 0;
}
EXPORT_SYMBOL(dvb_unregister_adapter);

/* if the miracle happens and "generic_usercopy()" is included into
   the kernel, then this can vanish. please don't make the mistake and
   define this as video_usercopy(). this will introduce a dependecy
   to the v4l "videodev.o" module, which is unnecessary for some
   cards (ie. the budget dvb-cards don't need the v4l module...) */
int dvb_usercopy(struct inode *inode, struct file *file,
	             unsigned int cmd, unsigned long arg,
		     int (*func)(struct inode *inode, struct file *file,
		     unsigned int cmd, void *arg))
{
        char    sbuf[128];
        void    *mbuf = NULL;
        void    *parg = NULL;
        int     err  = -EINVAL;

        /*  Copy arguments into temp kernel buffer  */
        switch (_IOC_DIR(cmd)) {
        case _IOC_NONE:
		/*
		 * For this command, the pointer is actually an integer
		 * argument.
		 */
		parg = (void *) arg;
		break;
        case _IOC_READ: /* some v4l ioctls are marked wrong ... */
        case _IOC_WRITE:
        case (_IOC_WRITE | _IOC_READ):
                if (_IOC_SIZE(cmd) <= sizeof(sbuf)) {
                        parg = sbuf;
                } else {
                        /* too big to allocate from stack */
                        mbuf = kmalloc(_IOC_SIZE(cmd),GFP_KERNEL);
                        if (NULL == mbuf)
                                return -ENOMEM;
                        parg = mbuf;
                }

                err = -EFAULT;
                if (copy_from_user(parg, (void __user *)arg, _IOC_SIZE(cmd)))
                        goto out;
                break;
        }

        /* call driver */
        if ((err = func(inode, file, cmd, parg)) == -ENOIOCTLCMD)
                err = -EINVAL;

        if (err < 0)
                goto out;

        /*  Copy results into user buffer  */
        switch (_IOC_DIR(cmd))
        {
        case _IOC_READ:
        case (_IOC_WRITE | _IOC_READ):
                if (copy_to_user((void __user *)arg, parg, _IOC_SIZE(cmd)))
                        err = -EFAULT;
                break;
        }

out:
        kfree(mbuf);
        return err;
}

static int __init init_dvbdev(void)
{
	int retval;
	dev_t dev = MKDEV(DVB_MAJOR, 0);

	if ((retval = register_chrdev_region(dev, MAX_DVB_MINORS, "DVB")) != 0) {
		printk("dvb-core: unable to get major %d\n", DVB_MAJOR);
		return retval;
	}

	cdev_init(&dvb_device_cdev, &dvb_device_fops);
	if ((retval = cdev_add(&dvb_device_cdev, dev, MAX_DVB_MINORS)) != 0) {
		printk("dvb-core: unable to get major %d\n", DVB_MAJOR);
		goto error;
	}

	devfs_mk_dir("dvb");

	dvb_class = class_create(THIS_MODULE, "dvb");
	if (IS_ERR(dvb_class)) {
		retval = PTR_ERR(dvb_class);
		goto error;
	}
	return 0;

error:
	cdev_del(&dvb_device_cdev);
	unregister_chrdev_region(dev, MAX_DVB_MINORS);
	return retval;
}


static void __exit exit_dvbdev(void)
{
        devfs_remove("dvb");
	class_destroy(dvb_class);
	cdev_del(&dvb_device_cdev);
        unregister_chrdev_region(MKDEV(DVB_MAJOR, 0), MAX_DVB_MINORS);
}

module_init(init_dvbdev);
module_exit(exit_dvbdev);

MODULE_DESCRIPTION("DVB Core Driver");
MODULE_AUTHOR("Marcus Metzler, Ralph Metzler, Holger Waechtler");
MODULE_LICENSE("GPL");
Commit	Line	Data
1da177e4 LT	1	/*
	2	* dvbdev.c
	3	*
	4	* Copyright (C) 2000 Ralph Metzler <ralph@convergence.de>
	5	* & Marcus Metzler <marcus@convergence.de>
	6	* for convergence integrated media GmbH
	7	*
	8	* This program is free software; you can redistribute it and/or
	9	* modify it under the terms of the GNU Lesser General Public License
	10	* as published by the Free Software Foundation; either version 2.1
	11	* of the License, or (at your option) any later version.
	12	*
	13	* This program is distributed in the hope that it will be useful,
	14	* but WITHOUT ANY WARRANTY; without even the implied warranty of
	15	* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
	16	* GNU General Public License for more details.
	17	*
	18	* You should have received a copy of the GNU Lesser General Public License
	19	* along with this program; if not, write to the Free Software
	20	* Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
	21	*
	22	*/
	23
	24	#include <linux/types.h>
	25	#include <linux/errno.h>
	26	#include <linux/string.h>
	27	#include <linux/module.h>
	28	#include <linux/moduleparam.h>
	29	#include <linux/kernel.h>
	30	#include <linux/sched.h>
	31	#include <linux/init.h>
	32	#include <linux/slab.h>
	33	#include <linux/device.h>
	34	#include <linux/fs.h>
	35	#include <linux/cdev.h>
	36
	37	#include "dvbdev.h"
	38
	39	static int dvbdev_debug;
	40
	41	module_param(dvbdev_debug, int, 0644);
	42	MODULE_PARM_DESC(dvbdev_debug, "Turn on/off device debugging (default:off).");
	43
	44	#define dprintk if (dvbdev_debug) printk
	45
	46	static LIST_HEAD(dvb_adapter_list);
	47	static DECLARE_MUTEX(dvbdev_register_lock);
	48
	49	static const char * const dnames[] = {
	50	"video", "audio", "sec", "frontend", "demux", "dvr", "ca",
	51	"net", "osd"
	52	};
	53
	54	#define DVB_MAX_ADAPTERS 8
	55	#define DVB_MAX_IDS 4
	56	#define nums2minor(num,type,id) ((num << 6) \| (id << 4) \| type)
	57	#define MAX_DVB_MINORS (DVB_MAX_ADAPTERS*64)
	58
56b22935	59	static struct class *dvb_class;
1da177e4 LT	60
	61	static struct dvb_device* dvbdev_find_device (int minor)
	62	{
	63	struct list_head *entry;
	64
	65	list_for_each (entry, &dvb_adapter_list) {
	66	struct list_head *entry0;
	67	struct dvb_adapter *adap;
	68	adap = list_entry (entry, struct dvb_adapter, list_head);
	69	list_for_each (entry0, &adap->device_list) {
	70	struct dvb_device *dev;
	71	dev = list_entry (entry0, struct dvb_device, list_head);
	72	if (nums2minor(adap->num, dev->type, dev->id) == minor)
	73	return dev;
	74	}
	75	}
	76
	77	return NULL;
	78	}
	79
	80
	81	static int dvb_device_open(struct inode inode, struct file file)
	82	{
	83	struct dvb_device *dvbdev;
	84
	85	dvbdev = dvbdev_find_device (iminor(inode));
	86
	87	if (dvbdev && dvbdev->fops) {
	88	int err = 0;
	89	struct file_operations *old_fops;
	90
	91	file->private_data = dvbdev;
	92	old_fops = file->f_op;
	93	file->f_op = fops_get(dvbdev->fops);
	94	if(file->f_op->open)
	95	err = file->f_op->open(inode,file);
	96	if (err) {
	97	fops_put(file->f_op);
	98	file->f_op = fops_get(old_fops);
	99	}
	100	fops_put(old_fops);
	101	return err;
	102	}
	103	return -ENODEV;
	104	}
	105
	106
	107	static struct file_operations dvb_device_fops =
	108	{
	109	.owner = THIS_MODULE,
	110	.open = dvb_device_open,
	111	};
	112
	113	static struct cdev dvb_device_cdev = {
	114	.kobj = {.name = "dvb", },
	115	.owner = THIS_MODULE,
	116	};
	117
	118	int dvb_generic_open(struct inode inode, struct file file)
	119	{
	120	struct dvb_device *dvbdev = file->private_data;
	121
	122	if (!dvbdev)
	123	return -ENODEV;
124
125	if (!dvbdev->users)
126	return -EBUSY;
127
128	if ((file->f_flags & O_ACCMODE) == O_RDONLY) {
129	if (!dvbdev->readers)
130	return -EBUSY;
131	dvbdev->readers--;
132	} else {
133	if (!dvbdev->writers)
134	return -EBUSY;
135	dvbdev->writers--;
136	}
137
138	dvbdev->users--;
139	return 0;
140	}
141	EXPORT_SYMBOL(dvb_generic_open);
142
143
144	int dvb_generic_release(struct inode inode, struct file file)
145	{
146	struct dvb_device *dvbdev = file->private_data;
147
148	if (!dvbdev)
149	return -ENODEV;
150
151	if ((file->f_flags & O_ACCMODE) == O_RDONLY) {
152	dvbdev->readers++;
153	} else {
154	dvbdev->writers++;
155	}
156
157	dvbdev->users++;
158	return 0;
159	}
160	EXPORT_SYMBOL(dvb_generic_release);
161
162
163	int dvb_generic_ioctl(struct inode inode, struct file file,
164	unsigned int cmd, unsigned long arg)
165	{
166	struct dvb_device *dvbdev = file->private_data;
167
168	if (!dvbdev)
169	return -ENODEV;
170
171	if (!dvbdev->kernel_ioctl)
172	return -EINVAL;
173
174	return dvb_usercopy (inode, file, cmd, arg, dvbdev->kernel_ioctl);
175	}
176	EXPORT_SYMBOL(dvb_generic_ioctl);
177
178
179	static int dvbdev_get_free_id (struct dvb_adapter *adap, int type)
180	{
181	u32 id = 0;
182
183	while (id < DVB_MAX_IDS) {
184	struct list_head *entry;
185	list_for_each (entry, &adap->device_list) {
186	struct dvb_device *dev;
187	dev = list_entry (entry, struct dvb_device, list_head);
188	if (dev->type == type && dev->id == id)
189	goto skip;
190	}
191	return id;
192	skip:
193	id++;
194	}
195	return -ENFILE;
196	}
197
198
199	int dvb_register_device(struct dvb_adapter adap, struct dvb_device *pdvbdev,
200	const struct dvb_device template, void priv, int type)
201	{
202	struct dvb_device *dvbdev;
203	int id;
204
205	if (down_interruptible (&dvbdev_register_lock))
206	return -ERESTARTSYS;
207
208	if ((id = dvbdev_get_free_id (adap, type)) < 0) {
209	up (&dvbdev_register_lock);
210	*pdvbdev = NULL;
211	printk ("%s: could get find free device id...\n", __FUNCTION__);
212	return -ENFILE;
213	}
214
215	*pdvbdev = dvbdev = kmalloc(sizeof(struct dvb_device), GFP_KERNEL);
216
217	if (!dvbdev) {
218	up(&dvbdev_register_lock);
219	return -ENOMEM;
220	}
221
222	up (&dvbdev_register_lock);
223
224	memcpy(dvbdev, template, sizeof(struct dvb_device));
225	dvbdev->type = type;
226	dvbdev->id = id;
227	dvbdev->adapter = adap;
228	dvbdev->priv = priv;
229
230	dvbdev->fops->owner = adap->module;
231
232	list_add_tail (&dvbdev->list_head, &adap->device_list);
233
234	devfs_mk_cdev(MKDEV(DVB_MAJOR, nums2minor(adap->num, type, id)),
235	S_IFCHR \| S_IRUSR \| S_IWUSR,
236	"dvb/adapter%d/%s%d", adap->num, dnames[type], id);
237
56b22935	238	class_device_create(dvb_class, MKDEV(DVB_MAJOR, nums2minor(adap->num, type, id)),
56b22935	239	NULL, "dvb%d.%s%d", adap->num, dnames[type], id);
1da177e4 LT	240
	241	dprintk("DVB: register adapter%d/%s%d @ minor: %i (0x%02x)\n",
	242	adap->num, dnames[type], id, nums2minor(adap->num, type, id),
	243	nums2minor(adap->num, type, id));
	244
	245	return 0;
	246	}
	247	EXPORT_SYMBOL(dvb_register_device);
	248
	249
	250	void dvb_unregister_device(struct dvb_device *dvbdev)
	251	{
	252	if (!dvbdev)
	253	return;
	254
	255	devfs_remove("dvb/adapter%d/%s%d", dvbdev->adapter->num,
	256	dnames[dvbdev->type], dvbdev->id);
	257
56b22935	258	class_device_destroy(dvb_class, MKDEV(DVB_MAJOR, nums2minor(dvbdev->adapter->num,
1da177e4 LT	259	dvbdev->type, dvbdev->id)));
	260
	261	list_del (&dvbdev->list_head);
	262	kfree (dvbdev);
	263	}
	264	EXPORT_SYMBOL(dvb_unregister_device);
	265
	266
	267	static int dvbdev_get_free_adapter_num (void)
	268	{
	269	int num = 0;
	270
	271	while (num < DVB_MAX_ADAPTERS) {
	272	struct list_head *entry;
	273	list_for_each (entry, &dvb_adapter_list) {
	274	struct dvb_adapter *adap;
	275	adap = list_entry (entry, struct dvb_adapter, list_head);
	276	if (adap->num == num)
	277	goto skip;
	278	}
	279	return num;
	280	skip:
	281	num++;
	282	}
	283
	284	return -ENFILE;
	285	}
	286
	287
fdc53a6d	288	int dvb_register_adapter(struct dvb_adapter adap, const char name, struct module *module)
1da177e4	289	{
1da177e4 LT	290	int num;
	291
	292	if (down_interruptible (&dvbdev_register_lock))
	293	return -ERESTARTSYS;
	294
	295	if ((num = dvbdev_get_free_adapter_num ()) < 0) {
	296	up (&dvbdev_register_lock);
	297	return -ENFILE;
	298	}
	299
1da177e4 LT	300	memset (adap, 0, sizeof(struct dvb_adapter));
	301	INIT_LIST_HEAD (&adap->device_list);
	302
	303	printk ("DVB: registering new adapter (%s).\n", name);
	304
	305	devfs_mk_dir("dvb/adapter%d", num);
	306	adap->num = num;
	307	adap->name = name;
	308	adap->module = module;
	309
	310	list_add_tail (&adap->list_head, &dvb_adapter_list);
	311
	312	up (&dvbdev_register_lock);
	313
	314	return num;
	315	}
	316	EXPORT_SYMBOL(dvb_register_adapter);
	317
	318
	319	int dvb_unregister_adapter(struct dvb_adapter *adap)
	320	{
	321	devfs_remove("dvb/adapter%d", adap->num);
	322
	323	if (down_interruptible (&dvbdev_register_lock))
	324	return -ERESTARTSYS;
	325	list_del (&adap->list_head);
	326	up (&dvbdev_register_lock);
1da177e4 LT	327	return 0;
	328	}
	329	EXPORT_SYMBOL(dvb_unregister_adapter);
	330
	331	/* if the miracle happens and "generic_usercopy()" is included into
	332	the kernel, then this can vanish. please don't make the mistake and
	333	define this as video_usercopy(). this will introduce a dependecy
	334	to the v4l "videodev.o" module, which is unnecessary for some
	335	cards (ie. the budget dvb-cards don't need the v4l module...) */
	336	int dvb_usercopy(struct inode inode, struct file file,
	337	unsigned int cmd, unsigned long arg,
	338	int (func)(struct inode inode, struct file *file,
	339	unsigned int cmd, void *arg))
	340	{
	341	char sbuf[128];
	342	void *mbuf = NULL;
	343	void *parg = NULL;
	344	int err = -EINVAL;
	345
	346	/* Copy arguments into temp kernel buffer */
	347	switch (_IOC_DIR(cmd)) {
	348	case _IOC_NONE:
	349	/*
	350	* For this command, the pointer is actually an integer
	351	* argument.
	352	*/
	353	parg = (void *) arg;
	354	break;
	355	case _IOC_READ: /* some v4l ioctls are marked wrong ... */
	356	case _IOC_WRITE:
	357	case (_IOC_WRITE \| _IOC_READ):
	358	if (_IOC_SIZE(cmd) <= sizeof(sbuf)) {
	359	parg = sbuf;
	360	} else {
	361	/* too big to allocate from stack */
	362	mbuf = kmalloc(_IOC_SIZE(cmd),GFP_KERNEL);
	363	if (NULL == mbuf)
	364	return -ENOMEM;
	365	parg = mbuf;
	366	}
	367
	368	err = -EFAULT;
	369	if (copy_from_user(parg, (void __user *)arg, _IOC_SIZE(cmd)))
	370	goto out;
	371	break;
	372	}
	373
	374	/* call driver */
	375	if ((err = func(inode, file, cmd, parg)) == -ENOIOCTLCMD)
	376	err = -EINVAL;
	377
	378	if (err < 0)
	379	goto out;
	380
	381	/* Copy results into user buffer */
	382	switch (_IOC_DIR(cmd))
	383	{
	384	case _IOC_READ:
	385	case (_IOC_WRITE \| _IOC_READ):
	386	if (copy_to_user((void __user *)arg, parg, _IOC_SIZE(cmd)))
	387	err = -EFAULT;
	388	break;
	389	}
	390
391	out:
392	kfree(mbuf);
393	return err;
394	}
395
396	static int __init init_dvbdev(void)
397	{
398	int retval;
399	dev_t dev = MKDEV(DVB_MAJOR, 0);
400
401	if ((retval = register_chrdev_region(dev, MAX_DVB_MINORS, "DVB")) != 0) {
402	printk("dvb-core: unable to get major %d\n", DVB_MAJOR);
403	return retval;
404	}
405
406	cdev_init(&dvb_device_cdev, &dvb_device_fops);
407	if ((retval = cdev_add(&dvb_device_cdev, dev, MAX_DVB_MINORS)) != 0) {
408	printk("dvb-core: unable to get major %d\n", DVB_MAJOR);
409	goto error;
410	}
411
412	devfs_mk_dir("dvb");
413
56b22935	414	dvb_class = class_create(THIS_MODULE, "dvb");
1da177e4 LT	415	if (IS_ERR(dvb_class)) {
	416	retval = PTR_ERR(dvb_class);
	417	goto error;
	418	}
	419	return 0;
	420
	421	error:
	422	cdev_del(&dvb_device_cdev);
	423	unregister_chrdev_region(dev, MAX_DVB_MINORS);
	424	return retval;
	425	}
	426
	427
	428	static void __exit exit_dvbdev(void)
	429	{
	430	devfs_remove("dvb");
56b22935	431	class_destroy(dvb_class);
1da177e4 LT	432	cdev_del(&dvb_device_cdev);
	433	unregister_chrdev_region(MKDEV(DVB_MAJOR, 0), MAX_DVB_MINORS);
	434	}
	435
	436	module_init(init_dvbdev);
	437	module_exit(exit_dvbdev);
	438
	439	MODULE_DESCRIPTION("DVB Core Driver");
	440	MODULE_AUTHOR("Marcus Metzler, Ralph Metzler, Holger Waechtler");
	441	MODULE_LICENSE("GPL");