Pileus Git - ~andy/linux/blob - 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->vfl_type == VFL_TYPE_GRABBER)
 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         SET_VALID_IOCTL(ops, VIDIOC_ENUM_DV_TIMINGS, vidioc_enum_dv_timings);
 683         SET_VALID_IOCTL(ops, VIDIOC_QUERY_DV_TIMINGS, vidioc_query_dv_timings);
 684         /* yes, really vidioc_subscribe_event */
 685         SET_VALID_IOCTL(ops, VIDIOC_DQEVENT, vidioc_subscribe_event);
 686         SET_VALID_IOCTL(ops, VIDIOC_SUBSCRIBE_EVENT, vidioc_subscribe_event);
 687         SET_VALID_IOCTL(ops, VIDIOC_UNSUBSCRIBE_EVENT, vidioc_unsubscribe_event);
 688         SET_VALID_IOCTL(ops, VIDIOC_CREATE_BUFS, vidioc_create_bufs);
 689         SET_VALID_IOCTL(ops, VIDIOC_PREPARE_BUF, vidioc_prepare_buf);
 690         bitmap_andnot(vdev->valid_ioctls, valid_ioctls, vdev->valid_ioctls,
 691                         BASE_VIDIOC_PRIVATE);
 692 }
 693
 694 /**
 695  *      __video_register_device - register video4linux devices
 696  *      @vdev: video device structure we want to register
 697  *      @type: type of device to register
 698  *      @nr:   which device node number (0 == /dev/video0, 1 == /dev/video1, ...
 699  *             -1 == first free)
 700  *      @warn_if_nr_in_use: warn if the desired device node number
 701  *             was already in use and another number was chosen instead.
 702  *      @owner: module that owns the video device node
 703  *
 704  *      The registration code assigns minor numbers and device node numbers
 705  *      based on the requested type and registers the new device node with
 706  *      the kernel.
 707  *
 708  *      This function assumes that struct video_device was zeroed when it
 709  *      was allocated and does not contain any stale date.
 710  *
 711  *      An error is returned if no free minor or device node number could be
 712  *      found, or if the registration of the device node failed.
 713  *
 714  *      Zero is returned on success.
 715  *
 716  *      Valid types are
 717  *
 718  *      %VFL_TYPE_GRABBER - A frame grabber
 719  *
 720  *      %VFL_TYPE_VBI - Vertical blank data (undecoded)
 721  *
 722  *      %VFL_TYPE_RADIO - A radio card
 723  *
 724  *      %VFL_TYPE_SUBDEV - A subdevice
 725  */
 726 int __video_register_device(struct video_device *vdev, int type, int nr,
 727                 int warn_if_nr_in_use, struct module *owner)
 728 {
 729         int i = 0;
 730         int ret;
 731         int minor_offset = 0;
 732         int minor_cnt = VIDEO_NUM_DEVICES;
 733         const char *name_base;
 734
 735         /* A minor value of -1 marks this video device as never
 736            having been registered */
 737         vdev->minor = -1;
 738
 739         /* the release callback MUST be present */
 740         if (WARN_ON(!vdev->release))
 741                 return -EINVAL;
 742
 743         /* v4l2_fh support */
 744         spin_lock_init(&vdev->fh_lock);
 745         INIT_LIST_HEAD(&vdev->fh_list);
 746
 747         /* Part 1: check device type */
 748         switch (type) {
 749         case VFL_TYPE_GRABBER:
 750                 name_base = "video";
 751                 break;
 752         case VFL_TYPE_VBI:
 753                 name_base = "vbi";
 754                 break;
 755         case VFL_TYPE_RADIO:
 756                 name_base = "radio";
 757                 break;
 758         case VFL_TYPE_SUBDEV:
 759                 name_base = "v4l-subdev";
 760                 break;
 761         default:
 762                 printk(KERN_ERR "%s called with unknown type: %d\n",
 763                        __func__, type);
 764                 return -EINVAL;
 765         }
 766
 767         vdev->vfl_type = type;
 768         vdev->cdev = NULL;
 769         if (vdev->v4l2_dev) {
 770                 if (vdev->v4l2_dev->dev)
 771                         vdev->parent = vdev->v4l2_dev->dev;
 772                 if (vdev->ctrl_handler == NULL)
 773                         vdev->ctrl_handler = vdev->v4l2_dev->ctrl_handler;
 774                 /* If the prio state pointer is NULL, then use the v4l2_device
 775                    prio state. */
 776                 if (vdev->prio == NULL)
 777                         vdev->prio = &vdev->v4l2_dev->prio;
 778         }
 779
 780         /* Part 2: find a free minor, device node number and device index. */
 781 #ifdef CONFIG_VIDEO_FIXED_MINOR_RANGES
 782         /* Keep the ranges for the first four types for historical
 783          * reasons.
 784          * Newer devices (not yet in place) should use the range
 785          * of 128-191 and just pick the first free minor there
 786          * (new style). */
 787         switch (type) {
 788         case VFL_TYPE_GRABBER:
 789                 minor_offset = 0;
 790                 minor_cnt = 64;
 791                 break;
 792         case VFL_TYPE_RADIO:
 793                 minor_offset = 64;
 794                 minor_cnt = 64;
 795                 break;
 796         case VFL_TYPE_VBI:
 797                 minor_offset = 224;
 798                 minor_cnt = 32;
 799                 break;
 800         default:
 801                 minor_offset = 128;
 802                 minor_cnt = 64;
 803                 break;
 804         }
 805 #endif
 806
 807         /* Pick a device node number */
 808         mutex_lock(&videodev_lock);
 809         nr = devnode_find(vdev, nr == -1 ? 0 : nr, minor_cnt);
 810         if (nr == minor_cnt)
 811                 nr = devnode_find(vdev, 0, minor_cnt);
 812         if (nr == minor_cnt) {
 813                 printk(KERN_ERR "could not get a free device node number\n");
 814                 mutex_unlock(&videodev_lock);
 815                 return -ENFILE;
 816         }
 817 #ifdef CONFIG_VIDEO_FIXED_MINOR_RANGES
 818         /* 1-on-1 mapping of device node number to minor number */
 819         i = nr;
 820 #else
 821         /* The device node number and minor numbers are independent, so
 822            we just find the first free minor number. */
 823         for (i = 0; i < VIDEO_NUM_DEVICES; i++)
 824                 if (video_device[i] == NULL)
 825                         break;
 826         if (i == VIDEO_NUM_DEVICES) {
 827                 mutex_unlock(&videodev_lock);
 828                 printk(KERN_ERR "could not get a free minor\n");
 829                 return -ENFILE;
 830         }
 831 #endif
 832         vdev->minor = i + minor_offset;
 833         vdev->num = nr;
 834         devnode_set(vdev);
 835
 836         /* Should not happen since we thought this minor was free */
 837         WARN_ON(video_device[vdev->minor] != NULL);
 838         vdev->index = get_index(vdev);
 839         mutex_unlock(&videodev_lock);
 840         /* if no lock was passed, then make sure the LOCK_ALL_FOPS bit is
 841            clear and warn if it wasn't. */
 842         if (vdev->lock == NULL)
 843                 WARN_ON(test_and_clear_bit(V4L2_FL_LOCK_ALL_FOPS, &vdev->flags));
 844
 845         if (vdev->ioctl_ops)
 846                 determine_valid_ioctls(vdev);
 847
 848         /* Part 3: Initialize the character device */
 849         vdev->cdev = cdev_alloc();
 850         if (vdev->cdev == NULL) {
 851                 ret = -ENOMEM;
 852                 goto cleanup;
 853         }
 854         vdev->cdev->ops = &v4l2_fops;
 855         vdev->cdev->owner = owner;
 856         ret = cdev_add(vdev->cdev, MKDEV(VIDEO_MAJOR, vdev->minor), 1);
 857         if (ret < 0) {
 858                 printk(KERN_ERR "%s: cdev_add failed\n", __func__);
 859                 kfree(vdev->cdev);
 860                 vdev->cdev = NULL;
 861                 goto cleanup;
 862         }
 863
 864         /* Part 4: register the device with sysfs */
 865         vdev->dev.class = &video_class;
 866         vdev->dev.devt = MKDEV(VIDEO_MAJOR, vdev->minor);
 867         if (vdev->parent)
 868                 vdev->dev.parent = vdev->parent;
 869         dev_set_name(&vdev->dev, "%s%d", name_base, vdev->num);
 870         ret = device_register(&vdev->dev);
 871         if (ret < 0) {
 872                 printk(KERN_ERR "%s: device_register failed\n", __func__);
 873                 goto cleanup;
 874         }
 875         /* Register the release callback that will be called when the last
 876            reference to the device goes away. */
 877         vdev->dev.release = v4l2_device_release;
 878
 879         if (nr != -1 && nr != vdev->num && warn_if_nr_in_use)
 880                 printk(KERN_WARNING "%s: requested %s%d, got %s\n", __func__,
 881                         name_base, nr, video_device_node_name(vdev));
 882
 883         /* Increase v4l2_device refcount */
 884         if (vdev->v4l2_dev)
 885                 v4l2_device_get(vdev->v4l2_dev);
 886
 887 #if defined(CONFIG_MEDIA_CONTROLLER)
 888         /* Part 5: Register the entity. */
 889         if (vdev->v4l2_dev && vdev->v4l2_dev->mdev &&
 890             vdev->vfl_type != VFL_TYPE_SUBDEV) {
 891                 vdev->entity.type = MEDIA_ENT_T_DEVNODE_V4L;
 892                 vdev->entity.name = vdev->name;
 893                 vdev->entity.info.v4l.major = VIDEO_MAJOR;
 894                 vdev->entity.info.v4l.minor = vdev->minor;
 895                 ret = media_device_register_entity(vdev->v4l2_dev->mdev,
 896                         &vdev->entity);
 897                 if (ret < 0)
 898                         printk(KERN_WARNING
 899                                "%s: media_device_register_entity failed\n",
 900                                __func__);
 901         }
 902 #endif
 903         /* Part 6: Activate this minor. The char device can now be used. */
 904         set_bit(V4L2_FL_REGISTERED, &vdev->flags);
 905         mutex_lock(&videodev_lock);
 906         video_device[vdev->minor] = vdev;
 907         mutex_unlock(&videodev_lock);
 908
 909         return 0;
 910
 911 cleanup:
 912         mutex_lock(&videodev_lock);
 913         if (vdev->cdev)
 914                 cdev_del(vdev->cdev);
 915         devnode_clear(vdev);
 916         mutex_unlock(&videodev_lock);
 917         /* Mark this video device as never having been registered. */
 918         vdev->minor = -1;
 919         return ret;
 920 }
 921 EXPORT_SYMBOL(__video_register_device);
 922
 923 /**
 924  *      video_unregister_device - unregister a video4linux device
 925  *      @vdev: the device to unregister
 926  *
 927  *      This unregisters the passed device. Future open calls will
 928  *      be met with errors.
 929  */
 930 void video_unregister_device(struct video_device *vdev)
 931 {
 932         /* Check if vdev was ever registered at all */
 933         if (!vdev || !video_is_registered(vdev))
 934                 return;
 935
 936         mutex_lock(&videodev_lock);
 937         /* This must be in a critical section to prevent a race with v4l2_open.
 938          * Once this bit has been cleared video_get may never be called again.
 939          */
 940         clear_bit(V4L2_FL_REGISTERED, &vdev->flags);
 941         mutex_unlock(&videodev_lock);
 942         device_unregister(&vdev->dev);
 943 }
 944 EXPORT_SYMBOL(video_unregister_device);
 945
 946 /*
 947  *      Initialise video for linux
 948  */
 949 static int __init videodev_init(void)
 950 {
 951         dev_t dev = MKDEV(VIDEO_MAJOR, 0);
 952         int ret;
 953
 954         printk(KERN_INFO "Linux video capture interface: v2.00\n");
 955         ret = register_chrdev_region(dev, VIDEO_NUM_DEVICES, VIDEO_NAME);
 956         if (ret < 0) {
 957                 printk(KERN_WARNING "videodev: unable to get major %d\n",
 958                                 VIDEO_MAJOR);
 959                 return ret;
 960         }
 961
 962         ret = class_register(&video_class);
 963         if (ret < 0) {
 964                 unregister_chrdev_region(dev, VIDEO_NUM_DEVICES);
 965                 printk(KERN_WARNING "video_dev: class_register failed\n");
 966                 return -EIO;
 967         }
 968
 969         return 0;
 970 }
 971
 972 static void __exit videodev_exit(void)
 973 {
 974         dev_t dev = MKDEV(VIDEO_MAJOR, 0);
 975
 976         class_unregister(&video_class);
 977         unregister_chrdev_region(dev, VIDEO_NUM_DEVICES);
 978 }
 979
 980 subsys_initcall(videodev_init);
 981 module_exit(videodev_exit)
 982
 983 MODULE_AUTHOR("Alan Cox, Mauro Carvalho Chehab <mchehab@infradead.org>");
 984 MODULE_DESCRIPTION("Device registrar for Video4Linux drivers v2");
 985 MODULE_LICENSE("GPL");
 986 MODULE_ALIAS_CHARDEV_MAJOR(VIDEO_MAJOR);
 987
 988
 989 /*
 990  * Local variables:
 991  * c-basic-offset: 8
 992  * End:
 993  */