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