2 * Video capture interface for Linux
4 * A generic video device interface for the LINUX operating system
5 * using a set of device structures/vectors for low level operations.
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.
12 * Author: Alan Cox, <alan@redhat.com>
14 * Fixes: 20000516 Claudio Matsuoka <claudio@conectiva.com>
15 * - Added procfs support
18 #include <linux/module.h>
19 #include <linux/types.h>
20 #include <linux/kernel.h>
21 #include <linux/sched.h>
22 #include <linux/smp_lock.h>
24 #include <linux/string.h>
25 #include <linux/errno.h>
26 #include <linux/init.h>
27 #include <linux/kmod.h>
28 #include <linux/slab.h>
29 #include <linux/devfs_fs_kernel.h>
30 #include <asm/uaccess.h>
31 #include <asm/system.h>
32 #include <asm/semaphore.h>
34 #include <linux/videodev.h>
36 #define VIDEO_NUM_DEVICES 256
37 #define VIDEO_NAME "video4linux"
43 static ssize_t
show_name(struct class_device
*cd
, char *buf
)
45 struct video_device
*vfd
= container_of(cd
, struct video_device
, class_dev
);
46 return sprintf(buf
,"%.*s\n",(int)sizeof(vfd
->name
),vfd
->name
);
49 static CLASS_DEVICE_ATTR(name
, S_IRUGO
, show_name
, NULL
);
51 struct video_device
*video_device_alloc(void)
53 struct video_device
*vfd
;
55 vfd
= kzalloc(sizeof(*vfd
),GFP_KERNEL
);
59 void video_device_release(struct video_device
*vfd
)
64 static void video_release(struct class_device
*cd
)
66 struct video_device
*vfd
= container_of(cd
, struct video_device
, class_dev
);
69 /* needed until all drivers are fixed */
76 static struct class video_class
= {
78 .release
= video_release
,
85 static struct video_device
*video_device
[VIDEO_NUM_DEVICES
];
86 static DECLARE_MUTEX(videodev_lock
);
88 struct video_device
* video_devdata(struct file
*file
)
90 return video_device
[iminor(file
->f_dentry
->d_inode
)];
94 * Open a video device.
96 static int video_open(struct inode
*inode
, struct file
*file
)
98 unsigned int minor
= iminor(inode
);
100 struct video_device
*vfl
;
101 struct file_operations
*old_fops
;
103 if(minor
>=VIDEO_NUM_DEVICES
)
105 down(&videodev_lock
);
106 vfl
=video_device
[minor
];
109 request_module("char-major-%d-%d", VIDEO_MAJOR
, minor
);
110 down(&videodev_lock
);
111 vfl
=video_device
[minor
];
117 old_fops
= file
->f_op
;
118 file
->f_op
= fops_get(vfl
->fops
);
120 err
= file
->f_op
->open(inode
,file
);
122 fops_put(file
->f_op
);
123 file
->f_op
= fops_get(old_fops
);
131 * helper function -- handles userspace copying for ioctl arguments
135 video_fix_command(unsigned int cmd
)
138 case VIDIOC_OVERLAY_OLD
:
139 cmd
= VIDIOC_OVERLAY
;
141 case VIDIOC_S_PARM_OLD
:
144 case VIDIOC_S_CTRL_OLD
:
147 case VIDIOC_G_AUDIO_OLD
:
148 cmd
= VIDIOC_G_AUDIO
;
150 case VIDIOC_G_AUDOUT_OLD
:
151 cmd
= VIDIOC_G_AUDOUT
;
153 case VIDIOC_CROPCAP_OLD
:
154 cmd
= VIDIOC_CROPCAP
;
161 video_usercopy(struct inode
*inode
, struct file
*file
,
162 unsigned int cmd
, unsigned long arg
,
163 int (*func
)(struct inode
*inode
, struct file
*file
,
164 unsigned int cmd
, void *arg
))
171 cmd
= video_fix_command(cmd
);
173 /* Copy arguments into temp kernel buffer */
174 switch (_IOC_DIR(cmd
)) {
180 case (_IOC_WRITE
| _IOC_READ
):
181 if (_IOC_SIZE(cmd
) <= sizeof(sbuf
)) {
184 /* too big to allocate from stack */
185 mbuf
= kmalloc(_IOC_SIZE(cmd
),GFP_KERNEL
);
192 if (_IOC_DIR(cmd
) & _IOC_WRITE
)
193 if (copy_from_user(parg
, (void __user
*)arg
, _IOC_SIZE(cmd
)))
199 err
= func(inode
, file
, cmd
, parg
);
200 if (err
== -ENOIOCTLCMD
)
205 /* Copy results into user buffer */
206 switch (_IOC_DIR(cmd
))
209 case (_IOC_WRITE
| _IOC_READ
):
210 if (copy_to_user((void __user
*)arg
, parg
, _IOC_SIZE(cmd
)))
221 * open/release helper functions -- handle exclusive opens
223 int video_exclusive_open(struct inode
*inode
, struct file
*file
)
225 struct video_device
*vfl
= video_devdata(file
);
238 int video_exclusive_release(struct inode
*inode
, struct file
*file
)
240 struct video_device
*vfl
= video_devdata(file
);
246 static struct file_operations video_fops
;
249 * video_register_device - register video4linux devices
250 * @vfd: video device structure we want to register
251 * @type: type of device to register
252 * @nr: which device number (0 == /dev/video0, 1 == /dev/video1, ...
255 * The registration code assigns minor numbers based on the type
256 * requested. -ENFILE is returned in all the device slots for this
257 * category are full. If not then the minor field is set and the
258 * driver initialize function is called (if non %NULL).
260 * Zero is returned on success.
264 * %VFL_TYPE_GRABBER - A frame grabber
266 * %VFL_TYPE_VTX - A teletext device
268 * %VFL_TYPE_VBI - Vertical blank data (undecoded)
270 * %VFL_TYPE_RADIO - A radio card
273 int video_register_device(struct video_device
*vfd
, int type
, int nr
)
282 case VFL_TYPE_GRABBER
:
306 /* pick a minor number */
307 down(&videodev_lock
);
308 if (nr
>= 0 && nr
< end
-base
) {
309 /* use the one the driver asked for */
311 if (NULL
!= video_device
[i
]) {
317 for(i
=base
;i
<end
;i
++)
318 if (NULL
== video_device
[i
])
329 sprintf(vfd
->devfs_name
, "v4l/%s%d", name_base
, i
- base
);
330 devfs_mk_cdev(MKDEV(VIDEO_MAJOR
, vfd
->minor
),
331 S_IFCHR
| S_IRUSR
| S_IWUSR
, vfd
->devfs_name
);
332 init_MUTEX(&vfd
->lock
);
335 memset(&vfd
->class_dev
, 0x00, sizeof(vfd
->class_dev
));
337 vfd
->class_dev
.dev
= vfd
->dev
;
338 vfd
->class_dev
.class = &video_class
;
339 vfd
->class_dev
.devt
= MKDEV(VIDEO_MAJOR
, vfd
->minor
);
340 strlcpy(vfd
->class_dev
.class_id
, vfd
->devfs_name
+ 4, BUS_ID_SIZE
);
341 class_device_register(&vfd
->class_dev
);
342 class_device_create_file(&vfd
->class_dev
,
343 &class_device_attr_name
);
346 /* needed until all drivers are fixed */
348 printk(KERN_WARNING
"videodev: \"%s\" has no release callback. "
349 "Please fix your driver for proper sysfs support, see "
350 "http://lwn.net/Articles/36850/\n", vfd
->name
);
356 * video_unregister_device - unregister a video4linux device
357 * @vfd: the device to unregister
359 * This unregisters the passed device and deassigns the minor
360 * number. Future open calls will be met with errors.
363 void video_unregister_device(struct video_device
*vfd
)
365 down(&videodev_lock
);
366 if(video_device
[vfd
->minor
]!=vfd
)
367 panic("videodev: bad unregister");
369 devfs_remove(vfd
->devfs_name
);
370 video_device
[vfd
->minor
]=NULL
;
371 class_device_unregister(&vfd
->class_dev
);
376 static struct file_operations video_fops
=
378 .owner
= THIS_MODULE
,
384 * Initialise video for linux
387 static int __init
videodev_init(void)
391 printk(KERN_INFO
"Linux video capture interface: v1.00\n");
392 if (register_chrdev(VIDEO_MAJOR
, VIDEO_NAME
, &video_fops
)) {
393 printk(KERN_WARNING
"video_dev: unable to get major %d\n", VIDEO_MAJOR
);
397 ret
= class_register(&video_class
);
399 unregister_chrdev(VIDEO_MAJOR
, VIDEO_NAME
);
400 printk(KERN_WARNING
"video_dev: class_register failed\n");
407 static void __exit
videodev_exit(void)
409 class_unregister(&video_class
);
410 unregister_chrdev(VIDEO_MAJOR
, VIDEO_NAME
);
413 module_init(videodev_init
)
414 module_exit(videodev_exit
)
416 EXPORT_SYMBOL(video_register_device
);
417 EXPORT_SYMBOL(video_unregister_device
);
418 EXPORT_SYMBOL(video_devdata
);
419 EXPORT_SYMBOL(video_usercopy
);
420 EXPORT_SYMBOL(video_exclusive_open
);
421 EXPORT_SYMBOL(video_exclusive_release
);
422 EXPORT_SYMBOL(video_device_alloc
);
423 EXPORT_SYMBOL(video_device_release
);
425 MODULE_AUTHOR("Alan Cox");
426 MODULE_DESCRIPTION("Device registrar for Video4Linux drivers");
427 MODULE_LICENSE("GPL");