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