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