drivers/media/v4l2-core/v4l2-dev.c

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