Merge branch 'linus' into sched/core
[linux-3.10.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_registered(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_registered(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_registered(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_registered(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 || !video_is_registered(vdev))
264                 return -ENODEV;
265         return vdev->fops->mmap(filp, vm);
266 }
267
268 /* Override for the open function */
269 static int v4l2_open(struct inode *inode, struct file *filp)
270 {
271         struct video_device *vdev;
272         int ret = 0;
273
274         /* Check if the video device is available */
275         mutex_lock(&videodev_lock);
276         vdev = video_devdata(filp);
277         /* return ENODEV if the video device has been removed
278            already or if it is not registered anymore. */
279         if (vdev == NULL || !video_is_registered(vdev)) {
280                 mutex_unlock(&videodev_lock);
281                 return -ENODEV;
282         }
283         /* and increase the device refcount */
284         video_get(vdev);
285         mutex_unlock(&videodev_lock);
286         if (vdev->fops->open)
287                 ret = vdev->fops->open(filp);
288
289         /* decrease the refcount in case of an error */
290         if (ret)
291                 video_put(vdev);
292         return ret;
293 }
294
295 /* Override for the release function */
296 static int v4l2_release(struct inode *inode, struct file *filp)
297 {
298         struct video_device *vdev = video_devdata(filp);
299         int ret = 0;
300
301         if (vdev->fops->release)
302                 vdev->fops->release(filp);
303
304         /* decrease the refcount unconditionally since the release()
305            return value is ignored. */
306         video_put(vdev);
307         return ret;
308 }
309
310 static const struct file_operations v4l2_unlocked_fops = {
311         .owner = THIS_MODULE,
312         .read = v4l2_read,
313         .write = v4l2_write,
314         .open = v4l2_open,
315         .get_unmapped_area = v4l2_get_unmapped_area,
316         .mmap = v4l2_mmap,
317         .unlocked_ioctl = v4l2_unlocked_ioctl,
318 #ifdef CONFIG_COMPAT
319         .compat_ioctl = v4l2_compat_ioctl32,
320 #endif
321         .release = v4l2_release,
322         .poll = v4l2_poll,
323         .llseek = no_llseek,
324 };
325
326 static const struct file_operations v4l2_fops = {
327         .owner = THIS_MODULE,
328         .read = v4l2_read,
329         .write = v4l2_write,
330         .open = v4l2_open,
331         .get_unmapped_area = v4l2_get_unmapped_area,
332         .mmap = v4l2_mmap,
333         .ioctl = v4l2_ioctl,
334 #ifdef CONFIG_COMPAT
335         .compat_ioctl = v4l2_compat_ioctl32,
336 #endif
337         .release = v4l2_release,
338         .poll = v4l2_poll,
339         .llseek = no_llseek,
340 };
341
342 /**
343  * get_index - assign stream index number based on parent device
344  * @vdev: video_device to assign index number to, vdev->parent should be assigned
345  *
346  * Note that when this is called the new device has not yet been registered
347  * in the video_device array, but it was able to obtain a minor number.
348  *
349  * This means that we can always obtain a free stream index number since
350  * the worst case scenario is that there are VIDEO_NUM_DEVICES - 1 slots in
351  * use of the video_device array.
352  *
353  * Returns a free index number.
354  */
355 static int get_index(struct video_device *vdev)
356 {
357         /* This can be static since this function is called with the global
358            videodev_lock held. */
359         static DECLARE_BITMAP(used, VIDEO_NUM_DEVICES);
360         int i;
361
362         /* Some drivers do not set the parent. In that case always return 0. */
363         if (vdev->parent == NULL)
364                 return 0;
365
366         bitmap_zero(used, VIDEO_NUM_DEVICES);
367
368         for (i = 0; i < VIDEO_NUM_DEVICES; i++) {
369                 if (video_device[i] != NULL &&
370                     video_device[i]->parent == vdev->parent) {
371                         set_bit(video_device[i]->index, used);
372                 }
373         }
374
375         return find_first_zero_bit(used, VIDEO_NUM_DEVICES);
376 }
377
378 /**
379  *      video_register_device - register video4linux devices
380  *      @vdev: video device structure we want to register
381  *      @type: type of device to register
382  *      @nr:   which device node number (0 == /dev/video0, 1 == /dev/video1, ...
383  *             -1 == first free)
384  *      @warn_if_nr_in_use: warn if the desired device node number
385  *             was already in use and another number was chosen instead.
386  *
387  *      The registration code assigns minor numbers and device node numbers
388  *      based on the requested type and registers the new device node with
389  *      the kernel.
390  *      An error is returned if no free minor or device node number could be
391  *      found, or if the registration of the device node failed.
392  *
393  *      Zero is returned on success.
394  *
395  *      Valid types are
396  *
397  *      %VFL_TYPE_GRABBER - A frame grabber
398  *
399  *      %VFL_TYPE_VTX - A teletext device
400  *
401  *      %VFL_TYPE_VBI - Vertical blank data (undecoded)
402  *
403  *      %VFL_TYPE_RADIO - A radio card
404  */
405 static int __video_register_device(struct video_device *vdev, int type, int nr,
406                 int warn_if_nr_in_use)
407 {
408         int i = 0;
409         int ret;
410         int minor_offset = 0;
411         int minor_cnt = VIDEO_NUM_DEVICES;
412         const char *name_base;
413         void *priv = video_get_drvdata(vdev);
414
415         /* A minor value of -1 marks this video device as never
416            having been registered */
417         vdev->minor = -1;
418
419         /* the release callback MUST be present */
420         WARN_ON(!vdev->release);
421         if (!vdev->release)
422                 return -EINVAL;
423
424         /* Part 1: check device type */
425         switch (type) {
426         case VFL_TYPE_GRABBER:
427                 name_base = "video";
428                 break;
429         case VFL_TYPE_VTX:
430                 name_base = "vtx";
431                 break;
432         case VFL_TYPE_VBI:
433                 name_base = "vbi";
434                 break;
435         case VFL_TYPE_RADIO:
436                 name_base = "radio";
437                 break;
438         default:
439                 printk(KERN_ERR "%s called with unknown type: %d\n",
440                        __func__, type);
441                 return -EINVAL;
442         }
443
444         vdev->vfl_type = type;
445         vdev->cdev = NULL;
446         if (vdev->v4l2_dev && vdev->v4l2_dev->dev)
447                 vdev->parent = vdev->v4l2_dev->dev;
448
449         /* Part 2: find a free minor, device node number and device index. */
450 #ifdef CONFIG_VIDEO_FIXED_MINOR_RANGES
451         /* Keep the ranges for the first four types for historical
452          * reasons.
453          * Newer devices (not yet in place) should use the range
454          * of 128-191 and just pick the first free minor there
455          * (new style). */
456         switch (type) {
457         case VFL_TYPE_GRABBER:
458                 minor_offset = 0;
459                 minor_cnt = 64;
460                 break;
461         case VFL_TYPE_RADIO:
462                 minor_offset = 64;
463                 minor_cnt = 64;
464                 break;
465         case VFL_TYPE_VTX:
466                 minor_offset = 192;
467                 minor_cnt = 32;
468                 break;
469         case VFL_TYPE_VBI:
470                 minor_offset = 224;
471                 minor_cnt = 32;
472                 break;
473         default:
474                 minor_offset = 128;
475                 minor_cnt = 64;
476                 break;
477         }
478 #endif
479
480         /* Pick a device node number */
481         mutex_lock(&videodev_lock);
482         nr = devnode_find(vdev, nr == -1 ? 0 : nr, minor_cnt);
483         if (nr == minor_cnt)
484                 nr = devnode_find(vdev, 0, minor_cnt);
485         if (nr == minor_cnt) {
486                 printk(KERN_ERR "could not get a free device node number\n");
487                 mutex_unlock(&videodev_lock);
488                 return -ENFILE;
489         }
490 #ifdef CONFIG_VIDEO_FIXED_MINOR_RANGES
491         /* 1-on-1 mapping of device node number to minor number */
492         i = nr;
493 #else
494         /* The device node number and minor numbers are independent, so
495            we just find the first free minor number. */
496         for (i = 0; i < VIDEO_NUM_DEVICES; i++)
497                 if (video_device[i] == NULL)
498                         break;
499         if (i == VIDEO_NUM_DEVICES) {
500                 mutex_unlock(&videodev_lock);
501                 printk(KERN_ERR "could not get a free minor\n");
502                 return -ENFILE;
503         }
504 #endif
505         vdev->minor = i + minor_offset;
506         vdev->num = nr;
507         devnode_set(vdev);
508
509         /* Should not happen since we thought this minor was free */
510         WARN_ON(video_device[vdev->minor] != NULL);
511         vdev->index = get_index(vdev);
512         mutex_unlock(&videodev_lock);
513
514         /* Part 3: Initialize the character device */
515         vdev->cdev = cdev_alloc();
516         if (vdev->cdev == NULL) {
517                 ret = -ENOMEM;
518                 goto cleanup;
519         }
520         if (vdev->fops->unlocked_ioctl)
521                 vdev->cdev->ops = &v4l2_unlocked_fops;
522         else
523                 vdev->cdev->ops = &v4l2_fops;
524         vdev->cdev->owner = vdev->fops->owner;
525         ret = cdev_add(vdev->cdev, MKDEV(VIDEO_MAJOR, vdev->minor), 1);
526         if (ret < 0) {
527                 printk(KERN_ERR "%s: cdev_add failed\n", __func__);
528                 kfree(vdev->cdev);
529                 vdev->cdev = NULL;
530                 goto cleanup;
531         }
532
533         /* Part 4: register the device with sysfs */
534         memset(&vdev->dev, 0, sizeof(vdev->dev));
535         /* The memset above cleared the device's drvdata, so
536            put back the copy we made earlier. */
537         video_set_drvdata(vdev, priv);
538         vdev->dev.class = &video_class;
539         vdev->dev.devt = MKDEV(VIDEO_MAJOR, vdev->minor);
540         if (vdev->parent)
541                 vdev->dev.parent = vdev->parent;
542         dev_set_name(&vdev->dev, "%s%d", name_base, vdev->num);
543         ret = device_register(&vdev->dev);
544         if (ret < 0) {
545                 printk(KERN_ERR "%s: device_register failed\n", __func__);
546                 goto cleanup;
547         }
548         /* Register the release callback that will be called when the last
549            reference to the device goes away. */
550         vdev->dev.release = v4l2_device_release;
551
552         if (nr != -1 && nr != vdev->num && warn_if_nr_in_use)
553                 printk(KERN_WARNING "%s: requested %s%d, got %s\n", __func__,
554                         name_base, nr, video_device_node_name(vdev));
555
556         /* Part 5: Activate this minor. The char device can now be used. */
557         set_bit(V4L2_FL_REGISTERED, &vdev->flags);
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 || !video_is_registered(vdev))
597                 return;
598
599         mutex_lock(&videodev_lock);
600         clear_bit(V4L2_FL_REGISTERED, &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  */