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