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