4 * Copyright (C) 2000 Ralph Metzler <ralph@convergence.de>
5 * & Marcus Metzler <marcus@convergence.de>
6 * for convergence integrated media GmbH
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.
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.
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.
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>
35 #include <linux/cdev.h>
39 static int dvbdev_debug;
41 module_param(dvbdev_debug, int, 0644);
42 MODULE_PARM_DESC(dvbdev_debug, "Turn on/off device debugging (default:off).");
44 #define dprintk if (dvbdev_debug) printk
46 static LIST_HEAD(dvb_adapter_list);
47 static DECLARE_MUTEX(dvbdev_register_lock);
49 static const char * const dnames[] = {
50 "video", "audio", "sec", "frontend", "demux", "dvr", "ca",
56 #define nums2minor(num,type,id) ((num << 6) | (id << 4) | type)
57 #define MAX_DVB_MINORS (DVB_MAX_IDS*64)
59 struct class_simple *dvb_class;
60 EXPORT_SYMBOL(dvb_class);
62 static struct dvb_device* dvbdev_find_device (int minor)
64 struct list_head *entry;
66 list_for_each (entry, &dvb_adapter_list) {
67 struct list_head *entry0;
68 struct dvb_adapter *adap;
69 adap = list_entry (entry, struct dvb_adapter, list_head);
70 list_for_each (entry0, &adap->device_list) {
71 struct dvb_device *dev;
72 dev = list_entry (entry0, struct dvb_device, list_head);
73 if (nums2minor(adap->num, dev->type, dev->id) == minor)
82 static int dvb_device_open(struct inode *inode, struct file *file)
84 struct dvb_device *dvbdev;
86 dvbdev = dvbdev_find_device (iminor(inode));
88 if (dvbdev && dvbdev->fops) {
90 struct file_operations *old_fops;
92 file->private_data = dvbdev;
93 old_fops = file->f_op;
94 file->f_op = fops_get(dvbdev->fops);
96 err = file->f_op->open(inode,file);
99 file->f_op = fops_get(old_fops);
108 static struct file_operations dvb_device_fops =
110 .owner = THIS_MODULE,
111 .open = dvb_device_open,
115 static struct cdev dvb_device_cdev = {
116 .kobj = {.name = "dvb", },
117 .owner = THIS_MODULE,
120 int dvb_generic_open(struct inode *inode, struct file *file)
122 struct dvb_device *dvbdev = file->private_data;
130 if ((file->f_flags & O_ACCMODE) == O_RDONLY) {
131 if (!dvbdev->readers)
135 if (!dvbdev->writers)
143 EXPORT_SYMBOL(dvb_generic_open);
146 int dvb_generic_release(struct inode *inode, struct file *file)
148 struct dvb_device *dvbdev = file->private_data;
153 if ((file->f_flags & O_ACCMODE) == O_RDONLY) {
162 EXPORT_SYMBOL(dvb_generic_release);
165 int dvb_generic_ioctl(struct inode *inode, struct file *file,
166 unsigned int cmd, unsigned long arg)
168 struct dvb_device *dvbdev = file->private_data;
173 if (!dvbdev->kernel_ioctl)
176 return dvb_usercopy (inode, file, cmd, arg, dvbdev->kernel_ioctl);
178 EXPORT_SYMBOL(dvb_generic_ioctl);
181 static int dvbdev_get_free_id (struct dvb_adapter *adap, int type)
185 while (id < DVB_MAX_IDS) {
186 struct list_head *entry;
187 list_for_each (entry, &adap->device_list) {
188 struct dvb_device *dev;
189 dev = list_entry (entry, struct dvb_device, list_head);
190 if (dev->type == type && dev->id == id)
201 int dvb_register_device(struct dvb_adapter *adap, struct dvb_device **pdvbdev,
202 const struct dvb_device *template, void *priv, int type)
204 struct dvb_device *dvbdev;
207 if (down_interruptible (&dvbdev_register_lock))
210 if ((id = dvbdev_get_free_id (adap, type)) < 0) {
211 up (&dvbdev_register_lock);
213 printk ("%s: could get find free device id...\n", __FUNCTION__);
217 *pdvbdev = dvbdev = kmalloc(sizeof(struct dvb_device), GFP_KERNEL);
220 up(&dvbdev_register_lock);
224 up (&dvbdev_register_lock);
226 memcpy(dvbdev, template, sizeof(struct dvb_device));
229 dvbdev->adapter = adap;
232 dvbdev->fops->owner = adap->module;
234 list_add_tail (&dvbdev->list_head, &adap->device_list);
236 devfs_mk_cdev(MKDEV(DVB_MAJOR, nums2minor(adap->num, type, id)),
237 S_IFCHR | S_IRUSR | S_IWUSR,
238 "dvb/adapter%d/%s%d", adap->num, dnames[type], id);
240 class_simple_device_add(dvb_class, MKDEV(DVB_MAJOR, nums2minor(adap->num, type, id)),
241 NULL, "dvb%d.%s%d", adap->num, dnames[type], id);
243 dprintk("DVB: register adapter%d/%s%d @ minor: %i (0x%02x)\n",
244 adap->num, dnames[type], id, nums2minor(adap->num, type, id),
245 nums2minor(adap->num, type, id));
249 EXPORT_SYMBOL(dvb_register_device);
252 void dvb_unregister_device(struct dvb_device *dvbdev)
257 devfs_remove("dvb/adapter%d/%s%d", dvbdev->adapter->num,
258 dnames[dvbdev->type], dvbdev->id);
260 class_simple_device_remove(MKDEV(DVB_MAJOR, nums2minor(dvbdev->adapter->num,
261 dvbdev->type, dvbdev->id)));
263 list_del(&dvbdev->list_head);
266 EXPORT_SYMBOL(dvb_unregister_device);
269 static int dvbdev_get_free_adapter_num (void)
274 struct list_head *entry;
275 list_for_each (entry, &dvb_adapter_list) {
276 struct dvb_adapter *adap;
277 adap = list_entry (entry, struct dvb_adapter, list_head);
278 if (adap->num == num)
290 int dvb_register_adapter(struct dvb_adapter **padap, const char *name, struct module *module)
292 struct dvb_adapter *adap;
295 if (down_interruptible (&dvbdev_register_lock))
298 if ((num = dvbdev_get_free_adapter_num ()) < 0) {
299 up (&dvbdev_register_lock);
303 if (!(*padap = adap = kmalloc(sizeof(struct dvb_adapter), GFP_KERNEL))) {
304 up(&dvbdev_register_lock);
308 memset (adap, 0, sizeof(struct dvb_adapter));
309 INIT_LIST_HEAD (&adap->device_list);
311 printk ("DVB: registering new adapter (%s).\n", name);
313 devfs_mk_dir("dvb/adapter%d", num);
317 adap->module = module;
319 list_add_tail (&adap->list_head, &dvb_adapter_list);
321 up (&dvbdev_register_lock);
325 EXPORT_SYMBOL(dvb_register_adapter);
328 int dvb_unregister_adapter(struct dvb_adapter *adap)
330 devfs_remove("dvb/adapter%d", adap->num);
332 if (down_interruptible (&dvbdev_register_lock))
334 list_del (&adap->list_head);
335 up (&dvbdev_register_lock);
339 EXPORT_SYMBOL(dvb_unregister_adapter);
341 /* if the miracle happens and "generic_usercopy()" is included into
342 the kernel, then this can vanish. please don't make the mistake and
343 define this as video_usercopy(). this will introduce a dependecy
344 to the v4l "videodev.o" module, which is unnecessary for some
345 cards (ie. the budget dvb-cards don't need the v4l module...) */
346 int dvb_usercopy(struct inode *inode, struct file *file,
347 unsigned int cmd, unsigned long arg,
348 int (*func)(struct inode *inode, struct file *file,
349 unsigned int cmd, void *arg))
356 /* Copy arguments into temp kernel buffer */
357 switch (_IOC_DIR(cmd)) {
360 * For this command, the pointer is actually an integer
365 case _IOC_READ: /* some v4l ioctls are marked wrong ... */
367 case (_IOC_WRITE | _IOC_READ):
368 if (_IOC_SIZE(cmd) <= sizeof(sbuf)) {
371 /* too big to allocate from stack */
372 mbuf = kmalloc(_IOC_SIZE(cmd),GFP_KERNEL);
379 if (copy_from_user(parg, (void __user *)arg, _IOC_SIZE(cmd)))
385 if ((err = func(inode, file, cmd, parg)) == -ENOIOCTLCMD)
391 /* Copy results into user buffer */
392 switch (_IOC_DIR(cmd))
395 case (_IOC_WRITE | _IOC_READ):
396 if (copy_to_user((void __user *)arg, parg, _IOC_SIZE(cmd)))
408 static int __init init_dvbdev(void)
411 dev_t dev = MKDEV(DVB_MAJOR, 0);
413 if ((retval = register_chrdev_region(dev, MAX_DVB_MINORS, "DVB")) != 0) {
414 printk("dvb-core: unable to get major %d\n", DVB_MAJOR);
418 cdev_init(&dvb_device_cdev, &dvb_device_fops);
419 if ((retval = cdev_add(&dvb_device_cdev, dev, MAX_DVB_MINORS)) != 0) {
420 printk("dvb-core: unable to get major %d\n", DVB_MAJOR);
426 dvb_class = class_simple_create(THIS_MODULE, "dvb");
427 if (IS_ERR(dvb_class)) {
428 retval = PTR_ERR(dvb_class);
434 cdev_del(&dvb_device_cdev);
435 unregister_chrdev_region(dev, MAX_DVB_MINORS);
440 static void __exit exit_dvbdev(void)
443 class_simple_destroy(dvb_class);
444 cdev_del(&dvb_device_cdev);
445 unregister_chrdev_region(MKDEV(DVB_MAJOR, 0), MAX_DVB_MINORS);
448 module_init(init_dvbdev);
449 module_exit(exit_dvbdev);
451 MODULE_DESCRIPTION("DVB Core Driver");
452 MODULE_AUTHOR("Marcus Metzler, Ralph Metzler, Holger Waechtler");
453 MODULE_LICENSE("GPL");