| 0,0 → 1,408 |
|---|
| /* |
| * Video capture interface for Linux |
| * |
| * A generic video device interface for the LINUX operating system |
| * using a set of device structures/vectors for low level operations. |
| * |
| * This program is free software; you can redistribute it and/or |
| * modify it under the terms of the GNU General Public License |
| * as published by the Free Software Foundation; either version |
| * 2 of the License, or (at your option) any later version. |
| * |
| * Author: Alan Cox, <alan@redhat.com> |
| * |
| * Fixes: 20000516 Claudio Matsuoka <claudio@conectiva.com> |
| * - Added procfs support |
| */ |
| |
| #include <linuxcomp.h> |
| |
| #include <linux/module.h> |
| #include <linux/types.h> |
| #include <linux/kernel.h> |
| #include <linux/sched.h> |
| #include <linux/smp_lock.h> |
| #include <linux/mm.h> |
| #include <linux/string.h> |
| #include <linux/errno.h> |
| #include <linux/init.h> |
| #include <linux/kmod.h> |
| #include <linux/slab.h> |
| #include <linux/devfs_fs_kernel.h> |
| #include <asm/uaccess.h> |
| #include <asm/system.h> |
| #include <asm/semaphore.h> |
| |
| #include <linux/videodev.h> |
| |
| #define VIDEO_NUM_DEVICES 256 |
| #define VIDEO_NAME "video4linux" |
| |
| /* |
| * sysfs stuff |
| */ |
| |
| static ssize_t show_name(struct class_device *cd, char *buf) |
| { |
| struct video_device *vfd = container_of(cd, struct video_device, class_dev); |
| return sprintf26(buf,"%.*s\n",(int)sizeof(vfd->name),vfd->name); |
| } |
| |
| static ssize_t show_dev(struct class_device *cd, char *buf) |
| { |
| struct video_device *vfd = container_of(cd, struct video_device, class_dev); |
| dev_t dev = MKDEV(VIDEO_MAJOR, vfd->minor); |
| return print_dev_t(buf,dev); |
| } |
| |
| static CLASS_DEVICE_ATTR(name, S_IRUGO, show_name, NULL); |
| static CLASS_DEVICE_ATTR(dev, S_IRUGO, show_dev, NULL); |
| |
| struct video_device *video_device_alloc(void) |
| { |
| struct video_device *vfd; |
| |
| vfd = kmalloc(sizeof(*vfd),GFP_KERNEL); |
| if (NULL == vfd) |
| return NULL; |
| memset(vfd,0,sizeof(*vfd)); |
| return vfd; |
| } |
| |
| void video_device_release(struct video_device *vfd) |
| { |
| kfree(vfd); |
| } |
| |
| static void video_release(struct class_device *cd) |
| { |
| struct video_device *vfd = container_of(cd, struct video_device, class_dev); |
| |
| #if 1 /* needed until all drivers are fixed */ |
| if (!vfd->release) |
| return; |
| #endif |
| vfd->release(vfd); |
| } |
| |
| static struct class video_class = { |
| .name = VIDEO_NAME, |
| .release = video_release, |
| }; |
| |
| /* |
| * Active devices |
| */ |
| |
| static struct video_device *video_device[VIDEO_NUM_DEVICES]; |
| static DECLARE_MUTEX(videodev_lock); |
| |
| struct video_device* video_devdata(struct file *file) |
| { |
| return video_device[iminor(file->f_dentry->d_inode)]; |
| } |
| |
| /* |
| * Open a video device. |
| */ |
| static int video_open(struct inode *inode, struct file *file) |
| { |
| unsigned int minor = iminor(inode); |
| int err = 0; |
| struct video_device *vfl; |
| struct file_operations *old_fops; |
| |
| if(minor>=VIDEO_NUM_DEVICES) |
| return -ENODEV; |
| //down(&videodev_lock); |
| vfl=video_device[minor]; |
| if(vfl==NULL) { |
| //up(&videodev_lock); |
| //request_module("char-major-%d-%d", VIDEO_MAJOR, minor); |
| //down(&videodev_lock); |
| vfl=video_device[minor]; |
| if (vfl==NULL) { |
| //up(&videodev_lock); |
| return -ENODEV; |
| } |
| } |
| old_fops = file->f_op; |
| file->f_op = fops_get(vfl->fops); |
| if(file->f_op->open) |
| err = file->f_op->open(inode,file); |
| if (err) { |
| fops_put(file->f_op); |
| file->f_op = fops_get(old_fops); |
| } |
| fops_put(old_fops); |
| //up(&videodev_lock); |
| return err; |
| } |
| |
| /* |
| * helper function -- handles userspace copying for ioctl arguments |
| */ |
| int |
| video_usercopy(struct inode *inode, struct file *file, |
| unsigned int cmd, unsigned long arg, |
| int (*func)(struct inode *inode, struct file *file, |
| unsigned int cmd, void *arg)) |
| { |
| char sbuf[128]; |
| void *mbuf = NULL; |
| void *parg = NULL; |
| int err = -EINVAL; |
| |
| /* Copy arguments into temp kernel buffer */ |
| switch (_IOC_DIR(cmd)) { |
| case _IOC_NONE: |
| parg = (void *)arg; |
| break; |
| case _IOC_READ: /* some v4l ioctls are marked wrong ... */ |
| case _IOC_WRITE: |
| case (_IOC_WRITE | _IOC_READ): |
| if (_IOC_SIZE(cmd) <= sizeof(sbuf)) { |
| parg = sbuf; |
| } else { |
| /* too big to allocate from stack */ |
| mbuf = kmalloc(_IOC_SIZE(cmd),GFP_KERNEL); |
| if (NULL == mbuf) |
| return -ENOMEM; |
| parg = mbuf; |
| } |
| |
| err = -EFAULT; |
| if (copy_from_user(parg, (void *)arg, _IOC_SIZE(cmd))) |
| goto out; |
| break; |
| } |
| |
| /* call driver */ |
| err = func(inode, file, cmd, parg); |
| if (err == -ENOIOCTLCMD) |
| err = -EINVAL; |
| if (err < 0) |
| goto out; |
| |
| /* Copy results into user buffer */ |
| switch (_IOC_DIR(cmd)) |
| { |
| case _IOC_READ: |
| case (_IOC_WRITE | _IOC_READ): |
| if (copy_to_user((void *)arg, parg, _IOC_SIZE(cmd))) |
| err = -EFAULT; |
| break; |
| } |
| |
| out: |
| if (mbuf) |
| kfree(mbuf); |
| return err; |
| } |
| |
| /* |
| * open/release helper functions -- handle exclusive opens |
| */ |
| extern int video_exclusive_open(struct inode *inode, struct file *file) |
| { |
| struct video_device *vfl = video_devdata(file); |
| int retval = 0; |
| |
| //down(&vfl->lock); |
| if (vfl->users) { |
| retval = -EBUSY; |
| } else { |
| vfl->users++; |
| } |
| //up(&vfl->lock); |
| return retval; |
| } |
| |
| extern int video_exclusive_release(struct inode *inode, struct file *file) |
| { |
| struct video_device *vfl = video_devdata(file); |
| |
| vfl->users--; |
| return 0; |
| } |
| |
| extern struct file_operations video_fops; |
| |
| /** |
| * video_register_device - register video4linux devices |
| * @vfd: video device structure we want to register |
| * @type: type of device to register |
| * @nr: which device number (0 == /dev/video0, 1 == /dev/video1, ... |
| * -1 == first free) |
| * |
| * The registration code assigns minor numbers based on the type |
| * requested. -ENFILE is returned in all the device slots for this |
| * category are full. If not then the minor field is set and the |
| * driver initialize function is called (if non %NULL). |
| * |
| * Zero is returned on success. |
| * |
| * Valid types are |
| * |
| * %VFL_TYPE_GRABBER - A frame grabber |
| * |
| * %VFL_TYPE_VTX - A teletext device |
| * |
| * %VFL_TYPE_VBI - Vertical blank data (undecoded) |
| * |
| * %VFL_TYPE_RADIO - A radio card |
| */ |
| |
| int video_register_device(struct video_device *vfd, int type, int nr) |
| { |
| int i=0; |
| int base; |
| int end; |
| char *name_base; |
| |
| switch(type) |
| { |
| case VFL_TYPE_GRABBER: |
| base=0; |
| end=64; |
| name_base = "video"; |
| break; |
| case VFL_TYPE_VTX: |
| base=192; |
| end=224; |
| name_base = "vtx"; |
| break; |
| case VFL_TYPE_VBI: |
| base=224; |
| end=240; |
| name_base = "vbi"; |
| break; |
| case VFL_TYPE_RADIO: |
| base=64; |
| end=128; |
| name_base = "radio"; |
| break; |
| default: |
| return -1; |
| } |
| |
| /* pick a minor number */ |
| //down(&videodev_lock); |
| if (-1 == nr) { |
| /* use first free */ |
| for(i=base;i<end;i++) |
| if (NULL == video_device[i]) |
| break; |
| if (i == end) { |
| //up(&videodev_lock); |
| return -ENFILE; |
| } |
| } else { |
| /* use the one the driver asked for */ |
| i = base+nr; |
| if (NULL != video_device[i]) { |
| //up(&videodev_lock); |
| return -ENFILE; |
| } |
| } |
| video_device[i]=vfd; |
| vfd->minor=i; |
| //up(&videodev_lock); |
| |
| sprintf26(vfd->devfs_name, "v4l/%s%d", name_base, i - base); |
| devfs_mk_cdev(MKDEV(VIDEO_MAJOR, vfd->minor), |
| S_IFCHR | S_IRUSR | S_IWUSR, vfd->devfs_name); |
| //init_MUTEX(&vfd->lock); |
| |
| /* sysfs class */ |
| memset(&vfd->class_dev, 0x00, sizeof(vfd->class_dev)); |
| if (vfd->dev) |
| vfd->class_dev.dev = vfd->dev; |
| vfd->class_dev.class = &video_class; |
| strncpy(vfd->class_dev.class_id, vfd->devfs_name + 4, BUS_ID_SIZE); |
| class_device_register(&vfd->class_dev); |
| class_device_create_file(&vfd->class_dev, |
| &class_device_attr_name); |
| class_device_create_file(&vfd->class_dev, |
| &class_device_attr_dev); |
| |
| #if 1 /* needed until all drivers are fixed */ |
| if (!vfd->release) |
| printk(KERN_WARNING "videodev: \"%s\" has no release callback. " |
| "Please fix your driver for proper sysfs support, see " |
| "http://lwn.net/Articles/36850/\n", vfd->name); |
| #endif |
| return 0; |
| } |
| |
| /** |
| * video_unregister_device - unregister a video4linux device |
| * @vfd: the device to unregister |
| * |
| * This unregisters the passed device and deassigns the minor |
| * number. Future open calls will be met with errors. |
| */ |
| |
| void video_unregister_device(struct video_device *vfd) |
| { |
| //down(&videodev_lock); |
| if(video_device[vfd->minor]!=vfd) |
| panic("videodev: bad unregister"); |
| |
| devfs_remove(vfd->devfs_name); |
| video_device[vfd->minor]=NULL; |
| class_device_unregister(&vfd->class_dev); |
| //up(&videodev_lock); |
| } |
| |
| |
| static struct file_operations video_fops= |
| { |
| .owner = THIS_MODULE, |
| .llseek = no_llseek, |
| .open = video_open, |
| }; |
| |
| /* |
| * Initialise video for linux |
| */ |
| |
| int __init videodev_init(void) |
| { |
| printk(KERN_INFO "Linux video capture interface: v1.00\n"); |
| if (register_chrdev(VIDEO_MAJOR,VIDEO_NAME, &video_fops)) { |
| printk("video_dev: unable to get major %d\n", VIDEO_MAJOR); |
| return -EIO; |
| } |
| class_register(&video_class); |
| return 0; |
| } |
| |
| void __exit videodev_exit(void) |
| { |
| class_unregister(&video_class); |
| unregister_chrdev(VIDEO_MAJOR, VIDEO_NAME); |
| } |
| |
| module_init(videodev_init) |
| module_exit(videodev_exit) |
| |
| EXPORT_SYMBOL(video_register_device); |
| EXPORT_SYMBOL(video_unregister_device); |
| EXPORT_SYMBOL(video_devdata); |
| EXPORT_SYMBOL(video_usercopy); |
| EXPORT_SYMBOL(video_exclusive_open); |
| EXPORT_SYMBOL(video_exclusive_release); |
| EXPORT_SYMBOL(video_device_alloc); |
| EXPORT_SYMBOL(video_device_release); |
| |
| MODULE_AUTHOR("Alan Cox"); |
| MODULE_DESCRIPTION("Device registrar for Video4Linux drivers"); |
| MODULE_LICENSE("GPL"); |
| |
| |
| /* |
| * Local variables: |
| * c-basic-offset: 8 |
| * End: |
| */ |