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_inode(file))]; 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 v4l2_dev 499 * @vdev: video_device to assign index number to, vdev->v4l2_dev 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 bitmap_zero(used, VIDEO_NUM_DEVICES); 518 519 for (i = 0; i < VIDEO_NUM_DEVICES; i++) { 520 if (video_device[i] != NULL && 521 video_device[i]->v4l2_dev == vdev->v4l2_dev) { 522 set_bit(video_device[i]->index, used); 523 } 524 } 525 526 return find_first_zero_bit(used, VIDEO_NUM_DEVICES); 527 } 528 529 #define SET_VALID_IOCTL(ops, cmd, op) \ 530 if (ops->op) \ 531 set_bit(_IOC_NR(cmd), valid_ioctls) 532 533 /* This determines which ioctls are actually implemented in the driver. 534 It's a one-time thing which simplifies video_ioctl2 as it can just do 535 a bit test. 536 537 Note that drivers can override this by setting bits to 1 in 538 vdev->valid_ioctls. If an ioctl is marked as 1 when this function is 539 called, then that ioctl will actually be marked as unimplemented. 540 541 It does that by first setting up the local valid_ioctls bitmap, and 542 at the end do a: 543 544 vdev->valid_ioctls = valid_ioctls & ~(vdev->valid_ioctls) 545 */ 546 static void determine_valid_ioctls(struct video_device *vdev) 547 { 548 DECLARE_BITMAP(valid_ioctls, BASE_VIDIOC_PRIVATE); 549 const struct v4l2_ioctl_ops *ops = vdev->ioctl_ops; 550 bool is_vid = vdev->vfl_type == VFL_TYPE_GRABBER; 551 bool is_vbi = vdev->vfl_type == VFL_TYPE_VBI; 552 bool is_radio = vdev->vfl_type == VFL_TYPE_RADIO; 553 bool is_rx = vdev->vfl_dir != VFL_DIR_TX; 554 bool is_tx = vdev->vfl_dir != VFL_DIR_RX; 555 556 bitmap_zero(valid_ioctls, BASE_VIDIOC_PRIVATE); 557 558 /* vfl_type and vfl_dir independent ioctls */ 559 560 SET_VALID_IOCTL(ops, VIDIOC_QUERYCAP, vidioc_querycap); 561 if (ops->vidioc_g_priority || 562 test_bit(V4L2_FL_USE_FH_PRIO, &vdev->flags)) 563 set_bit(_IOC_NR(VIDIOC_G_PRIORITY), valid_ioctls); 564 if (ops->vidioc_s_priority || 565 test_bit(V4L2_FL_USE_FH_PRIO, &vdev->flags)) 566 set_bit(_IOC_NR(VIDIOC_S_PRIORITY), valid_ioctls); 567 SET_VALID_IOCTL(ops, VIDIOC_STREAMON, vidioc_streamon); 568 SET_VALID_IOCTL(ops, VIDIOC_STREAMOFF, vidioc_streamoff); 569 /* Note: the control handler can also be passed through the filehandle, 570 and that can't be tested here. If the bit for these control ioctls 571 is set, then the ioctl is valid. But if it is 0, then it can still 572 be valid if the filehandle passed the control handler. */ 573 if (vdev->ctrl_handler || ops->vidioc_queryctrl) 574 set_bit(_IOC_NR(VIDIOC_QUERYCTRL), 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 } 662 if (!is_radio) { 663 /* ioctls valid for video or vbi */ 664 SET_VALID_IOCTL(ops, VIDIOC_REQBUFS, vidioc_reqbufs); 665 SET_VALID_IOCTL(ops, VIDIOC_QUERYBUF, vidioc_querybuf); 666 SET_VALID_IOCTL(ops, VIDIOC_QBUF, vidioc_qbuf); 667 SET_VALID_IOCTL(ops, VIDIOC_EXPBUF, vidioc_expbuf); 668 SET_VALID_IOCTL(ops, VIDIOC_DQBUF, vidioc_dqbuf); 669 SET_VALID_IOCTL(ops, VIDIOC_CREATE_BUFS, vidioc_create_bufs); 670 SET_VALID_IOCTL(ops, VIDIOC_PREPARE_BUF, vidioc_prepare_buf); 671 if (ops->vidioc_s_std) 672 set_bit(_IOC_NR(VIDIOC_ENUMSTD), valid_ioctls); 673 SET_VALID_IOCTL(ops, VIDIOC_S_STD, vidioc_s_std); 674 SET_VALID_IOCTL(ops, VIDIOC_G_STD, vidioc_g_std); 675 if (is_rx) { 676 SET_VALID_IOCTL(ops, VIDIOC_QUERYSTD, vidioc_querystd); 677 SET_VALID_IOCTL(ops, VIDIOC_ENUMINPUT, vidioc_enum_input); 678 SET_VALID_IOCTL(ops, VIDIOC_G_INPUT, vidioc_g_input); 679 SET_VALID_IOCTL(ops, VIDIOC_S_INPUT, vidioc_s_input); 680 SET_VALID_IOCTL(ops, VIDIOC_ENUMAUDIO, vidioc_enumaudio); 681 SET_VALID_IOCTL(ops, VIDIOC_G_AUDIO, vidioc_g_audio); 682 SET_VALID_IOCTL(ops, VIDIOC_S_AUDIO, vidioc_s_audio); 683 SET_VALID_IOCTL(ops, VIDIOC_QUERY_DV_TIMINGS, vidioc_query_dv_timings); 684 } 685 if (is_tx) { 686 SET_VALID_IOCTL(ops, VIDIOC_ENUMOUTPUT, vidioc_enum_output); 687 SET_VALID_IOCTL(ops, VIDIOC_G_OUTPUT, vidioc_g_output); 688 SET_VALID_IOCTL(ops, VIDIOC_S_OUTPUT, vidioc_s_output); 689 SET_VALID_IOCTL(ops, VIDIOC_ENUMAUDOUT, vidioc_enumaudout); 690 SET_VALID_IOCTL(ops, VIDIOC_G_AUDOUT, vidioc_g_audout); 691 SET_VALID_IOCTL(ops, VIDIOC_S_AUDOUT, vidioc_s_audout); 692 } 693 if (ops->vidioc_g_crop || ops->vidioc_g_selection) 694 set_bit(_IOC_NR(VIDIOC_G_CROP), valid_ioctls); 695 if (ops->vidioc_s_crop || ops->vidioc_s_selection) 696 set_bit(_IOC_NR(VIDIOC_S_CROP), valid_ioctls); 697 SET_VALID_IOCTL(ops, VIDIOC_G_SELECTION, vidioc_g_selection); 698 SET_VALID_IOCTL(ops, VIDIOC_S_SELECTION, vidioc_s_selection); 699 if (ops->vidioc_cropcap || ops->vidioc_g_selection) 700 set_bit(_IOC_NR(VIDIOC_CROPCAP), valid_ioctls); 701 if (ops->vidioc_g_parm || (vdev->vfl_type == VFL_TYPE_GRABBER && 702 ops->vidioc_g_std)) 703 set_bit(_IOC_NR(VIDIOC_G_PARM), valid_ioctls); 704 SET_VALID_IOCTL(ops, VIDIOC_S_PARM, vidioc_s_parm); 705 SET_VALID_IOCTL(ops, VIDIOC_S_DV_TIMINGS, vidioc_s_dv_timings); 706 SET_VALID_IOCTL(ops, VIDIOC_G_DV_TIMINGS, vidioc_g_dv_timings); 707 SET_VALID_IOCTL(ops, VIDIOC_ENUM_DV_TIMINGS, vidioc_enum_dv_timings); 708 SET_VALID_IOCTL(ops, VIDIOC_DV_TIMINGS_CAP, vidioc_dv_timings_cap); 709 } 710 if (is_tx) { 711 /* transmitter only ioctls */ 712 SET_VALID_IOCTL(ops, VIDIOC_G_MODULATOR, vidioc_g_modulator); 713 SET_VALID_IOCTL(ops, VIDIOC_S_MODULATOR, vidioc_s_modulator); 714 } 715 if (is_rx) { 716 /* receiver only ioctls */ 717 SET_VALID_IOCTL(ops, VIDIOC_G_TUNER, vidioc_g_tuner); 718 SET_VALID_IOCTL(ops, VIDIOC_S_TUNER, vidioc_s_tuner); 719 SET_VALID_IOCTL(ops, VIDIOC_S_HW_FREQ_SEEK, vidioc_s_hw_freq_seek); 720 } 721 722 bitmap_andnot(vdev->valid_ioctls, valid_ioctls, vdev->valid_ioctls, 723 BASE_VIDIOC_PRIVATE); 724 } 725 726 /** 727 * __video_register_device - register video4linux devices 728 * @vdev: video device structure we want to register 729 * @type: type of device to register 730 * @nr: which device node number (0 == /dev/video0, 1 == /dev/video1, ... 731 * -1 == first free) 732 * @warn_if_nr_in_use: warn if the desired device node number 733 * was already in use and another number was chosen instead. 734 * @owner: module that owns the video device node 735 * 736 * The registration code assigns minor numbers and device node numbers 737 * based on the requested type and registers the new device node with 738 * the kernel. 739 * 740 * This function assumes that struct video_device was zeroed when it 741 * was allocated and does not contain any stale date. 742 * 743 * An error is returned if no free minor or device node number could be 744 * found, or if the registration of the device node failed. 745 * 746 * Zero is returned on success. 747 * 748 * Valid types are 749 * 750 * %VFL_TYPE_GRABBER - A frame grabber 751 * 752 * %VFL_TYPE_VBI - Vertical blank data (undecoded) 753 * 754 * %VFL_TYPE_RADIO - A radio card 755 * 756 * %VFL_TYPE_SUBDEV - A subdevice 757 */ 758 int __video_register_device(struct video_device *vdev, int type, int nr, 759 int warn_if_nr_in_use, struct module *owner) 760 { 761 int i = 0; 762 int ret; 763 int minor_offset = 0; 764 int minor_cnt = VIDEO_NUM_DEVICES; 765 const char *name_base; 766 767 /* A minor value of -1 marks this video device as never 768 having been registered */ 769 vdev->minor = -1; 770 771 /* the release callback MUST be present */ 772 if (WARN_ON(!vdev->release)) 773 return -EINVAL; 774 /* the v4l2_dev pointer MUST be present */ 775 if (WARN_ON(!vdev->v4l2_dev)) 776 return -EINVAL; 777 778 /* v4l2_fh support */ 779 spin_lock_init(&vdev->fh_lock); 780 INIT_LIST_HEAD(&vdev->fh_list); 781 782 /* Part 1: check device type */ 783 switch (type) { 784 case VFL_TYPE_GRABBER: 785 name_base = "video"; 786 break; 787 case VFL_TYPE_VBI: 788 name_base = "vbi"; 789 break; 790 case VFL_TYPE_RADIO: 791 name_base = "radio"; 792 break; 793 case VFL_TYPE_SUBDEV: 794 name_base = "v4l-subdev"; 795 break; 796 default: 797 printk(KERN_ERR "%s called with unknown type: %d\n", 798 __func__, type); 799 return -EINVAL; 800 } 801 802 vdev->vfl_type = type; 803 vdev->cdev = NULL; 804 if (vdev->dev_parent == NULL) 805 vdev->dev_parent = vdev->v4l2_dev->dev; 806 if (vdev->ctrl_handler == NULL) 807 vdev->ctrl_handler = vdev->v4l2_dev->ctrl_handler; 808 /* If the prio state pointer is NULL, then use the v4l2_device 809 prio state. */ 810 if (vdev->prio == NULL) 811 vdev->prio = &vdev->v4l2_dev->prio; 812 813 /* Part 2: find a free minor, device node number and device index. */ 814 #ifdef CONFIG_VIDEO_FIXED_MINOR_RANGES 815 /* Keep the ranges for the first four types for historical 816 * reasons. 817 * Newer devices (not yet in place) should use the range 818 * of 128-191 and just pick the first free minor there 819 * (new style). */ 820 switch (type) { 821 case VFL_TYPE_GRABBER: 822 minor_offset = 0; 823 minor_cnt = 64; 824 break; 825 case VFL_TYPE_RADIO: 826 minor_offset = 64; 827 minor_cnt = 64; 828 break; 829 case VFL_TYPE_VBI: 830 minor_offset = 224; 831 minor_cnt = 32; 832 break; 833 default: 834 minor_offset = 128; 835 minor_cnt = 64; 836 break; 837 } 838 #endif 839 840 /* Pick a device node number */ 841 mutex_lock(&videodev_lock); 842 nr = devnode_find(vdev, nr == -1 ? 0 : nr, minor_cnt); 843 if (nr == minor_cnt) 844 nr = devnode_find(vdev, 0, minor_cnt); 845 if (nr == minor_cnt) { 846 printk(KERN_ERR "could not get a free device node number\n"); 847 mutex_unlock(&videodev_lock); 848 return -ENFILE; 849 } 850 #ifdef CONFIG_VIDEO_FIXED_MINOR_RANGES 851 /* 1-on-1 mapping of device node number to minor number */ 852 i = nr; 853 #else 854 /* The device node number and minor numbers are independent, so 855 we just find the first free minor number. */ 856 for (i = 0; i < VIDEO_NUM_DEVICES; i++) 857 if (video_device[i] == NULL) 858 break; 859 if (i == VIDEO_NUM_DEVICES) { 860 mutex_unlock(&videodev_lock); 861 printk(KERN_ERR "could not get a free minor\n"); 862 return -ENFILE; 863 } 864 #endif 865 vdev->minor = i + minor_offset; 866 vdev->num = nr; 867 devnode_set(vdev); 868 869 /* Should not happen since we thought this minor was free */ 870 WARN_ON(video_device[vdev->minor] != NULL); 871 vdev->index = get_index(vdev); 872 mutex_unlock(&videodev_lock); 873 874 if (vdev->ioctl_ops) 875 determine_valid_ioctls(vdev); 876 877 /* Part 3: Initialize the character device */ 878 vdev->cdev = cdev_alloc(); 879 if (vdev->cdev == NULL) { 880 ret = -ENOMEM; 881 goto cleanup; 882 } 883 vdev->cdev->ops = &v4l2_fops; 884 vdev->cdev->owner = owner; 885 ret = cdev_add(vdev->cdev, MKDEV(VIDEO_MAJOR, vdev->minor), 1); 886 if (ret < 0) { 887 printk(KERN_ERR "%s: cdev_add failed\n", __func__); 888 kfree(vdev->cdev); 889 vdev->cdev = NULL; 890 goto cleanup; 891 } 892 893 /* Part 4: register the device with sysfs */ 894 vdev->dev.class = &video_class; 895 vdev->dev.devt = MKDEV(VIDEO_MAJOR, vdev->minor); 896 vdev->dev.parent = vdev->dev_parent; 897 dev_set_name(&vdev->dev, "%s%d", name_base, vdev->num); 898 ret = device_register(&vdev->dev); 899 if (ret < 0) { 900 printk(KERN_ERR "%s: device_register failed\n", __func__); 901 goto cleanup; 902 } 903 /* Register the release callback that will be called when the last 904 reference to the device goes away. */ 905 vdev->dev.release = v4l2_device_release; 906 907 if (nr != -1 && nr != vdev->num && warn_if_nr_in_use) 908 printk(KERN_WARNING "%s: requested %s%d, got %s\n", __func__, 909 name_base, nr, video_device_node_name(vdev)); 910 911 /* Increase v4l2_device refcount */ 912 if (vdev->v4l2_dev) 913 v4l2_device_get(vdev->v4l2_dev); 914 915 #if defined(CONFIG_MEDIA_CONTROLLER) 916 /* Part 5: Register the entity. */ 917 if (vdev->v4l2_dev && vdev->v4l2_dev->mdev && 918 vdev->vfl_type != VFL_TYPE_SUBDEV) { 919 vdev->entity.type = MEDIA_ENT_T_DEVNODE_V4L; 920 vdev->entity.name = vdev->name; 921 vdev->entity.info.v4l.major = VIDEO_MAJOR; 922 vdev->entity.info.v4l.minor = vdev->minor; 923 ret = media_device_register_entity(vdev->v4l2_dev->mdev, 924 &vdev->entity); 925 if (ret < 0) 926 printk(KERN_WARNING 927 "%s: media_device_register_entity failed\n", 928 __func__); 929 } 930 #endif 931 /* Part 6: Activate this minor. The char device can now be used. */ 932 set_bit(V4L2_FL_REGISTERED, &vdev->flags); 933 mutex_lock(&videodev_lock); 934 video_device[vdev->minor] = vdev; 935 mutex_unlock(&videodev_lock); 936 937 return 0; 938 939 cleanup: 940 mutex_lock(&videodev_lock); 941 if (vdev->cdev) 942 cdev_del(vdev->cdev); 943 devnode_clear(vdev); 944 mutex_unlock(&videodev_lock); 945 /* Mark this video device as never having been registered. */ 946 vdev->minor = -1; 947 return ret; 948 } 949 EXPORT_SYMBOL(__video_register_device); 950 951 /** 952 * video_unregister_device - unregister a video4linux device 953 * @vdev: the device to unregister 954 * 955 * This unregisters the passed device. Future open calls will 956 * be met with errors. 957 */ 958 void video_unregister_device(struct video_device *vdev) 959 { 960 /* Check if vdev was ever registered at all */ 961 if (!vdev || !video_is_registered(vdev)) 962 return; 963 964 mutex_lock(&videodev_lock); 965 /* This must be in a critical section to prevent a race with v4l2_open. 966 * Once this bit has been cleared video_get may never be called again. 967 */ 968 clear_bit(V4L2_FL_REGISTERED, &vdev->flags); 969 mutex_unlock(&videodev_lock); 970 device_unregister(&vdev->dev); 971 } 972 EXPORT_SYMBOL(video_unregister_device); 973 974 /* 975 * Initialise video for linux 976 */ 977 static int __init videodev_init(void) 978 { 979 dev_t dev = MKDEV(VIDEO_MAJOR, 0); 980 int ret; 981 982 printk(KERN_INFO "Linux video capture interface: v2.00\n"); 983 ret = register_chrdev_region(dev, VIDEO_NUM_DEVICES, VIDEO_NAME); 984 if (ret < 0) { 985 printk(KERN_WARNING "videodev: unable to get major %d\n", 986 VIDEO_MAJOR); 987 return ret; 988 } 989 990 ret = class_register(&video_class); 991 if (ret < 0) { 992 unregister_chrdev_region(dev, VIDEO_NUM_DEVICES); 993 printk(KERN_WARNING "video_dev: class_register failed\n"); 994 return -EIO; 995 } 996 997 return 0; 998 } 999 1000 static void __exit videodev_exit(void) 1001 { 1002 dev_t dev = MKDEV(VIDEO_MAJOR, 0); 1003 1004 class_unregister(&video_class); 1005 unregister_chrdev_region(dev, VIDEO_NUM_DEVICES); 1006 } 1007 1008 subsys_initcall(videodev_init); 1009 module_exit(videodev_exit) 1010 1011 MODULE_AUTHOR("Alan Cox, Mauro Carvalho Chehab <mchehab@infradead.org>"); 1012 MODULE_DESCRIPTION("Device registrar for Video4Linux drivers v2"); 1013 MODULE_LICENSE("GPL"); 1014 MODULE_ALIAS_CHARDEV_MAJOR(VIDEO_MAJOR); 1015 1016 1017 /* 1018 * Local variables: 1019 * c-basic-offset: 8 1020 * End: 1021 */ 1022