drivers/media/v4l2-core/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
  30 #include <media/v4l2-common.h>
  31 #include <media/v4l2-device.h>
  32 #include <media/v4l2-ioctl.h>
  33
  34 #define VIDEO_NUM_DEVICES       256
  35 #define VIDEO_NAME              "video4linux"
  36
  37 /*
  38  *      sysfs stuff
  39  */
  40
  41 static ssize_t index_show(struct device *cd,
  42                           struct device_attribute *attr, char *buf)
  43 {
  44         struct video_device *vdev = to_video_device(cd);
  45
  46         return sprintf(buf, "%i\n", vdev->index);
  47 }
  48 static DEVICE_ATTR_RO(index);
  49
  50 static ssize_t dev_debug_show(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, "%i\n", vdev->dev_debug);
  56 }
  57
  58 static ssize_t dev_debug_store(struct device *cd, struct device_attribute *attr,
  59                           const char *buf, size_t len)
  60 {
  61         struct video_device *vdev = to_video_device(cd);
  62         int res = 0;
  63         u16 value;
  64
  65         res = kstrtou16(buf, 0, &value);
  66         if (res)
  67                 return res;
  68
  69         vdev->dev_debug = value;
  70         return len;
  71 }
  72 static DEVICE_ATTR_RW(dev_debug);
  73
  74 static ssize_t name_show(struct device *cd,
  75                          struct device_attribute *attr, char *buf)
  76 {
  77         struct video_device *vdev = to_video_device(cd);
  78
  79         return sprintf(buf, "%.*s\n", (int)sizeof(vdev->name), vdev->name);
  80 }
  81 static DEVICE_ATTR_RO(name);
  82
  83 static struct attribute *video_device_attrs[] = {
  84         &dev_attr_name.attr,
  85         &dev_attr_dev_debug.attr,
  86         &dev_attr_index.attr,
  87         NULL,
  88 };
  89 ATTRIBUTE_GROUPS(video_device);
  90
  91 /*
  92  *      Active devices
  93  */
  94 static struct video_device *video_device[VIDEO_NUM_DEVICES];
  95 static DEFINE_MUTEX(videodev_lock);
  96 static DECLARE_BITMAP(devnode_nums[VFL_TYPE_MAX], VIDEO_NUM_DEVICES);
  97
  98 /* Device node utility functions */
  99
 100 /* Note: these utility functions all assume that vfl_type is in the range
 101    [0, VFL_TYPE_MAX-1]. */
 102
 103 #ifdef CONFIG_VIDEO_FIXED_MINOR_RANGES
 104 /* Return the bitmap corresponding to vfl_type. */
 105 static inline unsigned long *devnode_bits(int vfl_type)
 106 {
 107         /* Any types not assigned to fixed minor ranges must be mapped to
 108            one single bitmap for the purposes of finding a free node number
 109            since all those unassigned types use the same minor range. */
 110         int idx = (vfl_type > VFL_TYPE_RADIO) ? VFL_TYPE_MAX - 1 : vfl_type;
 111
 112         return devnode_nums[idx];
 113 }
 114 #else
 115 /* Return the bitmap corresponding to vfl_type. */
 116 static inline unsigned long *devnode_bits(int vfl_type)
 117 {
 118         return devnode_nums[vfl_type];
 119 }
 120 #endif
 121
 122 /* Mark device node number vdev->num as used */
 123 static inline void devnode_set(struct video_device *vdev)
 124 {
 125         set_bit(vdev->num, devnode_bits(vdev->vfl_type));
 126 }
 127
 128 /* Mark device node number vdev->num as unused */
 129 static inline void devnode_clear(struct video_device *vdev)
 130 {
 131         clear_bit(vdev->num, devnode_bits(vdev->vfl_type));
 132 }
 133
 134 /* Try to find a free device node number in the range [from, to> */
 135 static inline int devnode_find(struct video_device *vdev, int from, int to)
 136 {
 137         return find_next_zero_bit(devnode_bits(vdev->vfl_type), to, from);
 138 }
 139
 140 struct video_device *video_device_alloc(void)
 141 {
 142         return kzalloc(sizeof(struct video_device), GFP_KERNEL);
 143 }
 144 EXPORT_SYMBOL(video_device_alloc);
 145
 146 void video_device_release(struct video_device *vdev)
 147 {
 148         kfree(vdev);
 149 }
 150 EXPORT_SYMBOL(video_device_release);
 151
 152 void video_device_release_empty(struct video_device *vdev)
 153 {
 154         /* Do nothing */
 155         /* Only valid when the video_device struct is a static. */
 156 }
 157 EXPORT_SYMBOL(video_device_release_empty);
 158
 159 static inline void video_get(struct video_device *vdev)
 160 {
 161         get_device(&vdev->dev);
 162 }
 163
 164 static inline void video_put(struct video_device *vdev)
 165 {
 166         put_device(&vdev->dev);
 167 }
 168
 169 /* Called when the last user of the video device exits. */
 170 static void v4l2_device_release(struct device *cd)
 171 {
 172         struct video_device *vdev = to_video_device(cd);
 173         struct v4l2_device *v4l2_dev = vdev->v4l2_dev;
 174
 175         mutex_lock(&videodev_lock);
 176         if (WARN_ON(video_device[vdev->minor] != vdev)) {
 177                 /* should not happen */
 178                 mutex_unlock(&videodev_lock);
 179                 return;
 180         }
 181
 182         /* Free up this device for reuse */
 183         video_device[vdev->minor] = NULL;
 184
 185         /* Delete the cdev on this minor as well */
 186         cdev_del(vdev->cdev);
 187         /* Just in case some driver tries to access this from
 188            the release() callback. */
 189         vdev->cdev = NULL;
 190
 191         /* Mark device node number as free */
 192         devnode_clear(vdev);
 193
 194         mutex_unlock(&videodev_lock);
 195
 196 #if defined(CONFIG_MEDIA_CONTROLLER)
 197         if (v4l2_dev->mdev) {
 198                 /* Remove interfaces and interface links */
 199                 media_devnode_remove(vdev->intf_devnode);
 200                 if (vdev->entity.function != MEDIA_ENT_F_UNKNOWN)
 201                         media_device_unregister_entity(&vdev->entity);
 202         }
 203 #endif
 204
 205         /* Do not call v4l2_device_put if there is no release callback set.
 206          * Drivers that have no v4l2_device release callback might free the
 207          * v4l2_dev instance in the video_device release callback below, so we
 208          * must perform this check here.
 209          *
 210          * TODO: In the long run all drivers that use v4l2_device should use the
 211          * v4l2_device release callback. This check will then be unnecessary.
 212          */
 213         if (v4l2_dev->release == NULL)
 214                 v4l2_dev = NULL;
 215
 216         /* Release video_device and perform other
 217            cleanups as needed. */
 218         vdev->release(vdev);
 219
 220         /* Decrease v4l2_device refcount */
 221         if (v4l2_dev)
 222                 v4l2_device_put(v4l2_dev);
 223 }
 224
 225 static struct class video_class = {
 226         .name = VIDEO_NAME,
 227         .dev_groups = video_device_groups,
 228 };
 229
 230 struct video_device *video_devdata(struct file *file)
 231 {
 232         return video_device[iminor(file_inode(file))];
 233 }
 234 EXPORT_SYMBOL(video_devdata);
 235
 236
 237 /* Priority handling */
 238
 239 static inline bool prio_is_valid(enum v4l2_priority prio)
 240 {
 241         return prio == V4L2_PRIORITY_BACKGROUND ||
 242                prio == V4L2_PRIORITY_INTERACTIVE ||
 243                prio == V4L2_PRIORITY_RECORD;
 244 }
 245
 246 void v4l2_prio_init(struct v4l2_prio_state *global)
 247 {
 248         memset(global, 0, sizeof(*global));
 249 }
 250 EXPORT_SYMBOL(v4l2_prio_init);
 251
 252 int v4l2_prio_change(struct v4l2_prio_state *global, enum v4l2_priority *local,
 253                      enum v4l2_priority new)
 254 {
 255         if (!prio_is_valid(new))
 256                 return -EINVAL;
 257         if (*local == new)
 258                 return 0;
 259
 260         atomic_inc(&global->prios[new]);
 261         if (prio_is_valid(*local))
 262                 atomic_dec(&global->prios[*local]);
 263         *local = new;
 264         return 0;
 265 }
 266 EXPORT_SYMBOL(v4l2_prio_change);
 267
 268 void v4l2_prio_open(struct v4l2_prio_state *global, enum v4l2_priority *local)
 269 {
 270         v4l2_prio_change(global, local, V4L2_PRIORITY_DEFAULT);
 271 }
 272 EXPORT_SYMBOL(v4l2_prio_open);
 273
 274 void v4l2_prio_close(struct v4l2_prio_state *global, enum v4l2_priority local)
 275 {
 276         if (prio_is_valid(local))
 277                 atomic_dec(&global->prios[local]);
 278 }
 279 EXPORT_SYMBOL(v4l2_prio_close);
 280
 281 enum v4l2_priority v4l2_prio_max(struct v4l2_prio_state *global)
 282 {
 283         if (atomic_read(&global->prios[V4L2_PRIORITY_RECORD]) > 0)
 284                 return V4L2_PRIORITY_RECORD;
 285         if (atomic_read(&global->prios[V4L2_PRIORITY_INTERACTIVE]) > 0)
 286                 return V4L2_PRIORITY_INTERACTIVE;
 287         if (atomic_read(&global->prios[V4L2_PRIORITY_BACKGROUND]) > 0)
 288                 return V4L2_PRIORITY_BACKGROUND;
 289         return V4L2_PRIORITY_UNSET;
 290 }
 291 EXPORT_SYMBOL(v4l2_prio_max);
 292
 293 int v4l2_prio_check(struct v4l2_prio_state *global, enum v4l2_priority local)
 294 {
 295         return (local < v4l2_prio_max(global)) ? -EBUSY : 0;
 296 }
 297 EXPORT_SYMBOL(v4l2_prio_check);
 298
 299
 300 static ssize_t v4l2_read(struct file *filp, char __user *buf,
 301                 size_t sz, loff_t *off)
 302 {
 303         struct video_device *vdev = video_devdata(filp);
 304         int ret = -ENODEV;
 305
 306         if (!vdev->fops->read)
 307                 return -EINVAL;
 308         if (video_is_registered(vdev))
 309                 ret = vdev->fops->read(filp, buf, sz, off);
 310         if ((vdev->dev_debug & V4L2_DEV_DEBUG_FOP) &&
 311             (vdev->dev_debug & V4L2_DEV_DEBUG_STREAMING))
 312                 printk(KERN_DEBUG "%s: read: %zd (%d)\n",
 313                         video_device_node_name(vdev), sz, ret);
 314         return ret;
 315 }
 316
 317 static ssize_t v4l2_write(struct file *filp, const char __user *buf,
 318                 size_t sz, loff_t *off)
 319 {
 320         struct video_device *vdev = video_devdata(filp);
 321         int ret = -ENODEV;
 322
 323         if (!vdev->fops->write)
 324                 return -EINVAL;
 325         if (video_is_registered(vdev))
 326                 ret = vdev->fops->write(filp, buf, sz, off);
 327         if ((vdev->dev_debug & V4L2_DEV_DEBUG_FOP) &&
 328             (vdev->dev_debug & V4L2_DEV_DEBUG_STREAMING))
 329                 printk(KERN_DEBUG "%s: write: %zd (%d)\n",
 330                         video_device_node_name(vdev), sz, ret);
 331         return ret;
 332 }
 333
 334 static unsigned int v4l2_poll(struct file *filp, struct poll_table_struct *poll)
 335 {
 336         struct video_device *vdev = video_devdata(filp);
 337         unsigned int res = POLLERR | POLLHUP;
 338
 339         if (!vdev->fops->poll)
 340                 return DEFAULT_POLLMASK;
 341         if (video_is_registered(vdev))
 342                 res = vdev->fops->poll(filp, poll);
 343         if (vdev->dev_debug & V4L2_DEV_DEBUG_POLL)
 344                 printk(KERN_DEBUG "%s: poll: %08x\n",
 345                         video_device_node_name(vdev), res);
 346         return res;
 347 }
 348
 349 static long v4l2_ioctl(struct file *filp, unsigned int cmd, unsigned long arg)
 350 {
 351         struct video_device *vdev = video_devdata(filp);
 352         int ret = -ENODEV;
 353
 354         if (vdev->fops->unlocked_ioctl) {
 355                 struct mutex *lock = v4l2_ioctl_get_lock(vdev, cmd);
 356
 357                 if (lock && mutex_lock_interruptible(lock))
 358                         return -ERESTARTSYS;
 359                 if (video_is_registered(vdev))
 360                         ret = vdev->fops->unlocked_ioctl(filp, cmd, arg);
 361                 if (lock)
 362                         mutex_unlock(lock);
 363         } else
 364                 ret = -ENOTTY;
 365
 366         return ret;
 367 }
 368
 369 #ifdef CONFIG_MMU
 370 #define v4l2_get_unmapped_area NULL
 371 #else
 372 static unsigned long v4l2_get_unmapped_area(struct file *filp,
 373                 unsigned long addr, unsigned long len, unsigned long pgoff,
 374                 unsigned long flags)
 375 {
 376         struct video_device *vdev = video_devdata(filp);
 377         int ret;
 378
 379         if (!vdev->fops->get_unmapped_area)
 380                 return -ENOSYS;
 381         if (!video_is_registered(vdev))
 382                 return -ENODEV;
 383         ret = vdev->fops->get_unmapped_area(filp, addr, len, pgoff, flags);
 384         if (vdev->dev_debug & V4L2_DEV_DEBUG_FOP)
 385                 printk(KERN_DEBUG "%s: get_unmapped_area (%d)\n",
 386                         video_device_node_name(vdev), ret);
 387         return ret;
 388 }
 389 #endif
 390
 391 static int v4l2_mmap(struct file *filp, struct vm_area_struct *vm)
 392 {
 393         struct video_device *vdev = video_devdata(filp);
 394         int ret = -ENODEV;
 395
 396         if (!vdev->fops->mmap)
 397                 return -ENODEV;
 398         if (video_is_registered(vdev))
 399                 ret = vdev->fops->mmap(filp, vm);
 400         if (vdev->dev_debug & V4L2_DEV_DEBUG_FOP)
 401                 printk(KERN_DEBUG "%s: mmap (%d)\n",
 402                         video_device_node_name(vdev), ret);
 403         return ret;
 404 }
 405
 406 /* Override for the open function */
 407 static int v4l2_open(struct inode *inode, struct file *filp)
 408 {
 409         struct video_device *vdev;
 410         int ret = 0;
 411
 412         /* Check if the video device is available */
 413         mutex_lock(&videodev_lock);
 414         vdev = video_devdata(filp);
 415         /* return ENODEV if the video device has already been removed. */
 416         if (vdev == NULL || !video_is_registered(vdev)) {
 417                 mutex_unlock(&videodev_lock);
 418                 return -ENODEV;
 419         }
 420         /* and increase the device refcount */
 421         video_get(vdev);
 422         mutex_unlock(&videodev_lock);
 423         if (vdev->fops->open) {
 424                 if (video_is_registered(vdev))
 425                         ret = vdev->fops->open(filp);
 426                 else
 427                         ret = -ENODEV;
 428         }
 429
 430         if (vdev->dev_debug & V4L2_DEV_DEBUG_FOP)
 431                 printk(KERN_DEBUG "%s: open (%d)\n",
 432                         video_device_node_name(vdev), ret);
 433         /* decrease the refcount in case of an error */
 434         if (ret)
 435                 video_put(vdev);
 436         return ret;
 437 }
 438
 439 /* Override for the release function */
 440 static int v4l2_release(struct inode *inode, struct file *filp)
 441 {
 442         struct video_device *vdev = video_devdata(filp);
 443         int ret = 0;
 444
 445         if (vdev->fops->release)
 446                 ret = vdev->fops->release(filp);
 447         if (vdev->dev_debug & V4L2_DEV_DEBUG_FOP)
 448                 printk(KERN_DEBUG "%s: release\n",
 449                         video_device_node_name(vdev));
 450
 451         /* decrease the refcount unconditionally since the release()
 452            return value is ignored. */
 453         video_put(vdev);
 454         return ret;
 455 }
 456
 457 static const struct file_operations v4l2_fops = {
 458         .owner = THIS_MODULE,
 459         .read = v4l2_read,
 460         .write = v4l2_write,
 461         .open = v4l2_open,
 462         .get_unmapped_area = v4l2_get_unmapped_area,
 463         .mmap = v4l2_mmap,
 464         .unlocked_ioctl = v4l2_ioctl,
 465 #ifdef CONFIG_COMPAT
 466         .compat_ioctl = v4l2_compat_ioctl32,
 467 #endif
 468         .release = v4l2_release,
 469         .poll = v4l2_poll,
 470         .llseek = no_llseek,
 471 };
 472
 473 /**
 474  * get_index - assign stream index number based on v4l2_dev
 475  * @vdev: video_device to assign index number to, vdev->v4l2_dev should be assigned
 476  *
 477  * Note that when this is called the new device has not yet been registered
 478  * in the video_device array, but it was able to obtain a minor number.
 479  *
 480  * This means that we can always obtain a free stream index number since
 481  * the worst case scenario is that there are VIDEO_NUM_DEVICES - 1 slots in
 482  * use of the video_device array.
 483  *
 484  * Returns a free index number.
 485  */
 486 static int get_index(struct video_device *vdev)
 487 {
 488         /* This can be static since this function is called with the global
 489            videodev_lock held. */
 490         static DECLARE_BITMAP(used, VIDEO_NUM_DEVICES);
 491         int i;
 492
 493         bitmap_zero(used, VIDEO_NUM_DEVICES);
 494
 495         for (i = 0; i < VIDEO_NUM_DEVICES; i++) {
 496                 if (video_device[i] != NULL &&
 497                     video_device[i]->v4l2_dev == vdev->v4l2_dev) {
 498                         set_bit(video_device[i]->index, used);
 499                 }
 500         }
 501
 502         return find_first_zero_bit(used, VIDEO_NUM_DEVICES);
 503 }
 504
 505 #define SET_VALID_IOCTL(ops, cmd, op)                   \
 506         if (ops->op)                                    \
 507                 set_bit(_IOC_NR(cmd), valid_ioctls)
 508
 509 /* This determines which ioctls are actually implemented in the driver.
 510    It's a one-time thing which simplifies video_ioctl2 as it can just do
 511    a bit test.
 512
 513    Note that drivers can override this by setting bits to 1 in
 514    vdev->valid_ioctls. If an ioctl is marked as 1 when this function is
 515    called, then that ioctl will actually be marked as unimplemented.
 516
 517    It does that by first setting up the local valid_ioctls bitmap, and
 518    at the end do a:
 519
 520    vdev->valid_ioctls = valid_ioctls & ~(vdev->valid_ioctls)
 521  */
 522 static void determine_valid_ioctls(struct video_device *vdev)
 523 {
 524         DECLARE_BITMAP(valid_ioctls, BASE_VIDIOC_PRIVATE);
 525         const struct v4l2_ioctl_ops *ops = vdev->ioctl_ops;
 526         bool is_vid = vdev->vfl_type == VFL_TYPE_GRABBER;
 527         bool is_vbi = vdev->vfl_type == VFL_TYPE_VBI;
 528         bool is_radio = vdev->vfl_type == VFL_TYPE_RADIO;
 529         bool is_sdr = vdev->vfl_type == VFL_TYPE_SDR;
 530         bool is_rx = vdev->vfl_dir != VFL_DIR_TX;
 531         bool is_tx = vdev->vfl_dir != VFL_DIR_RX;
 532
 533         bitmap_zero(valid_ioctls, BASE_VIDIOC_PRIVATE);
 534
 535         /* vfl_type and vfl_dir independent ioctls */
 536
 537         SET_VALID_IOCTL(ops, VIDIOC_QUERYCAP, vidioc_querycap);
 538         set_bit(_IOC_NR(VIDIOC_G_PRIORITY), valid_ioctls);
 539         set_bit(_IOC_NR(VIDIOC_S_PRIORITY), valid_ioctls);
 540
 541         /* Note: the control handler can also be passed through the filehandle,
 542            and that can't be tested here. If the bit for these control ioctls
 543            is set, then the ioctl is valid. But if it is 0, then it can still
 544            be valid if the filehandle passed the control handler. */
 545         if (vdev->ctrl_handler || ops->vidioc_queryctrl)
 546                 set_bit(_IOC_NR(VIDIOC_QUERYCTRL), valid_ioctls);
 547         if (vdev->ctrl_handler || ops->vidioc_query_ext_ctrl)
 548                 set_bit(_IOC_NR(VIDIOC_QUERY_EXT_CTRL), valid_ioctls);
 549         if (vdev->ctrl_handler || ops->vidioc_g_ctrl || ops->vidioc_g_ext_ctrls)
 550                 set_bit(_IOC_NR(VIDIOC_G_CTRL), valid_ioctls);
 551         if (vdev->ctrl_handler || ops->vidioc_s_ctrl || ops->vidioc_s_ext_ctrls)
 552                 set_bit(_IOC_NR(VIDIOC_S_CTRL), valid_ioctls);
 553         if (vdev->ctrl_handler || ops->vidioc_g_ext_ctrls)
 554                 set_bit(_IOC_NR(VIDIOC_G_EXT_CTRLS), valid_ioctls);
 555         if (vdev->ctrl_handler || ops->vidioc_s_ext_ctrls)
 556                 set_bit(_IOC_NR(VIDIOC_S_EXT_CTRLS), valid_ioctls);
 557         if (vdev->ctrl_handler || ops->vidioc_try_ext_ctrls)
 558                 set_bit(_IOC_NR(VIDIOC_TRY_EXT_CTRLS), valid_ioctls);
 559         if (vdev->ctrl_handler || ops->vidioc_querymenu)
 560                 set_bit(_IOC_NR(VIDIOC_QUERYMENU), valid_ioctls);
 561         SET_VALID_IOCTL(ops, VIDIOC_G_FREQUENCY, vidioc_g_frequency);
 562         SET_VALID_IOCTL(ops, VIDIOC_S_FREQUENCY, vidioc_s_frequency);
 563         SET_VALID_IOCTL(ops, VIDIOC_LOG_STATUS, vidioc_log_status);
 564 #ifdef CONFIG_VIDEO_ADV_DEBUG
 565         set_bit(_IOC_NR(VIDIOC_DBG_G_CHIP_INFO), valid_ioctls);
 566         set_bit(_IOC_NR(VIDIOC_DBG_G_REGISTER), valid_ioctls);
 567         set_bit(_IOC_NR(VIDIOC_DBG_S_REGISTER), valid_ioctls);
 568 #endif
 569         /* yes, really vidioc_subscribe_event */
 570         SET_VALID_IOCTL(ops, VIDIOC_DQEVENT, vidioc_subscribe_event);
 571         SET_VALID_IOCTL(ops, VIDIOC_SUBSCRIBE_EVENT, vidioc_subscribe_event);
 572         SET_VALID_IOCTL(ops, VIDIOC_UNSUBSCRIBE_EVENT, vidioc_unsubscribe_event);
 573         if (ops->vidioc_enum_freq_bands || ops->vidioc_g_tuner || ops->vidioc_g_modulator)
 574                 set_bit(_IOC_NR(VIDIOC_ENUM_FREQ_BANDS), valid_ioctls);
 575
 576         if (is_vid) {
 577                 /* video specific ioctls */
 578                 if ((is_rx && (ops->vidioc_enum_fmt_vid_cap ||
 579                                ops->vidioc_enum_fmt_vid_cap_mplane ||
 580                                ops->vidioc_enum_fmt_vid_overlay)) ||
 581                     (is_tx && (ops->vidioc_enum_fmt_vid_out ||
 582                                ops->vidioc_enum_fmt_vid_out_mplane)))
 583                         set_bit(_IOC_NR(VIDIOC_ENUM_FMT), valid_ioctls);
 584                 if ((is_rx && (ops->vidioc_g_fmt_vid_cap ||
 585                                ops->vidioc_g_fmt_vid_cap_mplane ||
 586                                ops->vidioc_g_fmt_vid_overlay)) ||
 587                     (is_tx && (ops->vidioc_g_fmt_vid_out ||
 588                                ops->vidioc_g_fmt_vid_out_mplane ||
 589                                ops->vidioc_g_fmt_vid_out_overlay)))
 590                          set_bit(_IOC_NR(VIDIOC_G_FMT), valid_ioctls);
 591                 if ((is_rx && (ops->vidioc_s_fmt_vid_cap ||
 592                                ops->vidioc_s_fmt_vid_cap_mplane ||
 593                                ops->vidioc_s_fmt_vid_overlay)) ||
 594                     (is_tx && (ops->vidioc_s_fmt_vid_out ||
 595                                ops->vidioc_s_fmt_vid_out_mplane ||
 596                                ops->vidioc_s_fmt_vid_out_overlay)))
 597                          set_bit(_IOC_NR(VIDIOC_S_FMT), valid_ioctls);
 598                 if ((is_rx && (ops->vidioc_try_fmt_vid_cap ||
 599                                ops->vidioc_try_fmt_vid_cap_mplane ||
 600                                ops->vidioc_try_fmt_vid_overlay)) ||
 601                     (is_tx && (ops->vidioc_try_fmt_vid_out ||
 602                                ops->vidioc_try_fmt_vid_out_mplane ||
 603                                ops->vidioc_try_fmt_vid_out_overlay)))
 604                          set_bit(_IOC_NR(VIDIOC_TRY_FMT), valid_ioctls);
 605                 SET_VALID_IOCTL(ops, VIDIOC_OVERLAY, vidioc_overlay);
 606                 SET_VALID_IOCTL(ops, VIDIOC_G_FBUF, vidioc_g_fbuf);
 607                 SET_VALID_IOCTL(ops, VIDIOC_S_FBUF, vidioc_s_fbuf);
 608                 SET_VALID_IOCTL(ops, VIDIOC_G_JPEGCOMP, vidioc_g_jpegcomp);
 609                 SET_VALID_IOCTL(ops, VIDIOC_S_JPEGCOMP, vidioc_s_jpegcomp);
 610                 SET_VALID_IOCTL(ops, VIDIOC_G_ENC_INDEX, vidioc_g_enc_index);
 611                 SET_VALID_IOCTL(ops, VIDIOC_ENCODER_CMD, vidioc_encoder_cmd);
 612                 SET_VALID_IOCTL(ops, VIDIOC_TRY_ENCODER_CMD, vidioc_try_encoder_cmd);
 613                 SET_VALID_IOCTL(ops, VIDIOC_DECODER_CMD, vidioc_decoder_cmd);
 614                 SET_VALID_IOCTL(ops, VIDIOC_TRY_DECODER_CMD, vidioc_try_decoder_cmd);
 615                 SET_VALID_IOCTL(ops, VIDIOC_ENUM_FRAMESIZES, vidioc_enum_framesizes);
 616                 SET_VALID_IOCTL(ops, VIDIOC_ENUM_FRAMEINTERVALS, vidioc_enum_frameintervals);
 617                 if (ops->vidioc_g_crop || ops->vidioc_g_selection)
 618                         set_bit(_IOC_NR(VIDIOC_G_CROP), valid_ioctls);
 619                 if (ops->vidioc_s_crop || ops->vidioc_s_selection)
 620                         set_bit(_IOC_NR(VIDIOC_S_CROP), valid_ioctls);
 621                 SET_VALID_IOCTL(ops, VIDIOC_G_SELECTION, vidioc_g_selection);
 622                 SET_VALID_IOCTL(ops, VIDIOC_S_SELECTION, vidioc_s_selection);
 623                 if (ops->vidioc_cropcap || ops->vidioc_g_selection)
 624                         set_bit(_IOC_NR(VIDIOC_CROPCAP), valid_ioctls);
 625         } else if (is_vbi) {
 626                 /* vbi specific ioctls */
 627                 if ((is_rx && (ops->vidioc_g_fmt_vbi_cap ||
 628                                ops->vidioc_g_fmt_sliced_vbi_cap)) ||
 629                     (is_tx && (ops->vidioc_g_fmt_vbi_out ||
 630                                ops->vidioc_g_fmt_sliced_vbi_out)))
 631                         set_bit(_IOC_NR(VIDIOC_G_FMT), valid_ioctls);
 632                 if ((is_rx && (ops->vidioc_s_fmt_vbi_cap ||
 633                                ops->vidioc_s_fmt_sliced_vbi_cap)) ||
 634                     (is_tx && (ops->vidioc_s_fmt_vbi_out ||
 635                                ops->vidioc_s_fmt_sliced_vbi_out)))
 636                         set_bit(_IOC_NR(VIDIOC_S_FMT), valid_ioctls);
 637                 if ((is_rx && (ops->vidioc_try_fmt_vbi_cap ||
 638                                ops->vidioc_try_fmt_sliced_vbi_cap)) ||
 639                     (is_tx && (ops->vidioc_try_fmt_vbi_out ||
 640                                ops->vidioc_try_fmt_sliced_vbi_out)))
 641                         set_bit(_IOC_NR(VIDIOC_TRY_FMT), valid_ioctls);
 642                 SET_VALID_IOCTL(ops, VIDIOC_G_SLICED_VBI_CAP, vidioc_g_sliced_vbi_cap);
 643         } else if (is_sdr && is_rx) {
 644                 /* SDR receiver specific ioctls */
 645                 if (ops->vidioc_enum_fmt_sdr_cap)
 646                         set_bit(_IOC_NR(VIDIOC_ENUM_FMT), valid_ioctls);
 647                 if (ops->vidioc_g_fmt_sdr_cap)
 648                         set_bit(_IOC_NR(VIDIOC_G_FMT), valid_ioctls);
 649                 if (ops->vidioc_s_fmt_sdr_cap)
 650                         set_bit(_IOC_NR(VIDIOC_S_FMT), valid_ioctls);
 651                 if (ops->vidioc_try_fmt_sdr_cap)
 652                         set_bit(_IOC_NR(VIDIOC_TRY_FMT), valid_ioctls);
 653         } else if (is_sdr && is_tx) {
 654                 /* SDR transmitter specific ioctls */
 655                 if (ops->vidioc_enum_fmt_sdr_out)
 656                         set_bit(_IOC_NR(VIDIOC_ENUM_FMT), valid_ioctls);
 657                 if (ops->vidioc_g_fmt_sdr_out)
 658                         set_bit(_IOC_NR(VIDIOC_G_FMT), valid_ioctls);
 659                 if (ops->vidioc_s_fmt_sdr_out)
 660                         set_bit(_IOC_NR(VIDIOC_S_FMT), valid_ioctls);
 661                 if (ops->vidioc_try_fmt_sdr_out)
 662                         set_bit(_IOC_NR(VIDIOC_TRY_FMT), valid_ioctls);
 663         }
 664
 665         if (is_vid || is_vbi || is_sdr) {
 666                 /* ioctls valid for video, vbi or sdr */
 667                 SET_VALID_IOCTL(ops, VIDIOC_REQBUFS, vidioc_reqbufs);
 668                 SET_VALID_IOCTL(ops, VIDIOC_QUERYBUF, vidioc_querybuf);
 669                 SET_VALID_IOCTL(ops, VIDIOC_QBUF, vidioc_qbuf);
 670                 SET_VALID_IOCTL(ops, VIDIOC_EXPBUF, vidioc_expbuf);
 671                 SET_VALID_IOCTL(ops, VIDIOC_DQBUF, vidioc_dqbuf);
 672                 SET_VALID_IOCTL(ops, VIDIOC_CREATE_BUFS, vidioc_create_bufs);
 673                 SET_VALID_IOCTL(ops, VIDIOC_PREPARE_BUF, vidioc_prepare_buf);
 674                 SET_VALID_IOCTL(ops, VIDIOC_STREAMON, vidioc_streamon);
 675                 SET_VALID_IOCTL(ops, VIDIOC_STREAMOFF, vidioc_streamoff);
 676         }
 677
 678         if (is_vid || is_vbi) {
 679                 /* ioctls valid for video or vbi */
 680                 if (ops->vidioc_s_std)
 681                         set_bit(_IOC_NR(VIDIOC_ENUMSTD), valid_ioctls);
 682                 SET_VALID_IOCTL(ops, VIDIOC_S_STD, vidioc_s_std);
 683                 SET_VALID_IOCTL(ops, VIDIOC_G_STD, vidioc_g_std);
 684                 if (is_rx) {
 685                         SET_VALID_IOCTL(ops, VIDIOC_QUERYSTD, vidioc_querystd);
 686                         SET_VALID_IOCTL(ops, VIDIOC_ENUMINPUT, vidioc_enum_input);
 687                         SET_VALID_IOCTL(ops, VIDIOC_G_INPUT, vidioc_g_input);
 688                         SET_VALID_IOCTL(ops, VIDIOC_S_INPUT, vidioc_s_input);
 689                         SET_VALID_IOCTL(ops, VIDIOC_ENUMAUDIO, vidioc_enumaudio);
 690                         SET_VALID_IOCTL(ops, VIDIOC_G_AUDIO, vidioc_g_audio);
 691                         SET_VALID_IOCTL(ops, VIDIOC_S_AUDIO, vidioc_s_audio);
 692                         SET_VALID_IOCTL(ops, VIDIOC_QUERY_DV_TIMINGS, vidioc_query_dv_timings);
 693                         SET_VALID_IOCTL(ops, VIDIOC_S_EDID, vidioc_s_edid);
 694                 }
 695                 if (is_tx) {
 696                         SET_VALID_IOCTL(ops, VIDIOC_ENUMOUTPUT, vidioc_enum_output);
 697                         SET_VALID_IOCTL(ops, VIDIOC_G_OUTPUT, vidioc_g_output);
 698                         SET_VALID_IOCTL(ops, VIDIOC_S_OUTPUT, vidioc_s_output);
 699                         SET_VALID_IOCTL(ops, VIDIOC_ENUMAUDOUT, vidioc_enumaudout);
 700                         SET_VALID_IOCTL(ops, VIDIOC_G_AUDOUT, vidioc_g_audout);
 701                         SET_VALID_IOCTL(ops, VIDIOC_S_AUDOUT, vidioc_s_audout);
 702                 }
 703                 if (ops->vidioc_g_parm || (vdev->vfl_type == VFL_TYPE_GRABBER &&
 704                                         ops->vidioc_g_std))
 705                         set_bit(_IOC_NR(VIDIOC_G_PARM), valid_ioctls);
 706                 SET_VALID_IOCTL(ops, VIDIOC_S_PARM, vidioc_s_parm);
 707                 SET_VALID_IOCTL(ops, VIDIOC_S_DV_TIMINGS, vidioc_s_dv_timings);
 708                 SET_VALID_IOCTL(ops, VIDIOC_G_DV_TIMINGS, vidioc_g_dv_timings);
 709                 SET_VALID_IOCTL(ops, VIDIOC_ENUM_DV_TIMINGS, vidioc_enum_dv_timings);
 710                 SET_VALID_IOCTL(ops, VIDIOC_DV_TIMINGS_CAP, vidioc_dv_timings_cap);
 711                 SET_VALID_IOCTL(ops, VIDIOC_G_EDID, vidioc_g_edid);
 712         }
 713         if (is_tx && (is_radio || is_sdr)) {
 714                 /* radio transmitter only ioctls */
 715                 SET_VALID_IOCTL(ops, VIDIOC_G_MODULATOR, vidioc_g_modulator);
 716                 SET_VALID_IOCTL(ops, VIDIOC_S_MODULATOR, vidioc_s_modulator);
 717         }
 718         if (is_rx) {
 719                 /* receiver only ioctls */
 720                 SET_VALID_IOCTL(ops, VIDIOC_G_TUNER, vidioc_g_tuner);
 721                 SET_VALID_IOCTL(ops, VIDIOC_S_TUNER, vidioc_s_tuner);
 722                 SET_VALID_IOCTL(ops, VIDIOC_S_HW_FREQ_SEEK, vidioc_s_hw_freq_seek);
 723         }
 724
 725         bitmap_andnot(vdev->valid_ioctls, valid_ioctls, vdev->valid_ioctls,
 726                         BASE_VIDIOC_PRIVATE);
 727 }
 728
 729 static int video_register_media_controller(struct video_device *vdev, int type)
 730 {
 731 #if defined(CONFIG_MEDIA_CONTROLLER)
 732         u32 intf_type;
 733         int ret;
 734
 735         if (!vdev->v4l2_dev->mdev)
 736                 return 0;
 737
 738         vdev->entity.function = MEDIA_ENT_F_UNKNOWN;
 739
 740         switch (type) {
 741         case VFL_TYPE_GRABBER:
 742                 intf_type = MEDIA_INTF_T_V4L_VIDEO;
 743                 vdev->entity.function = MEDIA_ENT_F_IO_V4L;
 744                 break;
 745         case VFL_TYPE_VBI:
 746                 intf_type = MEDIA_INTF_T_V4L_VBI;
 747                 vdev->entity.function = MEDIA_ENT_F_IO_VBI;
 748                 break;
 749         case VFL_TYPE_SDR:
 750                 intf_type = MEDIA_INTF_T_V4L_SWRADIO;
 751                 vdev->entity.function = MEDIA_ENT_F_IO_SWRADIO;
 752                 break;
 753         case VFL_TYPE_RADIO:
 754                 intf_type = MEDIA_INTF_T_V4L_RADIO;
 755                 /*
 756                  * Radio doesn't have an entity at the V4L2 side to represent
 757                  * radio input or output. Instead, the audio input/output goes
 758                  * via either physical wires or ALSA.
 759                  */
 760                 break;
 761         case VFL_TYPE_SUBDEV:
 762                 intf_type = MEDIA_INTF_T_V4L_SUBDEV;
 763                 /* Entity will be created via v4l2_device_register_subdev() */
 764                 break;
 765         default:
 766                 return 0;
 767         }
 768
 769         if (vdev->entity.function != MEDIA_ENT_F_UNKNOWN) {
 770                 vdev->entity.name = vdev->name;
 771
 772                 /* Needed just for backward compatibility with legacy MC API */
 773                 vdev->entity.info.dev.major = VIDEO_MAJOR;
 774                 vdev->entity.info.dev.minor = vdev->minor;
 775
 776                 ret = media_device_register_entity(vdev->v4l2_dev->mdev,
 777                                                    &vdev->entity);
 778                 if (ret < 0) {
 779                         printk(KERN_WARNING
 780                                 "%s: media_device_register_entity failed\n",
 781                                 __func__);
 782                         return ret;
 783                 }
 784         }
 785
 786         vdev->intf_devnode = media_devnode_create(vdev->v4l2_dev->mdev,
 787                                                   intf_type,
 788                                                   0, VIDEO_MAJOR,
 789                                                   vdev->minor);
 790         if (!vdev->intf_devnode) {
 791                 media_device_unregister_entity(&vdev->entity);
 792                 return -ENOMEM;
 793         }
 794
 795         if (vdev->entity.function != MEDIA_ENT_F_UNKNOWN) {
 796                 struct media_link *link;
 797
 798                 link = media_create_intf_link(&vdev->entity,
 799                                               &vdev->intf_devnode->intf,
 800                                               MEDIA_LNK_FL_ENABLED);
 801                 if (!link) {
 802                         media_devnode_remove(vdev->intf_devnode);
 803                         media_device_unregister_entity(&vdev->entity);
 804                         return -ENOMEM;
 805                 }
 806         }
 807
 808         /* FIXME: how to create the other interface links? */
 809
 810 #endif
 811         return 0;
 812 }
 813
 814 /**
 815  *      __video_register_device - register video4linux devices
 816  *      @vdev: video device structure we want to register
 817  *      @type: type of device to register
 818  *      @nr:   which device node number (0 == /dev/video0, 1 == /dev/video1, ...
 819  *             -1 == first free)
 820  *      @warn_if_nr_in_use: warn if the desired device node number
 821  *             was already in use and another number was chosen instead.
 822  *      @owner: module that owns the video device node
 823  *
 824  *      The registration code assigns minor numbers and device node numbers
 825  *      based on the requested type and registers the new device node with
 826  *      the kernel.
 827  *
 828  *      This function assumes that struct video_device was zeroed when it
 829  *      was allocated and does not contain any stale date.
 830  *
 831  *      An error is returned if no free minor or device node number could be
 832  *      found, or if the registration of the device node failed.
 833  *
 834  *      Zero is returned on success.
 835  *
 836  *      Valid types are
 837  *
 838  *      %VFL_TYPE_GRABBER - A frame grabber
 839  *
 840  *      %VFL_TYPE_VBI - Vertical blank data (undecoded)
 841  *
 842  *      %VFL_TYPE_RADIO - A radio card
 843  *
 844  *      %VFL_TYPE_SUBDEV - A subdevice
 845  *
 846  *      %VFL_TYPE_SDR - Software Defined Radio
 847  */
 848 int __video_register_device(struct video_device *vdev, int type, int nr,
 849                 int warn_if_nr_in_use, struct module *owner)
 850 {
 851         int i = 0;
 852         int ret;
 853         int minor_offset = 0;
 854         int minor_cnt = VIDEO_NUM_DEVICES;
 855         const char *name_base;
 856
 857         /* A minor value of -1 marks this video device as never
 858            having been registered */
 859         vdev->minor = -1;
 860
 861         /* the release callback MUST be present */
 862         if (WARN_ON(!vdev->release))
 863                 return -EINVAL;
 864         /* the v4l2_dev pointer MUST be present */
 865         if (WARN_ON(!vdev->v4l2_dev))
 866                 return -EINVAL;
 867
 868         /* v4l2_fh support */
 869         spin_lock_init(&vdev->fh_lock);
 870         INIT_LIST_HEAD(&vdev->fh_list);
 871
 872         /* Part 1: check device type */
 873         switch (type) {
 874         case VFL_TYPE_GRABBER:
 875                 name_base = "video";
 876                 break;
 877         case VFL_TYPE_VBI:
 878                 name_base = "vbi";
 879                 break;
 880         case VFL_TYPE_RADIO:
 881                 name_base = "radio";
 882                 break;
 883         case VFL_TYPE_SUBDEV:
 884                 name_base = "v4l-subdev";
 885                 break;
 886         case VFL_TYPE_SDR:
 887                 /* Use device name 'swradio' because 'sdr' was already taken. */
 888                 name_base = "swradio";
 889                 break;
 890         default:
 891                 printk(KERN_ERR "%s called with unknown type: %d\n",
 892                        __func__, type);
 893                 return -EINVAL;
 894         }
 895
 896         vdev->vfl_type = type;
 897         vdev->cdev = NULL;
 898         if (vdev->dev_parent == NULL)
 899                 vdev->dev_parent = vdev->v4l2_dev->dev;
 900         if (vdev->ctrl_handler == NULL)
 901                 vdev->ctrl_handler = vdev->v4l2_dev->ctrl_handler;
 902         /* If the prio state pointer is NULL, then use the v4l2_device
 903            prio state. */
 904         if (vdev->prio == NULL)
 905                 vdev->prio = &vdev->v4l2_dev->prio;
 906
 907         /* Part 2: find a free minor, device node number and device index. */
 908 #ifdef CONFIG_VIDEO_FIXED_MINOR_RANGES
 909         /* Keep the ranges for the first four types for historical
 910          * reasons.
 911          * Newer devices (not yet in place) should use the range
 912          * of 128-191 and just pick the first free minor there
 913          * (new style). */
 914         switch (type) {
 915         case VFL_TYPE_GRABBER:
 916                 minor_offset = 0;
 917                 minor_cnt = 64;
 918                 break;
 919         case VFL_TYPE_RADIO:
 920                 minor_offset = 64;
 921                 minor_cnt = 64;
 922                 break;
 923         case VFL_TYPE_VBI:
 924                 minor_offset = 224;
 925                 minor_cnt = 32;
 926                 break;
 927         default:
 928                 minor_offset = 128;
 929                 minor_cnt = 64;
 930                 break;
 931         }
 932 #endif
 933
 934         /* Pick a device node number */
 935         mutex_lock(&videodev_lock);
 936         nr = devnode_find(vdev, nr == -1 ? 0 : nr, minor_cnt);
 937         if (nr == minor_cnt)
 938                 nr = devnode_find(vdev, 0, minor_cnt);
 939         if (nr == minor_cnt) {
 940                 printk(KERN_ERR "could not get a free device node number\n");
 941                 mutex_unlock(&videodev_lock);
 942                 return -ENFILE;
 943         }
 944 #ifdef CONFIG_VIDEO_FIXED_MINOR_RANGES
 945         /* 1-on-1 mapping of device node number to minor number */
 946         i = nr;
 947 #else
 948         /* The device node number and minor numbers are independent, so
 949            we just find the first free minor number. */
 950         for (i = 0; i < VIDEO_NUM_DEVICES; i++)
 951                 if (video_device[i] == NULL)
 952                         break;
 953         if (i == VIDEO_NUM_DEVICES) {
 954                 mutex_unlock(&videodev_lock);
 955                 printk(KERN_ERR "could not get a free minor\n");
 956                 return -ENFILE;
 957         }
 958 #endif
 959         vdev->minor = i + minor_offset;
 960         vdev->num = nr;
 961         devnode_set(vdev);
 962
 963         /* Should not happen since we thought this minor was free */
 964         WARN_ON(video_device[vdev->minor] != NULL);
 965         vdev->index = get_index(vdev);
 966         video_device[vdev->minor] = vdev;
 967         mutex_unlock(&videodev_lock);
 968
 969         if (vdev->ioctl_ops)
 970                 determine_valid_ioctls(vdev);
 971
 972         /* Part 3: Initialize the character device */
 973         vdev->cdev = cdev_alloc();
 974         if (vdev->cdev == NULL) {
 975                 ret = -ENOMEM;
 976                 goto cleanup;
 977         }
 978         vdev->cdev->ops = &v4l2_fops;
 979         vdev->cdev->owner = owner;
 980         ret = cdev_add(vdev->cdev, MKDEV(VIDEO_MAJOR, vdev->minor), 1);
 981         if (ret < 0) {
 982                 printk(KERN_ERR "%s: cdev_add failed\n", __func__);
 983                 kfree(vdev->cdev);
 984                 vdev->cdev = NULL;
 985                 goto cleanup;
 986         }
 987
 988         /* Part 4: register the device with sysfs */
 989         vdev->dev.class = &video_class;
 990         vdev->dev.devt = MKDEV(VIDEO_MAJOR, vdev->minor);
 991         vdev->dev.parent = vdev->dev_parent;
 992         dev_set_name(&vdev->dev, "%s%d", name_base, vdev->num);
 993         ret = device_register(&vdev->dev);
 994         if (ret < 0) {
 995                 printk(KERN_ERR "%s: device_register failed\n", __func__);
 996                 goto cleanup;
 997         }
 998         /* Register the release callback that will be called when the last
 999            reference to the device goes away. */
1000         vdev->dev.release = v4l2_device_release;
1001
1002         if (nr != -1 && nr != vdev->num && warn_if_nr_in_use)
1003                 printk(KERN_WARNING "%s: requested %s%d, got %s\n", __func__,
1004                         name_base, nr, video_device_node_name(vdev));
1005
1006         /* Increase v4l2_device refcount */
1007         v4l2_device_get(vdev->v4l2_dev);
1008
1009         /* Part 5: Register the entity. */
1010         ret = video_register_media_controller(vdev, type);
1011
1012         /* Part 6: Activate this minor. The char device can now be used. */
1013         set_bit(V4L2_FL_REGISTERED, &vdev->flags);
1014
1015         return 0;
1016
1017 cleanup:
1018         mutex_lock(&videodev_lock);
1019         if (vdev->cdev)
1020                 cdev_del(vdev->cdev);
1021         video_device[vdev->minor] = NULL;
1022         devnode_clear(vdev);
1023         mutex_unlock(&videodev_lock);
1024         /* Mark this video device as never having been registered. */
1025         vdev->minor = -1;
1026         return ret;
1027 }
1028 EXPORT_SYMBOL(__video_register_device);
1029
1030 /**
1031  *      video_unregister_device - unregister a video4linux device
1032  *      @vdev: the device to unregister
1033  *
1034  *      This unregisters the passed device. Future open calls will
1035  *      be met with errors.
1036  */
1037 void video_unregister_device(struct video_device *vdev)
1038 {
1039         /* Check if vdev was ever registered at all */
1040         if (!vdev || !video_is_registered(vdev))
1041                 return;
1042
1043         mutex_lock(&videodev_lock);
1044         /* This must be in a critical section to prevent a race with v4l2_open.
1045          * Once this bit has been cleared video_get may never be called again.
1046          */
1047         clear_bit(V4L2_FL_REGISTERED, &vdev->flags);
1048         mutex_unlock(&videodev_lock);
1049         device_unregister(&vdev->dev);
1050 }
1051 EXPORT_SYMBOL(video_unregister_device);
1052
1053 /*
1054  *      Initialise video for linux
1055  */
1056 static int __init videodev_init(void)
1057 {
1058         dev_t dev = MKDEV(VIDEO_MAJOR, 0);
1059         int ret;
1060
1061         printk(KERN_INFO "Linux video capture interface: v2.00\n");
1062         ret = register_chrdev_region(dev, VIDEO_NUM_DEVICES, VIDEO_NAME);
1063         if (ret < 0) {
1064                 printk(KERN_WARNING "videodev: unable to get major %d\n",
1065                                 VIDEO_MAJOR);
1066                 return ret;
1067         }
1068
1069         ret = class_register(&video_class);
1070         if (ret < 0) {
1071                 unregister_chrdev_region(dev, VIDEO_NUM_DEVICES);
1072                 printk(KERN_WARNING "video_dev: class_register failed\n");
1073                 return -EIO;
1074         }
1075
1076         return 0;
1077 }
1078
1079 static void __exit videodev_exit(void)
1080 {
1081         dev_t dev = MKDEV(VIDEO_MAJOR, 0);
1082
1083         class_unregister(&video_class);
1084         unregister_chrdev_region(dev, VIDEO_NUM_DEVICES);
1085 }
1086
1087 subsys_initcall(videodev_init);
1088 module_exit(videodev_exit)
1089
1090 MODULE_AUTHOR("Alan Cox, Mauro Carvalho Chehab <mchehab@infradead.org>");
1091 MODULE_DESCRIPTION("Device registrar for Video4Linux drivers v2");
1092 MODULE_LICENSE("GPL");
1093 MODULE_ALIAS_CHARDEV_MAJOR(VIDEO_MAJOR);