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