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