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