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