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