4715f08157bcc9c2368e4d32761ed75fe422ec86
[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  *
386  *      The registration code assigns minor numbers and device node numbers
387  *      based on the requested type and registers the new device node with
388  *      the kernel.
389  *      An error is returned if no free minor or device node number could be
390  *      found, or if the registration of the device node failed.
391  *
392  *      Zero is returned on success.
393  *
394  *      Valid types are
395  *
396  *      %VFL_TYPE_GRABBER - A frame grabber
397  *
398  *      %VFL_TYPE_VTX - A teletext device
399  *
400  *      %VFL_TYPE_VBI - Vertical blank data (undecoded)
401  *
402  *      %VFL_TYPE_RADIO - A radio card
403  */
404 int video_register_device(struct video_device *vdev, int type, int nr)
405 {
406         int i = 0;
407         int ret;
408         int minor_offset = 0;
409         int minor_cnt = VIDEO_NUM_DEVICES;
410         const char *name_base;
411         void *priv = video_get_drvdata(vdev);
412
413         /* A minor value of -1 marks this video device as never
414            having been registered */
415         vdev->minor = -1;
416
417         /* the release callback MUST be present */
418         WARN_ON(!vdev->release);
419         if (!vdev->release)
420                 return -EINVAL;
421
422         /* Part 1: check device type */
423         switch (type) {
424         case VFL_TYPE_GRABBER:
425                 name_base = "video";
426                 break;
427         case VFL_TYPE_VTX:
428                 name_base = "vtx";
429                 break;
430         case VFL_TYPE_VBI:
431                 name_base = "vbi";
432                 break;
433         case VFL_TYPE_RADIO:
434                 name_base = "radio";
435                 break;
436         default:
437                 printk(KERN_ERR "%s called with unknown type: %d\n",
438                        __func__, type);
439                 return -EINVAL;
440         }
441
442         vdev->vfl_type = type;
443         vdev->cdev = NULL;
444         if (vdev->v4l2_dev && vdev->v4l2_dev->dev)
445                 vdev->parent = vdev->v4l2_dev->dev;
446
447         /* Part 2: find a free minor, device node number and device index. */
448 #ifdef CONFIG_VIDEO_FIXED_MINOR_RANGES
449         /* Keep the ranges for the first four types for historical
450          * reasons.
451          * Newer devices (not yet in place) should use the range
452          * of 128-191 and just pick the first free minor there
453          * (new style). */
454         switch (type) {
455         case VFL_TYPE_GRABBER:
456                 minor_offset = 0;
457                 minor_cnt = 64;
458                 break;
459         case VFL_TYPE_RADIO:
460                 minor_offset = 64;
461                 minor_cnt = 64;
462                 break;
463         case VFL_TYPE_VTX:
464                 minor_offset = 192;
465                 minor_cnt = 32;
466                 break;
467         case VFL_TYPE_VBI:
468                 minor_offset = 224;
469                 minor_cnt = 32;
470                 break;
471         default:
472                 minor_offset = 128;
473                 minor_cnt = 64;
474                 break;
475         }
476 #endif
477
478         /* Pick a device node number */
479         mutex_lock(&videodev_lock);
480         nr = devnode_find(vdev, nr == -1 ? 0 : nr, minor_cnt);
481         if (nr == minor_cnt)
482                 nr = devnode_find(vdev, 0, minor_cnt);
483         if (nr == minor_cnt) {
484                 printk(KERN_ERR "could not get a free device node number\n");
485                 mutex_unlock(&videodev_lock);
486                 return -ENFILE;
487         }
488 #ifdef CONFIG_VIDEO_FIXED_MINOR_RANGES
489         /* 1-on-1 mapping of device node number to minor number */
490         i = nr;
491 #else
492         /* The device node number and minor numbers are independent, so
493            we just find the first free minor number. */
494         for (i = 0; i < VIDEO_NUM_DEVICES; i++)
495                 if (video_device[i] == NULL)
496                         break;
497         if (i == VIDEO_NUM_DEVICES) {
498                 mutex_unlock(&videodev_lock);
499                 printk(KERN_ERR "could not get a free minor\n");
500                 return -ENFILE;
501         }
502 #endif
503         vdev->minor = i + minor_offset;
504         vdev->num = nr;
505         devnode_set(vdev);
506
507         /* Should not happen since we thought this minor was free */
508         WARN_ON(video_device[vdev->minor] != NULL);
509         vdev->index = get_index(vdev);
510         mutex_unlock(&videodev_lock);
511
512         /* Part 3: Initialize the character device */
513         vdev->cdev = cdev_alloc();
514         if (vdev->cdev == NULL) {
515                 ret = -ENOMEM;
516                 goto cleanup;
517         }
518         if (vdev->fops->unlocked_ioctl)
519                 vdev->cdev->ops = &v4l2_unlocked_fops;
520         else
521                 vdev->cdev->ops = &v4l2_fops;
522         vdev->cdev->owner = vdev->fops->owner;
523         ret = cdev_add(vdev->cdev, MKDEV(VIDEO_MAJOR, vdev->minor), 1);
524         if (ret < 0) {
525                 printk(KERN_ERR "%s: cdev_add failed\n", __func__);
526                 kfree(vdev->cdev);
527                 vdev->cdev = NULL;
528                 goto cleanup;
529         }
530
531         /* Part 4: register the device with sysfs */
532         memset(&vdev->dev, 0, sizeof(vdev->dev));
533         /* The memset above cleared the device's drvdata, so
534            put back the copy we made earlier. */
535         video_set_drvdata(vdev, priv);
536         vdev->dev.class = &video_class;
537         vdev->dev.devt = MKDEV(VIDEO_MAJOR, vdev->minor);
538         if (vdev->parent)
539                 vdev->dev.parent = vdev->parent;
540         dev_set_name(&vdev->dev, "%s%d", name_base, vdev->num);
541         ret = device_register(&vdev->dev);
542         if (ret < 0) {
543                 printk(KERN_ERR "%s: device_register failed\n", __func__);
544                 goto cleanup;
545         }
546         /* Register the release callback that will be called when the last
547            reference to the device goes away. */
548         vdev->dev.release = v4l2_device_release;
549
550         /* Part 5: Activate this minor. The char device can now be used. */
551         mutex_lock(&videodev_lock);
552         video_device[vdev->minor] = vdev;
553         mutex_unlock(&videodev_lock);
554         return 0;
555
556 cleanup:
557         mutex_lock(&videodev_lock);
558         if (vdev->cdev)
559                 cdev_del(vdev->cdev);
560         devnode_clear(vdev);
561         mutex_unlock(&videodev_lock);
562         /* Mark this video device as never having been registered. */
563         vdev->minor = -1;
564         return ret;
565 }
566 EXPORT_SYMBOL(video_register_device);
567
568 /**
569  *      video_unregister_device - unregister a video4linux device
570  *      @vdev: the device to unregister
571  *
572  *      This unregisters the passed device. Future open calls will
573  *      be met with errors.
574  */
575 void video_unregister_device(struct video_device *vdev)
576 {
577         /* Check if vdev was ever registered at all */
578         if (!vdev || vdev->minor < 0)
579                 return;
580
581         mutex_lock(&videodev_lock);
582         set_bit(V4L2_FL_UNREGISTERED, &vdev->flags);
583         mutex_unlock(&videodev_lock);
584         device_unregister(&vdev->dev);
585 }
586 EXPORT_SYMBOL(video_unregister_device);
587
588 /*
589  *      Initialise video for linux
590  */
591 static int __init videodev_init(void)
592 {
593         dev_t dev = MKDEV(VIDEO_MAJOR, 0);
594         int ret;
595
596         printk(KERN_INFO "Linux video capture interface: v2.00\n");
597         ret = register_chrdev_region(dev, VIDEO_NUM_DEVICES, VIDEO_NAME);
598         if (ret < 0) {
599                 printk(KERN_WARNING "videodev: unable to get major %d\n",
600                                 VIDEO_MAJOR);
601                 return ret;
602         }
603
604         ret = class_register(&video_class);
605         if (ret < 0) {
606                 unregister_chrdev_region(dev, VIDEO_NUM_DEVICES);
607                 printk(KERN_WARNING "video_dev: class_register failed\n");
608                 return -EIO;
609         }
610
611         return 0;
612 }
613
614 static void __exit videodev_exit(void)
615 {
616         dev_t dev = MKDEV(VIDEO_MAJOR, 0);
617
618         class_unregister(&video_class);
619         unregister_chrdev_region(dev, VIDEO_NUM_DEVICES);
620 }
621
622 module_init(videodev_init)
623 module_exit(videodev_exit)
624
625 MODULE_AUTHOR("Alan Cox, Mauro Carvalho Chehab <mchehab@infradead.org>");
626 MODULE_DESCRIPTION("Device registrar for Video4Linux drivers v2");
627 MODULE_LICENSE("GPL");
628 MODULE_ALIAS_CHARDEV_MAJOR(VIDEO_MAJOR);
629
630
631 /*
632  * Local variables:
633  * c-basic-offset: 8
634  * End:
635  */