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