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