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