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

   1 // SPDX-License-Identifier: GPL-2.0-or-later
   2 /*
   3  * Video capture interface for Linux version 2
   4  *
   5  *      A generic video device interface for the LINUX operating system
   6  *      using a set of device structures/vectors for low level operations.
   7  *
   8  * Authors:     Alan Cox, <[email protected]> (version 1)
   9  *              Mauro Carvalho Chehab <[email protected]> (version 2)
  10  *
  11  * Fixes:       20000516  Claudio Matsuoka <[email protected]>
  12  *              - Added procfs support
  13  */
  14
  15 #define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
  16
  17 #include <linux/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
  42 static struct dentry *v4l2_debugfs_dir;
  43
  44 /*
  45  *      sysfs stuff
  46  */
  47
  48 static 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 }
  55 static DEVICE_ATTR_RO(index);
  56
  57 static 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
  65 static 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 }
  79 static DEVICE_ATTR_RW(dev_debug);
  80
  81 static 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 }
  88 static DEVICE_ATTR_RO(name);
  89
  90 static struct attribute *video_device_attrs[] = {
  91         &dev_attr_name.attr,
  92         &dev_attr_dev_debug.attr,
  93         &dev_attr_index.attr,
  94         NULL,
  95 };
  96 ATTRIBUTE_GROUPS(video_device);
  97
  98 /*
  99  *      Active devices
 100  */
 101 static struct video_device *video_devices[VIDEO_NUM_DEVICES];
 102 static DEFINE_MUTEX(videodev_lock);
 103 static 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. */
 112 static 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. */
 123 static 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 */
 130 static 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 */
 136 static 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> */
 142 static 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
 147 struct video_device *video_device_alloc(void)
 148 {
 149         return kzalloc(sizeof(struct video_device), GFP_KERNEL);
 150 }
 151 EXPORT_SYMBOL(video_device_alloc);
 152
 153 void video_device_release(struct video_device *vdev)
 154 {
 155         kfree(vdev);
 156 }
 157 EXPORT_SYMBOL(video_device_release);
 158
 159 void video_device_release_empty(struct video_device *vdev)
 160 {
 161         /* Do nothing */
 162         /* Only valid when the video_device struct is a static. */
 163 }
 164 EXPORT_SYMBOL(video_device_release_empty);
 165
 166 static inline void video_get(struct video_device *vdev)
 167 {
 168         get_device(&vdev->dev);
 169 }
 170
 171 static 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. */
 177 static 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
 232 static struct class video_class = {
 233         .name = VIDEO_NAME,
 234         .dev_groups = video_device_groups,
 235 };
 236
 237 struct video_device *video_devdata(struct file *file)
 238 {
 239         return video_devices[iminor(file_inode(file))];
 240 }
 241 EXPORT_SYMBOL(video_devdata);
 242
 243
 244 /* Priority handling */
 245
 246 static 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
 253 void v4l2_prio_init(struct v4l2_prio_state *global)
 254 {
 255         memset(global, 0, sizeof(*global));
 256 }
 257 EXPORT_SYMBOL(v4l2_prio_init);
 258
 259 int 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 }
 273 EXPORT_SYMBOL(v4l2_prio_change);
 274
 275 void v4l2_prio_open(struct v4l2_prio_state *global, enum v4l2_priority *local)
 276 {
 277         v4l2_prio_change(global, local, V4L2_PRIORITY_DEFAULT);
 278 }
 279 EXPORT_SYMBOL(v4l2_prio_open);
 280
 281 void 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 }
 286 EXPORT_SYMBOL(v4l2_prio_close);
 287
 288 enum 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 }
 298 EXPORT_SYMBOL(v4l2_prio_max);
 299
 300 int v4l2_prio_check(struct v4l2_prio_state *global, enum v4l2_priority local)
 301 {
 302         return (local < v4l2_prio_max(global)) ? -EBUSY : 0;
 303 }
 304 EXPORT_SYMBOL(v4l2_prio_check);
 305
 306
 307 static 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
 324 static 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
 341 static __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
 359 static 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
 376 static 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
 395 static 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 */
 411 static 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 */
 444 static 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
 475 static 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  */
 504 static 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  */
 540 static 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
 789 static 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
 882 int __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
1063 cleanup:
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 }
1074 EXPORT_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  */
1083 void 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 }
1099 EXPORT_SYMBOL(video_unregister_device);
1100
1101 /*
1102  *      Initialise video for linux
1103  */
1104 static 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
1129 static 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
1138 subsys_initcall(videodev_init);
1139 module_exit(videodev_exit)
1140
1141 MODULE_AUTHOR("Alan Cox, Mauro Carvalho Chehab <[email protected]>, Bill Dirks, Justin Schoeman, Gerd Knorr");
1142 MODULE_DESCRIPTION("Video4Linux2 core driver");
1143 MODULE_LICENSE("GPL");
1144 MODULE_ALIAS_CHARDEV_MAJOR(VIDEO_MAJOR);