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