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

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