drivers/media/v4l2-core/v4l2-dev.c

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