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, <alan@lxorguk.ukuu.org.uk> (version 1)
   9  *              Mauro Carvalho Chehab <mchehab@kernel.org> (version 2)
  10  *
  11  * Fixes:       20000516  Claudio Matsuoka <claudio@conectiva.com>
  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         const u32 vid_caps = V4L2_CAP_VIDEO_CAPTURE |
 537                              V4L2_CAP_VIDEO_CAPTURE_MPLANE |
 538                              V4L2_CAP_VIDEO_OUTPUT |
 539                              V4L2_CAP_VIDEO_OUTPUT_MPLANE |
 540                              V4L2_CAP_VIDEO_M2M | V4L2_CAP_VIDEO_M2M_MPLANE;
 541         const u32 meta_caps = V4L2_CAP_META_CAPTURE |
 542                               V4L2_CAP_META_OUTPUT;
 543         DECLARE_BITMAP(valid_ioctls, BASE_VIDIOC_PRIVATE);
 544         const struct v4l2_ioctl_ops *ops = vdev->ioctl_ops;
 545         bool is_vid = vdev->vfl_type == VFL_TYPE_GRABBER &&
 546                       (vdev->device_caps & vid_caps);
 547         bool is_vbi = vdev->vfl_type == VFL_TYPE_VBI;
 548         bool is_radio = vdev->vfl_type == VFL_TYPE_RADIO;
 549         bool is_sdr = vdev->vfl_type == VFL_TYPE_SDR;
 550         bool is_tch = vdev->vfl_type == VFL_TYPE_TOUCH;
 551         bool is_meta = vdev->vfl_type == VFL_TYPE_GRABBER &&
 552                        (vdev->device_caps & meta_caps);
 553         bool is_rx = vdev->vfl_dir != VFL_DIR_TX;
 554         bool is_tx = vdev->vfl_dir != VFL_DIR_RX;
 555
 556         bitmap_zero(valid_ioctls, BASE_VIDIOC_PRIVATE);
 557
 558         /* vfl_type and vfl_dir independent ioctls */
 559
 560         SET_VALID_IOCTL(ops, VIDIOC_QUERYCAP, vidioc_querycap);
 561         set_bit(_IOC_NR(VIDIOC_G_PRIORITY), valid_ioctls);
 562         set_bit(_IOC_NR(VIDIOC_S_PRIORITY), valid_ioctls);
 563
 564         /* Note: the control handler can also be passed through the filehandle,
 565            and that can't be tested here. If the bit for these control ioctls
 566            is set, then the ioctl is valid. But if it is 0, then it can still
 567            be valid if the filehandle passed the control handler. */
 568         if (vdev->ctrl_handler || ops->vidioc_queryctrl)
 569                 set_bit(_IOC_NR(VIDIOC_QUERYCTRL), valid_ioctls);
 570         if (vdev->ctrl_handler || ops->vidioc_query_ext_ctrl)
 571                 set_bit(_IOC_NR(VIDIOC_QUERY_EXT_CTRL), valid_ioctls);
 572         if (vdev->ctrl_handler || ops->vidioc_g_ctrl || ops->vidioc_g_ext_ctrls)
 573                 set_bit(_IOC_NR(VIDIOC_G_CTRL), valid_ioctls);
 574         if (vdev->ctrl_handler || ops->vidioc_s_ctrl || ops->vidioc_s_ext_ctrls)
 575                 set_bit(_IOC_NR(VIDIOC_S_CTRL), valid_ioctls);
 576         if (vdev->ctrl_handler || ops->vidioc_g_ext_ctrls)
 577                 set_bit(_IOC_NR(VIDIOC_G_EXT_CTRLS), valid_ioctls);
 578         if (vdev->ctrl_handler || ops->vidioc_s_ext_ctrls)
 579                 set_bit(_IOC_NR(VIDIOC_S_EXT_CTRLS), valid_ioctls);
 580         if (vdev->ctrl_handler || ops->vidioc_try_ext_ctrls)
 581                 set_bit(_IOC_NR(VIDIOC_TRY_EXT_CTRLS), valid_ioctls);
 582         if (vdev->ctrl_handler || ops->vidioc_querymenu)
 583                 set_bit(_IOC_NR(VIDIOC_QUERYMENU), valid_ioctls);
 584         if (!is_tch) {
 585                 SET_VALID_IOCTL(ops, VIDIOC_G_FREQUENCY, vidioc_g_frequency);
 586                 SET_VALID_IOCTL(ops, VIDIOC_S_FREQUENCY, vidioc_s_frequency);
 587         }
 588         SET_VALID_IOCTL(ops, VIDIOC_LOG_STATUS, vidioc_log_status);
 589 #ifdef CONFIG_VIDEO_ADV_DEBUG
 590         set_bit(_IOC_NR(VIDIOC_DBG_G_CHIP_INFO), valid_ioctls);
 591         set_bit(_IOC_NR(VIDIOC_DBG_G_REGISTER), valid_ioctls);
 592         set_bit(_IOC_NR(VIDIOC_DBG_S_REGISTER), valid_ioctls);
 593 #endif
 594         /* yes, really vidioc_subscribe_event */
 595         SET_VALID_IOCTL(ops, VIDIOC_DQEVENT, vidioc_subscribe_event);
 596         SET_VALID_IOCTL(ops, VIDIOC_SUBSCRIBE_EVENT, vidioc_subscribe_event);
 597         SET_VALID_IOCTL(ops, VIDIOC_UNSUBSCRIBE_EVENT, vidioc_unsubscribe_event);
 598         if (ops->vidioc_enum_freq_bands || ops->vidioc_g_tuner || ops->vidioc_g_modulator)
 599                 set_bit(_IOC_NR(VIDIOC_ENUM_FREQ_BANDS), valid_ioctls);
 600
 601         if (is_vid) {
 602                 /* video specific ioctls */
 603                 if ((is_rx && (ops->vidioc_enum_fmt_vid_cap ||
 604                                ops->vidioc_enum_fmt_vid_overlay)) ||
 605                     (is_tx && ops->vidioc_enum_fmt_vid_out))
 606                         set_bit(_IOC_NR(VIDIOC_ENUM_FMT), valid_ioctls);
 607                 if ((is_rx && (ops->vidioc_g_fmt_vid_cap ||
 608                                ops->vidioc_g_fmt_vid_cap_mplane ||
 609                                ops->vidioc_g_fmt_vid_overlay)) ||
 610                     (is_tx && (ops->vidioc_g_fmt_vid_out ||
 611                                ops->vidioc_g_fmt_vid_out_mplane ||
 612                                ops->vidioc_g_fmt_vid_out_overlay)))
 613                          set_bit(_IOC_NR(VIDIOC_G_FMT), valid_ioctls);
 614                 if ((is_rx && (ops->vidioc_s_fmt_vid_cap ||
 615                                ops->vidioc_s_fmt_vid_cap_mplane ||
 616                                ops->vidioc_s_fmt_vid_overlay)) ||
 617                     (is_tx && (ops->vidioc_s_fmt_vid_out ||
 618                                ops->vidioc_s_fmt_vid_out_mplane ||
 619                                ops->vidioc_s_fmt_vid_out_overlay)))
 620                          set_bit(_IOC_NR(VIDIOC_S_FMT), valid_ioctls);
 621                 if ((is_rx && (ops->vidioc_try_fmt_vid_cap ||
 622                                ops->vidioc_try_fmt_vid_cap_mplane ||
 623                                ops->vidioc_try_fmt_vid_overlay)) ||
 624                     (is_tx && (ops->vidioc_try_fmt_vid_out ||
 625                                ops->vidioc_try_fmt_vid_out_mplane ||
 626                                ops->vidioc_try_fmt_vid_out_overlay)))
 627                          set_bit(_IOC_NR(VIDIOC_TRY_FMT), valid_ioctls);
 628                 SET_VALID_IOCTL(ops, VIDIOC_OVERLAY, vidioc_overlay);
 629                 SET_VALID_IOCTL(ops, VIDIOC_G_FBUF, vidioc_g_fbuf);
 630                 SET_VALID_IOCTL(ops, VIDIOC_S_FBUF, vidioc_s_fbuf);
 631                 SET_VALID_IOCTL(ops, VIDIOC_G_JPEGCOMP, vidioc_g_jpegcomp);
 632                 SET_VALID_IOCTL(ops, VIDIOC_S_JPEGCOMP, vidioc_s_jpegcomp);
 633                 SET_VALID_IOCTL(ops, VIDIOC_G_ENC_INDEX, vidioc_g_enc_index);
 634                 SET_VALID_IOCTL(ops, VIDIOC_ENCODER_CMD, vidioc_encoder_cmd);
 635                 SET_VALID_IOCTL(ops, VIDIOC_TRY_ENCODER_CMD, vidioc_try_encoder_cmd);
 636                 SET_VALID_IOCTL(ops, VIDIOC_DECODER_CMD, vidioc_decoder_cmd);
 637                 SET_VALID_IOCTL(ops, VIDIOC_TRY_DECODER_CMD, vidioc_try_decoder_cmd);
 638                 SET_VALID_IOCTL(ops, VIDIOC_ENUM_FRAMESIZES, vidioc_enum_framesizes);
 639                 SET_VALID_IOCTL(ops, VIDIOC_ENUM_FRAMEINTERVALS, vidioc_enum_frameintervals);
 640                 if (ops->vidioc_g_selection) {
 641                         set_bit(_IOC_NR(VIDIOC_G_CROP), valid_ioctls);
 642                         set_bit(_IOC_NR(VIDIOC_CROPCAP), valid_ioctls);
 643                 }
 644                 if (ops->vidioc_s_selection)
 645                         set_bit(_IOC_NR(VIDIOC_S_CROP), valid_ioctls);
 646                 SET_VALID_IOCTL(ops, VIDIOC_G_SELECTION, vidioc_g_selection);
 647                 SET_VALID_IOCTL(ops, VIDIOC_S_SELECTION, vidioc_s_selection);
 648         }
 649         if (is_meta && is_rx) {
 650                 /* metadata capture specific ioctls */
 651                 SET_VALID_IOCTL(ops, VIDIOC_ENUM_FMT, vidioc_enum_fmt_meta_cap);
 652                 SET_VALID_IOCTL(ops, VIDIOC_G_FMT, vidioc_g_fmt_meta_cap);
 653                 SET_VALID_IOCTL(ops, VIDIOC_S_FMT, vidioc_s_fmt_meta_cap);
 654                 SET_VALID_IOCTL(ops, VIDIOC_TRY_FMT, vidioc_try_fmt_meta_cap);
 655         } else if (is_meta && is_tx) {
 656                 /* metadata output specific ioctls */
 657                 SET_VALID_IOCTL(ops, VIDIOC_ENUM_FMT, vidioc_enum_fmt_meta_out);
 658                 SET_VALID_IOCTL(ops, VIDIOC_G_FMT, vidioc_g_fmt_meta_out);
 659                 SET_VALID_IOCTL(ops, VIDIOC_S_FMT, vidioc_s_fmt_meta_out);
 660                 SET_VALID_IOCTL(ops, VIDIOC_TRY_FMT, vidioc_try_fmt_meta_out);
 661         }
 662         if (is_vbi) {
 663                 /* vbi specific ioctls */
 664                 if ((is_rx && (ops->vidioc_g_fmt_vbi_cap ||
 665                                ops->vidioc_g_fmt_sliced_vbi_cap)) ||
 666                     (is_tx && (ops->vidioc_g_fmt_vbi_out ||
 667                                ops->vidioc_g_fmt_sliced_vbi_out)))
 668                         set_bit(_IOC_NR(VIDIOC_G_FMT), valid_ioctls);
 669                 if ((is_rx && (ops->vidioc_s_fmt_vbi_cap ||
 670                                ops->vidioc_s_fmt_sliced_vbi_cap)) ||
 671                     (is_tx && (ops->vidioc_s_fmt_vbi_out ||
 672                                ops->vidioc_s_fmt_sliced_vbi_out)))
 673                         set_bit(_IOC_NR(VIDIOC_S_FMT), valid_ioctls);
 674                 if ((is_rx && (ops->vidioc_try_fmt_vbi_cap ||
 675                                ops->vidioc_try_fmt_sliced_vbi_cap)) ||
 676                     (is_tx && (ops->vidioc_try_fmt_vbi_out ||
 677                                ops->vidioc_try_fmt_sliced_vbi_out)))
 678                         set_bit(_IOC_NR(VIDIOC_TRY_FMT), valid_ioctls);
 679                 SET_VALID_IOCTL(ops, VIDIOC_G_SLICED_VBI_CAP, vidioc_g_sliced_vbi_cap);
 680         } else if (is_tch) {
 681                 /* touch specific ioctls */
 682                 SET_VALID_IOCTL(ops, VIDIOC_ENUM_FMT, vidioc_enum_fmt_vid_cap);
 683                 SET_VALID_IOCTL(ops, VIDIOC_G_FMT, vidioc_g_fmt_vid_cap);
 684                 SET_VALID_IOCTL(ops, VIDIOC_S_FMT, vidioc_s_fmt_vid_cap);
 685                 SET_VALID_IOCTL(ops, VIDIOC_TRY_FMT, vidioc_try_fmt_vid_cap);
 686                 SET_VALID_IOCTL(ops, VIDIOC_ENUM_FRAMESIZES, vidioc_enum_framesizes);
 687                 SET_VALID_IOCTL(ops, VIDIOC_ENUM_FRAMEINTERVALS, vidioc_enum_frameintervals);
 688                 SET_VALID_IOCTL(ops, VIDIOC_ENUMINPUT, vidioc_enum_input);
 689                 SET_VALID_IOCTL(ops, VIDIOC_G_INPUT, vidioc_g_input);
 690                 SET_VALID_IOCTL(ops, VIDIOC_S_INPUT, vidioc_s_input);
 691                 SET_VALID_IOCTL(ops, VIDIOC_G_PARM, vidioc_g_parm);
 692                 SET_VALID_IOCTL(ops, VIDIOC_S_PARM, vidioc_s_parm);
 693         } else if (is_sdr && is_rx) {
 694                 /* SDR receiver specific ioctls */
 695                 SET_VALID_IOCTL(ops, VIDIOC_ENUM_FMT, vidioc_enum_fmt_sdr_cap);
 696                 SET_VALID_IOCTL(ops, VIDIOC_G_FMT, vidioc_g_fmt_sdr_cap);
 697                 SET_VALID_IOCTL(ops, VIDIOC_S_FMT, vidioc_s_fmt_sdr_cap);
 698                 SET_VALID_IOCTL(ops, VIDIOC_TRY_FMT, vidioc_try_fmt_sdr_cap);
 699         } else if (is_sdr && is_tx) {
 700                 /* SDR transmitter specific ioctls */
 701                 SET_VALID_IOCTL(ops, VIDIOC_ENUM_FMT, vidioc_enum_fmt_sdr_out);
 702                 SET_VALID_IOCTL(ops, VIDIOC_G_FMT, vidioc_g_fmt_sdr_out);
 703                 SET_VALID_IOCTL(ops, VIDIOC_S_FMT, vidioc_s_fmt_sdr_out);
 704                 SET_VALID_IOCTL(ops, VIDIOC_TRY_FMT, vidioc_try_fmt_sdr_out);
 705         }
 706
 707         if (is_vid || is_vbi || is_sdr || is_tch || is_meta) {
 708                 /* ioctls valid for video, vbi, sdr, touch and metadata */
 709                 SET_VALID_IOCTL(ops, VIDIOC_REQBUFS, vidioc_reqbufs);
 710                 SET_VALID_IOCTL(ops, VIDIOC_QUERYBUF, vidioc_querybuf);
 711                 SET_VALID_IOCTL(ops, VIDIOC_QBUF, vidioc_qbuf);
 712                 SET_VALID_IOCTL(ops, VIDIOC_EXPBUF, vidioc_expbuf);
 713                 SET_VALID_IOCTL(ops, VIDIOC_DQBUF, vidioc_dqbuf);
 714                 SET_VALID_IOCTL(ops, VIDIOC_CREATE_BUFS, vidioc_create_bufs);
 715                 SET_VALID_IOCTL(ops, VIDIOC_PREPARE_BUF, vidioc_prepare_buf);
 716                 SET_VALID_IOCTL(ops, VIDIOC_STREAMON, vidioc_streamon);
 717                 SET_VALID_IOCTL(ops, VIDIOC_STREAMOFF, vidioc_streamoff);
 718         }
 719
 720         if (is_vid || is_vbi || is_meta) {
 721                 /* ioctls valid for video, vbi and metadata */
 722                 if (ops->vidioc_s_std)
 723                         set_bit(_IOC_NR(VIDIOC_ENUMSTD), valid_ioctls);
 724                 SET_VALID_IOCTL(ops, VIDIOC_S_STD, vidioc_s_std);
 725                 SET_VALID_IOCTL(ops, VIDIOC_G_STD, vidioc_g_std);
 726                 if (is_rx) {
 727                         SET_VALID_IOCTL(ops, VIDIOC_QUERYSTD, vidioc_querystd);
 728                         SET_VALID_IOCTL(ops, VIDIOC_ENUMINPUT, vidioc_enum_input);
 729                         SET_VALID_IOCTL(ops, VIDIOC_G_INPUT, vidioc_g_input);
 730                         SET_VALID_IOCTL(ops, VIDIOC_S_INPUT, vidioc_s_input);
 731                         SET_VALID_IOCTL(ops, VIDIOC_ENUMAUDIO, vidioc_enumaudio);
 732                         SET_VALID_IOCTL(ops, VIDIOC_G_AUDIO, vidioc_g_audio);
 733                         SET_VALID_IOCTL(ops, VIDIOC_S_AUDIO, vidioc_s_audio);
 734                         SET_VALID_IOCTL(ops, VIDIOC_QUERY_DV_TIMINGS, vidioc_query_dv_timings);
 735                         SET_VALID_IOCTL(ops, VIDIOC_S_EDID, vidioc_s_edid);
 736                 }
 737                 if (is_tx) {
 738                         SET_VALID_IOCTL(ops, VIDIOC_ENUMOUTPUT, vidioc_enum_output);
 739                         SET_VALID_IOCTL(ops, VIDIOC_G_OUTPUT, vidioc_g_output);
 740                         SET_VALID_IOCTL(ops, VIDIOC_S_OUTPUT, vidioc_s_output);
 741                         SET_VALID_IOCTL(ops, VIDIOC_ENUMAUDOUT, vidioc_enumaudout);
 742                         SET_VALID_IOCTL(ops, VIDIOC_G_AUDOUT, vidioc_g_audout);
 743                         SET_VALID_IOCTL(ops, VIDIOC_S_AUDOUT, vidioc_s_audout);
 744                 }
 745                 if (ops->vidioc_g_parm || ops->vidioc_g_std)
 746                         set_bit(_IOC_NR(VIDIOC_G_PARM), valid_ioctls);
 747                 SET_VALID_IOCTL(ops, VIDIOC_S_PARM, vidioc_s_parm);
 748                 SET_VALID_IOCTL(ops, VIDIOC_S_DV_TIMINGS, vidioc_s_dv_timings);
 749                 SET_VALID_IOCTL(ops, VIDIOC_G_DV_TIMINGS, vidioc_g_dv_timings);
 750                 SET_VALID_IOCTL(ops, VIDIOC_ENUM_DV_TIMINGS, vidioc_enum_dv_timings);
 751                 SET_VALID_IOCTL(ops, VIDIOC_DV_TIMINGS_CAP, vidioc_dv_timings_cap);
 752                 SET_VALID_IOCTL(ops, VIDIOC_G_EDID, vidioc_g_edid);
 753         }
 754         if (is_tx && (is_radio || is_sdr)) {
 755                 /* radio transmitter only ioctls */
 756                 SET_VALID_IOCTL(ops, VIDIOC_G_MODULATOR, vidioc_g_modulator);
 757                 SET_VALID_IOCTL(ops, VIDIOC_S_MODULATOR, vidioc_s_modulator);
 758         }
 759         if (is_rx && !is_tch) {
 760                 /* receiver only ioctls */
 761                 SET_VALID_IOCTL(ops, VIDIOC_G_TUNER, vidioc_g_tuner);
 762                 SET_VALID_IOCTL(ops, VIDIOC_S_TUNER, vidioc_s_tuner);
 763                 SET_VALID_IOCTL(ops, VIDIOC_S_HW_FREQ_SEEK, vidioc_s_hw_freq_seek);
 764         }
 765
 766         bitmap_andnot(vdev->valid_ioctls, valid_ioctls, vdev->valid_ioctls,
 767                         BASE_VIDIOC_PRIVATE);
 768 }
 769
 770 static int video_register_media_controller(struct video_device *vdev)
 771 {
 772 #if defined(CONFIG_MEDIA_CONTROLLER)
 773         u32 intf_type;
 774         int ret;
 775
 776         /* Memory-to-memory devices are more complex and use
 777          * their own function to register its mc entities.
 778          */
 779         if (!vdev->v4l2_dev->mdev || vdev->vfl_dir == VFL_DIR_M2M)
 780                 return 0;
 781
 782         vdev->entity.obj_type = MEDIA_ENTITY_TYPE_VIDEO_DEVICE;
 783         vdev->entity.function = MEDIA_ENT_F_UNKNOWN;
 784
 785         switch (vdev->vfl_type) {
 786         case VFL_TYPE_GRABBER:
 787                 intf_type = MEDIA_INTF_T_V4L_VIDEO;
 788                 vdev->entity.function = MEDIA_ENT_F_IO_V4L;
 789                 break;
 790         case VFL_TYPE_VBI:
 791                 intf_type = MEDIA_INTF_T_V4L_VBI;
 792                 vdev->entity.function = MEDIA_ENT_F_IO_VBI;
 793                 break;
 794         case VFL_TYPE_SDR:
 795                 intf_type = MEDIA_INTF_T_V4L_SWRADIO;
 796                 vdev->entity.function = MEDIA_ENT_F_IO_SWRADIO;
 797                 break;
 798         case VFL_TYPE_TOUCH:
 799                 intf_type = MEDIA_INTF_T_V4L_TOUCH;
 800                 vdev->entity.function = MEDIA_ENT_F_IO_V4L;
 801                 break;
 802         case VFL_TYPE_RADIO:
 803                 intf_type = MEDIA_INTF_T_V4L_RADIO;
 804                 /*
 805                  * Radio doesn't have an entity at the V4L2 side to represent
 806                  * radio input or output. Instead, the audio input/output goes
 807                  * via either physical wires or ALSA.
 808                  */
 809                 break;
 810         case VFL_TYPE_SUBDEV:
 811                 intf_type = MEDIA_INTF_T_V4L_SUBDEV;
 812                 /* Entity will be created via v4l2_device_register_subdev() */
 813                 break;
 814         default:
 815                 return 0;
 816         }
 817
 818         if (vdev->entity.function != MEDIA_ENT_F_UNKNOWN) {
 819                 vdev->entity.name = vdev->name;
 820
 821                 /* Needed just for backward compatibility with legacy MC API */
 822                 vdev->entity.info.dev.major = VIDEO_MAJOR;
 823                 vdev->entity.info.dev.minor = vdev->minor;
 824
 825                 ret = media_device_register_entity(vdev->v4l2_dev->mdev,
 826                                                    &vdev->entity);
 827                 if (ret < 0) {
 828                         pr_warn("%s: media_device_register_entity failed\n",
 829                                 __func__);
 830                         return ret;
 831                 }
 832         }
 833
 834         vdev->intf_devnode = media_devnode_create(vdev->v4l2_dev->mdev,
 835                                                   intf_type,
 836                                                   0, VIDEO_MAJOR,
 837                                                   vdev->minor);
 838         if (!vdev->intf_devnode) {
 839                 media_device_unregister_entity(&vdev->entity);
 840                 return -ENOMEM;
 841         }
 842
 843         if (vdev->entity.function != MEDIA_ENT_F_UNKNOWN) {
 844                 struct media_link *link;
 845
 846                 link = media_create_intf_link(&vdev->entity,
 847                                               &vdev->intf_devnode->intf,
 848                                               MEDIA_LNK_FL_ENABLED |
 849                                               MEDIA_LNK_FL_IMMUTABLE);
 850                 if (!link) {
 851                         media_devnode_remove(vdev->intf_devnode);
 852                         media_device_unregister_entity(&vdev->entity);
 853                         return -ENOMEM;
 854                 }
 855         }
 856
 857         /* FIXME: how to create the other interface links? */
 858
 859 #endif
 860         return 0;
 861 }
 862
 863 int __video_register_device(struct video_device *vdev,
 864                             enum vfl_devnode_type type,
 865                             int nr, int warn_if_nr_in_use,
 866                             struct module *owner)
 867 {
 868         int i = 0;
 869         int ret;
 870         int minor_offset = 0;
 871         int minor_cnt = VIDEO_NUM_DEVICES;
 872         const char *name_base;
 873
 874         /* A minor value of -1 marks this video device as never
 875            having been registered */
 876         vdev->minor = -1;
 877
 878         /* the release callback MUST be present */
 879         if (WARN_ON(!vdev->release))
 880                 return -EINVAL;
 881         /* the v4l2_dev pointer MUST be present */
 882         if (WARN_ON(!vdev->v4l2_dev))
 883                 return -EINVAL;
 884         /* the device_caps field MUST be set for all but subdevs */
 885         if (WARN_ON(type != VFL_TYPE_SUBDEV && !vdev->device_caps))
 886                 return -EINVAL;
 887
 888         /* v4l2_fh support */
 889         spin_lock_init(&vdev->fh_lock);
 890         INIT_LIST_HEAD(&vdev->fh_list);
 891
 892         /* Part 1: check device type */
 893         switch (type) {
 894         case VFL_TYPE_GRABBER:
 895                 name_base = "video";
 896                 break;
 897         case VFL_TYPE_VBI:
 898                 name_base = "vbi";
 899                 break;
 900         case VFL_TYPE_RADIO:
 901                 name_base = "radio";
 902                 break;
 903         case VFL_TYPE_SUBDEV:
 904                 name_base = "v4l-subdev";
 905                 break;
 906         case VFL_TYPE_SDR:
 907                 /* Use device name 'swradio' because 'sdr' was already taken. */
 908                 name_base = "swradio";
 909                 break;
 910         case VFL_TYPE_TOUCH:
 911                 name_base = "v4l-touch";
 912                 break;
 913         default:
 914                 pr_err("%s called with unknown type: %d\n",
 915                        __func__, type);
 916                 return -EINVAL;
 917         }
 918
 919         vdev->vfl_type = type;
 920         vdev->cdev = NULL;
 921         if (vdev->dev_parent == NULL)
 922                 vdev->dev_parent = vdev->v4l2_dev->dev;
 923         if (vdev->ctrl_handler == NULL)
 924                 vdev->ctrl_handler = vdev->v4l2_dev->ctrl_handler;
 925         /* If the prio state pointer is NULL, then use the v4l2_device
 926            prio state. */
 927         if (vdev->prio == NULL)
 928                 vdev->prio = &vdev->v4l2_dev->prio;
 929
 930         /* Part 2: find a free minor, device node number and device index. */
 931 #ifdef CONFIG_VIDEO_FIXED_MINOR_RANGES
 932         /* Keep the ranges for the first four types for historical
 933          * reasons.
 934          * Newer devices (not yet in place) should use the range
 935          * of 128-191 and just pick the first free minor there
 936          * (new style). */
 937         switch (type) {
 938         case VFL_TYPE_GRABBER:
 939                 minor_offset = 0;
 940                 minor_cnt = 64;
 941                 break;
 942         case VFL_TYPE_RADIO:
 943                 minor_offset = 64;
 944                 minor_cnt = 64;
 945                 break;
 946         case VFL_TYPE_VBI:
 947                 minor_offset = 224;
 948                 minor_cnt = 32;
 949                 break;
 950         default:
 951                 minor_offset = 128;
 952                 minor_cnt = 64;
 953                 break;
 954         }
 955 #endif
 956
 957         /* Pick a device node number */
 958         mutex_lock(&videodev_lock);
 959         nr = devnode_find(vdev, nr == -1 ? 0 : nr, minor_cnt);
 960         if (nr == minor_cnt)
 961                 nr = devnode_find(vdev, 0, minor_cnt);
 962         if (nr == minor_cnt) {
 963                 pr_err("could not get a free device node number\n");
 964                 mutex_unlock(&videodev_lock);
 965                 return -ENFILE;
 966         }
 967 #ifdef CONFIG_VIDEO_FIXED_MINOR_RANGES
 968         /* 1-on-1 mapping of device node number to minor number */
 969         i = nr;
 970 #else
 971         /* The device node number and minor numbers are independent, so
 972            we just find the first free minor number. */
 973         for (i = 0; i < VIDEO_NUM_DEVICES; i++)
 974                 if (video_devices[i] == NULL)
 975                         break;
 976         if (i == VIDEO_NUM_DEVICES) {
 977                 mutex_unlock(&videodev_lock);
 978                 pr_err("could not get a free minor\n");
 979                 return -ENFILE;
 980         }
 981 #endif
 982         vdev->minor = i + minor_offset;
 983         vdev->num = nr;
 984
 985         /* Should not happen since we thought this minor was free */
 986         if (WARN_ON(video_devices[vdev->minor])) {
 987                 mutex_unlock(&videodev_lock);
 988                 pr_err("video_device not empty!\n");
 989                 return -ENFILE;
 990         }
 991         devnode_set(vdev);
 992         vdev->index = get_index(vdev);
 993         video_devices[vdev->minor] = vdev;
 994         mutex_unlock(&videodev_lock);
 995
 996         if (vdev->ioctl_ops)
 997                 determine_valid_ioctls(vdev);
 998
 999         /* Part 3: Initialize the character device */
1000         vdev->cdev = cdev_alloc();
1001         if (vdev->cdev == NULL) {
1002                 ret = -ENOMEM;
1003                 goto cleanup;
1004         }
1005         vdev->cdev->ops = &v4l2_fops;
1006         vdev->cdev->owner = owner;
1007         ret = cdev_add(vdev->cdev, MKDEV(VIDEO_MAJOR, vdev->minor), 1);
1008         if (ret < 0) {
1009                 pr_err("%s: cdev_add failed\n", __func__);
1010                 kfree(vdev->cdev);
1011                 vdev->cdev = NULL;
1012                 goto cleanup;
1013         }
1014
1015         /* Part 4: register the device with sysfs */
1016         vdev->dev.class = &video_class;
1017         vdev->dev.devt = MKDEV(VIDEO_MAJOR, vdev->minor);
1018         vdev->dev.parent = vdev->dev_parent;
1019         dev_set_name(&vdev->dev, "%s%d", name_base, vdev->num);
1020         ret = device_register(&vdev->dev);
1021         if (ret < 0) {
1022                 pr_err("%s: device_register failed\n", __func__);
1023                 goto cleanup;
1024         }
1025         /* Register the release callback that will be called when the last
1026            reference to the device goes away. */
1027         vdev->dev.release = v4l2_device_release;
1028
1029         if (nr != -1 && nr != vdev->num && warn_if_nr_in_use)
1030                 pr_warn("%s: requested %s%d, got %s\n", __func__,
1031                         name_base, nr, video_device_node_name(vdev));
1032
1033         /* Increase v4l2_device refcount */
1034         v4l2_device_get(vdev->v4l2_dev);
1035
1036         /* Part 5: Register the entity. */
1037         ret = video_register_media_controller(vdev);
1038
1039         /* Part 6: Activate this minor. The char device can now be used. */
1040         set_bit(V4L2_FL_REGISTERED, &vdev->flags);
1041
1042         return 0;
1043
1044 cleanup:
1045         mutex_lock(&videodev_lock);
1046         if (vdev->cdev)
1047                 cdev_del(vdev->cdev);
1048         video_devices[vdev->minor] = NULL;
1049         devnode_clear(vdev);
1050         mutex_unlock(&videodev_lock);
1051         /* Mark this video device as never having been registered. */
1052         vdev->minor = -1;
1053         return ret;
1054 }
1055 EXPORT_SYMBOL(__video_register_device);
1056
1057 /**
1058  *      video_unregister_device - unregister a video4linux device
1059  *      @vdev: the device to unregister
1060  *
1061  *      This unregisters the passed device. Future open calls will
1062  *      be met with errors.
1063  */
1064 void video_unregister_device(struct video_device *vdev)
1065 {
1066         /* Check if vdev was ever registered at all */
1067         if (!vdev || !video_is_registered(vdev))
1068                 return;
1069
1070         mutex_lock(&videodev_lock);
1071         /* This must be in a critical section to prevent a race with v4l2_open.
1072          * Once this bit has been cleared video_get may never be called again.
1073          */
1074         clear_bit(V4L2_FL_REGISTERED, &vdev->flags);
1075         mutex_unlock(&videodev_lock);
1076         device_unregister(&vdev->dev);
1077 }
1078 EXPORT_SYMBOL(video_unregister_device);
1079
1080 /*
1081  *      Initialise video for linux
1082  */
1083 static int __init videodev_init(void)
1084 {
1085         dev_t dev = MKDEV(VIDEO_MAJOR, 0);
1086         int ret;
1087
1088         pr_info("Linux video capture interface: v2.00\n");
1089         ret = register_chrdev_region(dev, VIDEO_NUM_DEVICES, VIDEO_NAME);
1090         if (ret < 0) {
1091                 pr_warn("videodev: unable to get major %d\n",
1092                                 VIDEO_MAJOR);
1093                 return ret;
1094         }
1095
1096         ret = class_register(&video_class);
1097         if (ret < 0) {
1098                 unregister_chrdev_region(dev, VIDEO_NUM_DEVICES);
1099                 pr_warn("video_dev: class_register failed\n");
1100                 return -EIO;
1101         }
1102
1103         return 0;
1104 }
1105
1106 static void __exit videodev_exit(void)
1107 {
1108         dev_t dev = MKDEV(VIDEO_MAJOR, 0);
1109
1110         class_unregister(&video_class);
1111         unregister_chrdev_region(dev, VIDEO_NUM_DEVICES);
1112 }
1113
1114 subsys_initcall(videodev_init);
1115 module_exit(videodev_exit)
1116
1117 MODULE_AUTHOR("Alan Cox, Mauro Carvalho Chehab <mchehab@kernel.org>, Bill Dirks, Justin Schoeman, Gerd Knorr");
1118 MODULE_DESCRIPTION("Video4Linux2 core driver");
1119 MODULE_LICENSE("GPL");
1120 MODULE_ALIAS_CHARDEV_MAJOR(VIDEO_MAJOR);