xref: /linux/drivers/media/dvb-core/dvbdev.c (revision d0b73b488c55df905ea8faaad079f8535629ed26) 
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/kernel.h>
29 #include <linux/init.h>
30 #include <linux/slab.h>
31 #include <linux/device.h>
32 #include <linux/fs.h>
33 #include <linux/cdev.h>
34 #include <linux/mutex.h>
35 #include "dvbdev.h"
36 
37 static DEFINE_MUTEX(dvbdev_mutex);
38 static int dvbdev_debug;
39 
40 module_param(dvbdev_debug, int, 0644);
41 MODULE_PARM_DESC(dvbdev_debug, "Turn on/off device debugging (default:off).");
42 
43 #define dprintk if (dvbdev_debug) printk
44 
45 static LIST_HEAD(dvb_adapter_list);
46 static DEFINE_MUTEX(dvbdev_register_lock);
47 
48 static const char * const dnames[] = {
49 	"video", "audio", "sec", "frontend", "demux", "dvr", "ca",
50 	"net", "osd"
51 };
52 
53 #ifdef CONFIG_DVB_DYNAMIC_MINORS
54 #define MAX_DVB_MINORS		256
55 #define DVB_MAX_IDS		MAX_DVB_MINORS
56 #else
57 #define DVB_MAX_IDS		4
58 #define nums2minor(num,type,id)	((num << 6) | (id << 4) | type)
59 #define MAX_DVB_MINORS		(DVB_MAX_ADAPTERS*64)
60 #endif
61 
62 static struct class *dvb_class;
63 
64 static struct dvb_device *dvb_minors[MAX_DVB_MINORS];
65 static DECLARE_RWSEM(minor_rwsem);
66 
67 static int dvb_device_open(struct inode *inode, struct file *file)
68 {
69 	struct dvb_device *dvbdev;
70 
71 	mutex_lock(&dvbdev_mutex);
72 	down_read(&minor_rwsem);
73 	dvbdev = dvb_minors[iminor(inode)];
74 
75 	if (dvbdev && dvbdev->fops) {
76 		int err = 0;
77 		const struct file_operations *old_fops;
78 
79 		file->private_data = dvbdev;
80 		old_fops = file->f_op;
81 		file->f_op = fops_get(dvbdev->fops);
82 		if (file->f_op == NULL) {
83 			file->f_op = old_fops;
84 			goto fail;
85 		}
86 		if(file->f_op->open)
87 			err = file->f_op->open(inode,file);
88 		if (err) {
89 			fops_put(file->f_op);
90 			file->f_op = fops_get(old_fops);
91 		}
92 		fops_put(old_fops);
93 		up_read(&minor_rwsem);
94 		mutex_unlock(&dvbdev_mutex);
95 		return err;
96 	}
97 fail:
98 	up_read(&minor_rwsem);
99 	mutex_unlock(&dvbdev_mutex);
100 	return -ENODEV;
101 }
102 
103 
104 static const struct file_operations dvb_device_fops =
105 {
106 	.owner =	THIS_MODULE,
107 	.open =		dvb_device_open,
108 	.llseek =	noop_llseek,
109 };
110 
111 static struct cdev dvb_device_cdev;
112 
113 int dvb_generic_open(struct inode *inode, struct file *file)
114 {
115 	struct dvb_device *dvbdev = file->private_data;
116 
117 	if (!dvbdev)
118 		return -ENODEV;
119 
120 	if (!dvbdev->users)
121 		return -EBUSY;
122 
123 	if ((file->f_flags & O_ACCMODE) == O_RDONLY) {
124 		if (!dvbdev->readers)
125 			return -EBUSY;
126 		dvbdev->readers--;
127 	} else {
128 		if (!dvbdev->writers)
129 			return -EBUSY;
130 		dvbdev->writers--;
131 	}
132 
133 	dvbdev->users--;
134 	return 0;
135 }
136 EXPORT_SYMBOL(dvb_generic_open);
137 
138 
139 int dvb_generic_release(struct inode *inode, struct file *file)
140 {
141 	struct dvb_device *dvbdev = file->private_data;
142 
143 	if (!dvbdev)
144 		return -ENODEV;
145 
146 	if ((file->f_flags & O_ACCMODE) == O_RDONLY) {
147 		dvbdev->readers++;
148 	} else {
149 		dvbdev->writers++;
150 	}
151 
152 	dvbdev->users++;
153 	return 0;
154 }
155 EXPORT_SYMBOL(dvb_generic_release);
156 
157 
158 long dvb_generic_ioctl(struct file *file,
159 		       unsigned int cmd, unsigned long arg)
160 {
161 	struct dvb_device *dvbdev = file->private_data;
162 
163 	if (!dvbdev)
164 		return -ENODEV;
165 
166 	if (!dvbdev->kernel_ioctl)
167 		return -EINVAL;
168 
169 	return dvb_usercopy(file, cmd, arg, dvbdev->kernel_ioctl);
170 }
171 EXPORT_SYMBOL(dvb_generic_ioctl);
172 
173 
174 static int dvbdev_get_free_id (struct dvb_adapter *adap, int type)
175 {
176 	u32 id = 0;
177 
178 	while (id < DVB_MAX_IDS) {
179 		struct dvb_device *dev;
180 		list_for_each_entry(dev, &adap->device_list, list_head)
181 			if (dev->type == type && dev->id == id)
182 				goto skip;
183 		return id;
184 skip:
185 		id++;
186 	}
187 	return -ENFILE;
188 }
189 
190 
191 int dvb_register_device(struct dvb_adapter *adap, struct dvb_device **pdvbdev,
192 			const struct dvb_device *template, void *priv, int type)
193 {
194 	struct dvb_device *dvbdev;
195 	struct file_operations *dvbdevfops;
196 	struct device *clsdev;
197 	int minor;
198 	int id;
199 
200 	mutex_lock(&dvbdev_register_lock);
201 
202 	if ((id = dvbdev_get_free_id (adap, type)) < 0){
203 		mutex_unlock(&dvbdev_register_lock);
204 		*pdvbdev = NULL;
205 		printk(KERN_ERR "%s: couldn't find free device id\n", __func__);
206 		return -ENFILE;
207 	}
208 
209 	*pdvbdev = dvbdev = kmalloc(sizeof(struct dvb_device), GFP_KERNEL);
210 
211 	if (!dvbdev){
212 		mutex_unlock(&dvbdev_register_lock);
213 		return -ENOMEM;
214 	}
215 
216 	dvbdevfops = kzalloc(sizeof(struct file_operations), GFP_KERNEL);
217 
218 	if (!dvbdevfops){
219 		kfree (dvbdev);
220 		mutex_unlock(&dvbdev_register_lock);
221 		return -ENOMEM;
222 	}
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 	dvbdev->fops = dvbdevfops;
230 	init_waitqueue_head (&dvbdev->wait_queue);
231 
232 	memcpy(dvbdevfops, template->fops, sizeof(struct file_operations));
233 	dvbdevfops->owner = adap->module;
234 
235 	list_add_tail (&dvbdev->list_head, &adap->device_list);
236 
237 	down_write(&minor_rwsem);
238 #ifdef CONFIG_DVB_DYNAMIC_MINORS
239 	for (minor = 0; minor < MAX_DVB_MINORS; minor++)
240 		if (dvb_minors[minor] == NULL)
241 			break;
242 
243 	if (minor == MAX_DVB_MINORS) {
244 		kfree(dvbdevfops);
245 		kfree(dvbdev);
246 		up_write(&minor_rwsem);
247 		mutex_unlock(&dvbdev_register_lock);
248 		return -EINVAL;
249 	}
250 #else
251 	minor = nums2minor(adap->num, type, id);
252 #endif
253 
254 	dvbdev->minor = minor;
255 	dvb_minors[minor] = dvbdev;
256 	up_write(&minor_rwsem);
257 
258 	mutex_unlock(&dvbdev_register_lock);
259 
260 	clsdev = device_create(dvb_class, adap->device,
261 			       MKDEV(DVB_MAJOR, minor),
262 			       dvbdev, "dvb%d.%s%d", adap->num, dnames[type], id);
263 	if (IS_ERR(clsdev)) {
264 		printk(KERN_ERR "%s: failed to create device dvb%d.%s%d (%ld)\n",
265 		       __func__, adap->num, dnames[type], id, PTR_ERR(clsdev));
266 		return PTR_ERR(clsdev);
267 	}
268 
269 	dprintk(KERN_DEBUG "DVB: register adapter%d/%s%d @ minor: %i (0x%02x)\n",
270 		adap->num, dnames[type], id, minor, minor);
271 
272 	return 0;
273 }
274 EXPORT_SYMBOL(dvb_register_device);
275 
276 
277 void dvb_unregister_device(struct dvb_device *dvbdev)
278 {
279 	if (!dvbdev)
280 		return;
281 
282 	down_write(&minor_rwsem);
283 	dvb_minors[dvbdev->minor] = NULL;
284 	up_write(&minor_rwsem);
285 
286 	device_destroy(dvb_class, MKDEV(DVB_MAJOR, dvbdev->minor));
287 
288 	list_del (&dvbdev->list_head);
289 	kfree (dvbdev->fops);
290 	kfree (dvbdev);
291 }
292 EXPORT_SYMBOL(dvb_unregister_device);
293 
294 static int dvbdev_check_free_adapter_num(int num)
295 {
296 	struct list_head *entry;
297 	list_for_each(entry, &dvb_adapter_list) {
298 		struct dvb_adapter *adap;
299 		adap = list_entry(entry, struct dvb_adapter, list_head);
300 		if (adap->num == num)
301 			return 0;
302 	}
303 	return 1;
304 }
305 
306 static int dvbdev_get_free_adapter_num (void)
307 {
308 	int num = 0;
309 
310 	while (num < DVB_MAX_ADAPTERS) {
311 		if (dvbdev_check_free_adapter_num(num))
312 			return num;
313 		num++;
314 	}
315 
316 	return -ENFILE;
317 }
318 
319 
320 int dvb_register_adapter(struct dvb_adapter *adap, const char *name,
321 			 struct module *module, struct device *device,
322 			 short *adapter_nums)
323 {
324 	int i, num;
325 
326 	mutex_lock(&dvbdev_register_lock);
327 
328 	for (i = 0; i < DVB_MAX_ADAPTERS; ++i) {
329 		num = adapter_nums[i];
330 		if (num >= 0  &&  num < DVB_MAX_ADAPTERS) {
331 		/* use the one the driver asked for */
332 			if (dvbdev_check_free_adapter_num(num))
333 				break;
334 		} else {
335 			num = dvbdev_get_free_adapter_num();
336 			break;
337 		}
338 		num = -1;
339 	}
340 
341 	if (num < 0) {
342 		mutex_unlock(&dvbdev_register_lock);
343 		return -ENFILE;
344 	}
345 
346 	memset (adap, 0, sizeof(struct dvb_adapter));
347 	INIT_LIST_HEAD (&adap->device_list);
348 
349 	printk(KERN_INFO "DVB: registering new adapter (%s)\n", name);
350 
351 	adap->num = num;
352 	adap->name = name;
353 	adap->module = module;
354 	adap->device = device;
355 	adap->mfe_shared = 0;
356 	adap->mfe_dvbdev = NULL;
357 	mutex_init (&adap->mfe_lock);
358 
359 	list_add_tail (&adap->list_head, &dvb_adapter_list);
360 
361 	mutex_unlock(&dvbdev_register_lock);
362 
363 	return num;
364 }
365 EXPORT_SYMBOL(dvb_register_adapter);
366 
367 
368 int dvb_unregister_adapter(struct dvb_adapter *adap)
369 {
370 	mutex_lock(&dvbdev_register_lock);
371 	list_del (&adap->list_head);
372 	mutex_unlock(&dvbdev_register_lock);
373 	return 0;
374 }
375 EXPORT_SYMBOL(dvb_unregister_adapter);
376 
377 /* if the miracle happens and "generic_usercopy()" is included into
378    the kernel, then this can vanish. please don't make the mistake and
379    define this as video_usercopy(). this will introduce a dependecy
380    to the v4l "videodev.o" module, which is unnecessary for some
381    cards (ie. the budget dvb-cards don't need the v4l module...) */
382 int dvb_usercopy(struct file *file,
383 		     unsigned int cmd, unsigned long arg,
384 		     int (*func)(struct file *file,
385 		     unsigned int cmd, void *arg))
386 {
387 	char    sbuf[128];
388 	void    *mbuf = NULL;
389 	void    *parg = NULL;
390 	int     err  = -EINVAL;
391 
392 	/*  Copy arguments into temp kernel buffer  */
393 	switch (_IOC_DIR(cmd)) {
394 	case _IOC_NONE:
395 		/*
396 		 * For this command, the pointer is actually an integer
397 		 * argument.
398 		 */
399 		parg = (void *) arg;
400 		break;
401 	case _IOC_READ: /* some v4l ioctls are marked wrong ... */
402 	case _IOC_WRITE:
403 	case (_IOC_WRITE | _IOC_READ):
404 		if (_IOC_SIZE(cmd) <= sizeof(sbuf)) {
405 			parg = sbuf;
406 		} else {
407 			/* too big to allocate from stack */
408 			mbuf = kmalloc(_IOC_SIZE(cmd),GFP_KERNEL);
409 			if (NULL == mbuf)
410 				return -ENOMEM;
411 			parg = mbuf;
412 		}
413 
414 		err = -EFAULT;
415 		if (copy_from_user(parg, (void __user *)arg, _IOC_SIZE(cmd)))
416 			goto out;
417 		break;
418 	}
419 
420 	/* call driver */
421 	mutex_lock(&dvbdev_mutex);
422 	if ((err = func(file, cmd, parg)) == -ENOIOCTLCMD)
423 		err = -ENOTTY;
424 	mutex_unlock(&dvbdev_mutex);
425 
426 	if (err < 0)
427 		goto out;
428 
429 	/*  Copy results into user buffer  */
430 	switch (_IOC_DIR(cmd))
431 	{
432 	case _IOC_READ:
433 	case (_IOC_WRITE | _IOC_READ):
434 		if (copy_to_user((void __user *)arg, parg, _IOC_SIZE(cmd)))
435 			err = -EFAULT;
436 		break;
437 	}
438 
439 out:
440 	kfree(mbuf);
441 	return err;
442 }
443 
444 static int dvb_uevent(struct device *dev, struct kobj_uevent_env *env)
445 {
446 	struct dvb_device *dvbdev = dev_get_drvdata(dev);
447 
448 	add_uevent_var(env, "DVB_ADAPTER_NUM=%d", dvbdev->adapter->num);
449 	add_uevent_var(env, "DVB_DEVICE_TYPE=%s", dnames[dvbdev->type]);
450 	add_uevent_var(env, "DVB_DEVICE_NUM=%d", dvbdev->id);
451 	return 0;
452 }
453 
454 static char *dvb_devnode(struct device *dev, umode_t *mode)
455 {
456 	struct dvb_device *dvbdev = dev_get_drvdata(dev);
457 
458 	return kasprintf(GFP_KERNEL, "dvb/adapter%d/%s%d",
459 		dvbdev->adapter->num, dnames[dvbdev->type], dvbdev->id);
460 }
461 
462 
463 static int __init init_dvbdev(void)
464 {
465 	int retval;
466 	dev_t dev = MKDEV(DVB_MAJOR, 0);
467 
468 	if ((retval = register_chrdev_region(dev, MAX_DVB_MINORS, "DVB")) != 0) {
469 		printk(KERN_ERR "dvb-core: unable to get major %d\n", DVB_MAJOR);
470 		return retval;
471 	}
472 
473 	cdev_init(&dvb_device_cdev, &dvb_device_fops);
474 	if ((retval = cdev_add(&dvb_device_cdev, dev, MAX_DVB_MINORS)) != 0) {
475 		printk(KERN_ERR "dvb-core: unable register character device\n");
476 		goto error;
477 	}
478 
479 	dvb_class = class_create(THIS_MODULE, "dvb");
480 	if (IS_ERR(dvb_class)) {
481 		retval = PTR_ERR(dvb_class);
482 		goto error;
483 	}
484 	dvb_class->dev_uevent = dvb_uevent;
485 	dvb_class->devnode = dvb_devnode;
486 	return 0;
487 
488 error:
489 	cdev_del(&dvb_device_cdev);
490 	unregister_chrdev_region(dev, MAX_DVB_MINORS);
491 	return retval;
492 }
493 
494 
495 static void __exit exit_dvbdev(void)
496 {
497 	class_destroy(dvb_class);
498 	cdev_del(&dvb_device_cdev);
499 	unregister_chrdev_region(MKDEV(DVB_MAJOR, 0), MAX_DVB_MINORS);
500 }
501 
502 subsys_initcall(init_dvbdev);
503 module_exit(exit_dvbdev);
504 
505 MODULE_DESCRIPTION("DVB Core Driver");
506 MODULE_AUTHOR("Marcus Metzler, Ralph Metzler, Holger Waechtler");
507 MODULE_LICENSE("GPL");
508