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