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