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