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