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 /* 43 * sysfs stuff 44 */ 45 46 static ssize_t index_show(struct device *cd, 47 struct device_attribute *attr, char *buf) 48 { 49 struct video_device *vdev = to_video_device(cd); 50 51 return sprintf(buf, "%i\n", vdev->index); 52 } 53 static DEVICE_ATTR_RO(index); 54 55 static ssize_t dev_debug_show(struct device *cd, 56 struct device_attribute *attr, char *buf) 57 { 58 struct video_device *vdev = to_video_device(cd); 59 60 return sprintf(buf, "%i\n", vdev->dev_debug); 61 } 62 63 static ssize_t dev_debug_store(struct device *cd, struct device_attribute *attr, 64 const char *buf, size_t len) 65 { 66 struct video_device *vdev = to_video_device(cd); 67 int res = 0; 68 u16 value; 69 70 res = kstrtou16(buf, 0, &value); 71 if (res) 72 return res; 73 74 vdev->dev_debug = value; 75 return len; 76 } 77 static DEVICE_ATTR_RW(dev_debug); 78 79 static ssize_t name_show(struct device *cd, 80 struct device_attribute *attr, char *buf) 81 { 82 struct video_device *vdev = to_video_device(cd); 83 84 return sprintf(buf, "%.*s\n", (int)sizeof(vdev->name), vdev->name); 85 } 86 static DEVICE_ATTR_RO(name); 87 88 static struct attribute *video_device_attrs[] = { 89 &dev_attr_name.attr, 90 &dev_attr_dev_debug.attr, 91 &dev_attr_index.attr, 92 NULL, 93 }; 94 ATTRIBUTE_GROUPS(video_device); 95 96 /* 97 * Active devices 98 */ 99 static struct video_device *video_devices[VIDEO_NUM_DEVICES]; 100 static DEFINE_MUTEX(videodev_lock); 101 static DECLARE_BITMAP(devnode_nums[VFL_TYPE_MAX], VIDEO_NUM_DEVICES); 102 103 /* Device node utility functions */ 104 105 /* Note: these utility functions all assume that vfl_type is in the range 106 [0, VFL_TYPE_MAX-1]. */ 107 108 #ifdef CONFIG_VIDEO_FIXED_MINOR_RANGES 109 /* Return the bitmap corresponding to vfl_type. */ 110 static inline unsigned long *devnode_bits(enum vfl_devnode_type vfl_type) 111 { 112 /* Any types not assigned to fixed minor ranges must be mapped to 113 one single bitmap for the purposes of finding a free node number 114 since all those unassigned types use the same minor range. */ 115 int idx = (vfl_type > VFL_TYPE_RADIO) ? VFL_TYPE_MAX - 1 : vfl_type; 116 117 return devnode_nums[idx]; 118 } 119 #else 120 /* Return the bitmap corresponding to vfl_type. */ 121 static inline unsigned long *devnode_bits(enum vfl_devnode_type vfl_type) 122 { 123 return devnode_nums[vfl_type]; 124 } 125 #endif 126 127 /* Mark device node number vdev->num as used */ 128 static inline void devnode_set(struct video_device *vdev) 129 { 130 set_bit(vdev->num, devnode_bits(vdev->vfl_type)); 131 } 132 133 /* Mark device node number vdev->num as unused */ 134 static inline void devnode_clear(struct video_device *vdev) 135 { 136 clear_bit(vdev->num, devnode_bits(vdev->vfl_type)); 137 } 138 139 /* Try to find a free device node number in the range [from, to> */ 140 static inline int devnode_find(struct video_device *vdev, int from, int to) 141 { 142 return find_next_zero_bit(devnode_bits(vdev->vfl_type), to, from); 143 } 144 145 struct video_device *video_device_alloc(void) 146 { 147 return kzalloc(sizeof(struct video_device), GFP_KERNEL); 148 } 149 EXPORT_SYMBOL(video_device_alloc); 150 151 void video_device_release(struct video_device *vdev) 152 { 153 kfree(vdev); 154 } 155 EXPORT_SYMBOL(video_device_release); 156 157 void video_device_release_empty(struct video_device *vdev) 158 { 159 /* Do nothing */ 160 /* Only valid when the video_device struct is a static. */ 161 } 162 EXPORT_SYMBOL(video_device_release_empty); 163 164 static inline void video_get(struct video_device *vdev) 165 { 166 get_device(&vdev->dev); 167 } 168 169 static inline void video_put(struct video_device *vdev) 170 { 171 put_device(&vdev->dev); 172 } 173 174 /* Called when the last user of the video device exits. */ 175 static void v4l2_device_release(struct device *cd) 176 { 177 struct video_device *vdev = to_video_device(cd); 178 struct v4l2_device *v4l2_dev = vdev->v4l2_dev; 179 180 mutex_lock(&videodev_lock); 181 if (WARN_ON(video_devices[vdev->minor] != vdev)) { 182 /* should not happen */ 183 mutex_unlock(&videodev_lock); 184 return; 185 } 186 187 /* Free up this device for reuse */ 188 video_devices[vdev->minor] = NULL; 189 190 /* Delete the cdev on this minor as well */ 191 cdev_del(vdev->cdev); 192 /* Just in case some driver tries to access this from 193 the release() callback. */ 194 vdev->cdev = NULL; 195 196 /* Mark device node number as free */ 197 devnode_clear(vdev); 198 199 mutex_unlock(&videodev_lock); 200 201 #if defined(CONFIG_MEDIA_CONTROLLER) 202 if (v4l2_dev->mdev && vdev->vfl_dir != VFL_DIR_M2M) { 203 /* Remove interfaces and interface links */ 204 media_devnode_remove(vdev->intf_devnode); 205 if (vdev->entity.function != MEDIA_ENT_F_UNKNOWN) 206 media_device_unregister_entity(&vdev->entity); 207 } 208 #endif 209 210 /* Do not call v4l2_device_put if there is no release callback set. 211 * Drivers that have no v4l2_device release callback might free the 212 * v4l2_dev instance in the video_device release callback below, so we 213 * must perform this check here. 214 * 215 * TODO: In the long run all drivers that use v4l2_device should use the 216 * v4l2_device release callback. This check will then be unnecessary. 217 */ 218 if (v4l2_dev->release == NULL) 219 v4l2_dev = NULL; 220 221 /* Release video_device and perform other 222 cleanups as needed. */ 223 vdev->release(vdev); 224 225 /* Decrease v4l2_device refcount */ 226 if (v4l2_dev) 227 v4l2_device_put(v4l2_dev); 228 } 229 230 static struct class video_class = { 231 .name = VIDEO_NAME, 232 .dev_groups = video_device_groups, 233 }; 234 235 struct video_device *video_devdata(struct file *file) 236 { 237 return video_devices[iminor(file_inode(file))]; 238 } 239 EXPORT_SYMBOL(video_devdata); 240 241 242 /* Priority handling */ 243 244 static inline bool prio_is_valid(enum v4l2_priority prio) 245 { 246 return prio == V4L2_PRIORITY_BACKGROUND || 247 prio == V4L2_PRIORITY_INTERACTIVE || 248 prio == V4L2_PRIORITY_RECORD; 249 } 250 251 void v4l2_prio_init(struct v4l2_prio_state *global) 252 { 253 memset(global, 0, sizeof(*global)); 254 } 255 EXPORT_SYMBOL(v4l2_prio_init); 256 257 int v4l2_prio_change(struct v4l2_prio_state *global, enum v4l2_priority *local, 258 enum v4l2_priority new) 259 { 260 if (!prio_is_valid(new)) 261 return -EINVAL; 262 if (*local == new) 263 return 0; 264 265 atomic_inc(&global->prios[new]); 266 if (prio_is_valid(*local)) 267 atomic_dec(&global->prios[*local]); 268 *local = new; 269 return 0; 270 } 271 EXPORT_SYMBOL(v4l2_prio_change); 272 273 void v4l2_prio_open(struct v4l2_prio_state *global, enum v4l2_priority *local) 274 { 275 v4l2_prio_change(global, local, V4L2_PRIORITY_DEFAULT); 276 } 277 EXPORT_SYMBOL(v4l2_prio_open); 278 279 void v4l2_prio_close(struct v4l2_prio_state *global, enum v4l2_priority local) 280 { 281 if (prio_is_valid(local)) 282 atomic_dec(&global->prios[local]); 283 } 284 EXPORT_SYMBOL(v4l2_prio_close); 285 286 enum v4l2_priority v4l2_prio_max(struct v4l2_prio_state *global) 287 { 288 if (atomic_read(&global->prios[V4L2_PRIORITY_RECORD]) > 0) 289 return V4L2_PRIORITY_RECORD; 290 if (atomic_read(&global->prios[V4L2_PRIORITY_INTERACTIVE]) > 0) 291 return V4L2_PRIORITY_INTERACTIVE; 292 if (atomic_read(&global->prios[V4L2_PRIORITY_BACKGROUND]) > 0) 293 return V4L2_PRIORITY_BACKGROUND; 294 return V4L2_PRIORITY_UNSET; 295 } 296 EXPORT_SYMBOL(v4l2_prio_max); 297 298 int v4l2_prio_check(struct v4l2_prio_state *global, enum v4l2_priority local) 299 { 300 return (local < v4l2_prio_max(global)) ? -EBUSY : 0; 301 } 302 EXPORT_SYMBOL(v4l2_prio_check); 303 304 305 static ssize_t v4l2_read(struct file *filp, char __user *buf, 306 size_t sz, loff_t *off) 307 { 308 struct video_device *vdev = video_devdata(filp); 309 int ret = -ENODEV; 310 311 if (!vdev->fops->read) 312 return -EINVAL; 313 if (video_is_registered(vdev)) 314 ret = vdev->fops->read(filp, buf, sz, off); 315 if ((vdev->dev_debug & V4L2_DEV_DEBUG_FOP) && 316 (vdev->dev_debug & V4L2_DEV_DEBUG_STREAMING)) 317 dprintk("%s: read: %zd (%d)\n", 318 video_device_node_name(vdev), sz, ret); 319 return ret; 320 } 321 322 static ssize_t v4l2_write(struct file *filp, const char __user *buf, 323 size_t sz, loff_t *off) 324 { 325 struct video_device *vdev = video_devdata(filp); 326 int ret = -ENODEV; 327 328 if (!vdev->fops->write) 329 return -EINVAL; 330 if (video_is_registered(vdev)) 331 ret = vdev->fops->write(filp, buf, sz, off); 332 if ((vdev->dev_debug & V4L2_DEV_DEBUG_FOP) && 333 (vdev->dev_debug & V4L2_DEV_DEBUG_STREAMING)) 334 dprintk("%s: write: %zd (%d)\n", 335 video_device_node_name(vdev), sz, ret); 336 return ret; 337 } 338 339 static __poll_t v4l2_poll(struct file *filp, struct poll_table_struct *poll) 340 { 341 struct video_device *vdev = video_devdata(filp); 342 __poll_t res = EPOLLERR | EPOLLHUP | EPOLLPRI; 343 344 if (video_is_registered(vdev)) { 345 if (!vdev->fops->poll) 346 res = DEFAULT_POLLMASK; 347 else 348 res = vdev->fops->poll(filp, poll); 349 } 350 if (vdev->dev_debug & V4L2_DEV_DEBUG_POLL) 351 dprintk("%s: poll: %08x %08x\n", 352 video_device_node_name(vdev), res, 353 poll_requested_events(poll)); 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 do { if ((ops)->op) __set_bit(_IOC_NR(cmd), valid_ioctls); } while (0) 523 524 /* This determines which ioctls are actually implemented in the driver. 525 It's a one-time thing which simplifies video_ioctl2 as it can just do 526 a bit test. 527 528 Note that drivers can override this by setting bits to 1 in 529 vdev->valid_ioctls. If an ioctl is marked as 1 when this function is 530 called, then that ioctl will actually be marked as unimplemented. 531 532 It does that by first setting up the local valid_ioctls bitmap, and 533 at the end do a: 534 535 vdev->valid_ioctls = valid_ioctls & ~(vdev->valid_ioctls) 536 */ 537 static void determine_valid_ioctls(struct video_device *vdev) 538 { 539 const u32 vid_caps = V4L2_CAP_VIDEO_CAPTURE | 540 V4L2_CAP_VIDEO_CAPTURE_MPLANE | 541 V4L2_CAP_VIDEO_OUTPUT | 542 V4L2_CAP_VIDEO_OUTPUT_MPLANE | 543 V4L2_CAP_VIDEO_M2M | V4L2_CAP_VIDEO_M2M_MPLANE; 544 const u32 meta_caps = V4L2_CAP_META_CAPTURE | 545 V4L2_CAP_META_OUTPUT; 546 DECLARE_BITMAP(valid_ioctls, BASE_VIDIOC_PRIVATE); 547 const struct v4l2_ioctl_ops *ops = vdev->ioctl_ops; 548 bool is_vid = vdev->vfl_type == VFL_TYPE_VIDEO && 549 (vdev->device_caps & vid_caps); 550 bool is_vbi = vdev->vfl_type == VFL_TYPE_VBI; 551 bool is_radio = vdev->vfl_type == VFL_TYPE_RADIO; 552 bool is_sdr = vdev->vfl_type == VFL_TYPE_SDR; 553 bool is_tch = vdev->vfl_type == VFL_TYPE_TOUCH; 554 bool is_meta = vdev->vfl_type == VFL_TYPE_VIDEO && 555 (vdev->device_caps & meta_caps); 556 bool is_rx = vdev->vfl_dir != VFL_DIR_TX; 557 bool is_tx = vdev->vfl_dir != VFL_DIR_RX; 558 bool is_io_mc = vdev->device_caps & V4L2_CAP_IO_MC; 559 bool has_streaming = vdev->device_caps & V4L2_CAP_STREAMING; 560 bool is_edid = vdev->device_caps & V4L2_CAP_EDID; 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 !test_bit(_IOC_NR(VIDIOC_G_SELECTION), vdev->valid_ioctls)) { 648 __set_bit(_IOC_NR(VIDIOC_G_CROP), valid_ioctls); 649 __set_bit(_IOC_NR(VIDIOC_CROPCAP), valid_ioctls); 650 } 651 if (ops->vidioc_s_selection && 652 !test_bit(_IOC_NR(VIDIOC_S_SELECTION), vdev->valid_ioctls)) 653 __set_bit(_IOC_NR(VIDIOC_S_CROP), valid_ioctls); 654 SET_VALID_IOCTL(ops, VIDIOC_G_SELECTION, vidioc_g_selection); 655 SET_VALID_IOCTL(ops, VIDIOC_S_SELECTION, vidioc_s_selection); 656 } 657 if (is_meta && is_rx) { 658 /* metadata capture specific ioctls */ 659 SET_VALID_IOCTL(ops, VIDIOC_ENUM_FMT, vidioc_enum_fmt_meta_cap); 660 SET_VALID_IOCTL(ops, VIDIOC_G_FMT, vidioc_g_fmt_meta_cap); 661 SET_VALID_IOCTL(ops, VIDIOC_S_FMT, vidioc_s_fmt_meta_cap); 662 SET_VALID_IOCTL(ops, VIDIOC_TRY_FMT, vidioc_try_fmt_meta_cap); 663 } else if (is_meta && is_tx) { 664 /* metadata output specific ioctls */ 665 SET_VALID_IOCTL(ops, VIDIOC_ENUM_FMT, vidioc_enum_fmt_meta_out); 666 SET_VALID_IOCTL(ops, VIDIOC_G_FMT, vidioc_g_fmt_meta_out); 667 SET_VALID_IOCTL(ops, VIDIOC_S_FMT, vidioc_s_fmt_meta_out); 668 SET_VALID_IOCTL(ops, VIDIOC_TRY_FMT, vidioc_try_fmt_meta_out); 669 } 670 if (is_vbi) { 671 /* vbi specific ioctls */ 672 if ((is_rx && (ops->vidioc_g_fmt_vbi_cap || 673 ops->vidioc_g_fmt_sliced_vbi_cap)) || 674 (is_tx && (ops->vidioc_g_fmt_vbi_out || 675 ops->vidioc_g_fmt_sliced_vbi_out))) 676 __set_bit(_IOC_NR(VIDIOC_G_FMT), valid_ioctls); 677 if ((is_rx && (ops->vidioc_s_fmt_vbi_cap || 678 ops->vidioc_s_fmt_sliced_vbi_cap)) || 679 (is_tx && (ops->vidioc_s_fmt_vbi_out || 680 ops->vidioc_s_fmt_sliced_vbi_out))) 681 __set_bit(_IOC_NR(VIDIOC_S_FMT), valid_ioctls); 682 if ((is_rx && (ops->vidioc_try_fmt_vbi_cap || 683 ops->vidioc_try_fmt_sliced_vbi_cap)) || 684 (is_tx && (ops->vidioc_try_fmt_vbi_out || 685 ops->vidioc_try_fmt_sliced_vbi_out))) 686 __set_bit(_IOC_NR(VIDIOC_TRY_FMT), valid_ioctls); 687 SET_VALID_IOCTL(ops, VIDIOC_G_SLICED_VBI_CAP, vidioc_g_sliced_vbi_cap); 688 } else if (is_tch) { 689 /* touch specific ioctls */ 690 SET_VALID_IOCTL(ops, VIDIOC_ENUM_FMT, vidioc_enum_fmt_vid_cap); 691 SET_VALID_IOCTL(ops, VIDIOC_G_FMT, vidioc_g_fmt_vid_cap); 692 SET_VALID_IOCTL(ops, VIDIOC_S_FMT, vidioc_s_fmt_vid_cap); 693 SET_VALID_IOCTL(ops, VIDIOC_TRY_FMT, vidioc_try_fmt_vid_cap); 694 SET_VALID_IOCTL(ops, VIDIOC_ENUM_FRAMESIZES, vidioc_enum_framesizes); 695 SET_VALID_IOCTL(ops, VIDIOC_ENUM_FRAMEINTERVALS, vidioc_enum_frameintervals); 696 SET_VALID_IOCTL(ops, VIDIOC_ENUMINPUT, vidioc_enum_input); 697 SET_VALID_IOCTL(ops, VIDIOC_G_INPUT, vidioc_g_input); 698 SET_VALID_IOCTL(ops, VIDIOC_S_INPUT, vidioc_s_input); 699 SET_VALID_IOCTL(ops, VIDIOC_G_PARM, vidioc_g_parm); 700 SET_VALID_IOCTL(ops, VIDIOC_S_PARM, vidioc_s_parm); 701 } else if (is_sdr && is_rx) { 702 /* SDR receiver specific ioctls */ 703 SET_VALID_IOCTL(ops, VIDIOC_ENUM_FMT, vidioc_enum_fmt_sdr_cap); 704 SET_VALID_IOCTL(ops, VIDIOC_G_FMT, vidioc_g_fmt_sdr_cap); 705 SET_VALID_IOCTL(ops, VIDIOC_S_FMT, vidioc_s_fmt_sdr_cap); 706 SET_VALID_IOCTL(ops, VIDIOC_TRY_FMT, vidioc_try_fmt_sdr_cap); 707 } else if (is_sdr && is_tx) { 708 /* SDR transmitter specific ioctls */ 709 SET_VALID_IOCTL(ops, VIDIOC_ENUM_FMT, vidioc_enum_fmt_sdr_out); 710 SET_VALID_IOCTL(ops, VIDIOC_G_FMT, vidioc_g_fmt_sdr_out); 711 SET_VALID_IOCTL(ops, VIDIOC_S_FMT, vidioc_s_fmt_sdr_out); 712 SET_VALID_IOCTL(ops, VIDIOC_TRY_FMT, vidioc_try_fmt_sdr_out); 713 } 714 715 if (has_streaming) { 716 /* ioctls valid for streaming I/O */ 717 SET_VALID_IOCTL(ops, VIDIOC_REQBUFS, vidioc_reqbufs); 718 SET_VALID_IOCTL(ops, VIDIOC_QUERYBUF, vidioc_querybuf); 719 SET_VALID_IOCTL(ops, VIDIOC_QBUF, vidioc_qbuf); 720 SET_VALID_IOCTL(ops, VIDIOC_EXPBUF, vidioc_expbuf); 721 SET_VALID_IOCTL(ops, VIDIOC_DQBUF, vidioc_dqbuf); 722 SET_VALID_IOCTL(ops, VIDIOC_CREATE_BUFS, vidioc_create_bufs); 723 SET_VALID_IOCTL(ops, VIDIOC_PREPARE_BUF, vidioc_prepare_buf); 724 SET_VALID_IOCTL(ops, VIDIOC_STREAMON, vidioc_streamon); 725 SET_VALID_IOCTL(ops, VIDIOC_STREAMOFF, vidioc_streamoff); 726 /* VIDIOC_CREATE_BUFS support is mandatory to enable VIDIOC_REMOVE_BUFS */ 727 if (ops->vidioc_create_bufs) 728 SET_VALID_IOCTL(ops, VIDIOC_REMOVE_BUFS, vidioc_remove_bufs); 729 } 730 731 if (is_vid || is_vbi || is_meta) { 732 /* ioctls valid for video, vbi and metadata */ 733 if (ops->vidioc_s_std) 734 __set_bit(_IOC_NR(VIDIOC_ENUMSTD), valid_ioctls); 735 SET_VALID_IOCTL(ops, VIDIOC_S_STD, vidioc_s_std); 736 SET_VALID_IOCTL(ops, VIDIOC_G_STD, vidioc_g_std); 737 if (is_rx) { 738 SET_VALID_IOCTL(ops, VIDIOC_QUERYSTD, vidioc_querystd); 739 if (is_io_mc) { 740 __set_bit(_IOC_NR(VIDIOC_ENUMINPUT), valid_ioctls); 741 __set_bit(_IOC_NR(VIDIOC_G_INPUT), valid_ioctls); 742 __set_bit(_IOC_NR(VIDIOC_S_INPUT), valid_ioctls); 743 } else { 744 SET_VALID_IOCTL(ops, VIDIOC_ENUMINPUT, vidioc_enum_input); 745 SET_VALID_IOCTL(ops, VIDIOC_G_INPUT, vidioc_g_input); 746 SET_VALID_IOCTL(ops, VIDIOC_S_INPUT, vidioc_s_input); 747 } 748 SET_VALID_IOCTL(ops, VIDIOC_ENUMAUDIO, vidioc_enumaudio); 749 SET_VALID_IOCTL(ops, VIDIOC_G_AUDIO, vidioc_g_audio); 750 SET_VALID_IOCTL(ops, VIDIOC_S_AUDIO, vidioc_s_audio); 751 SET_VALID_IOCTL(ops, VIDIOC_QUERY_DV_TIMINGS, vidioc_query_dv_timings); 752 SET_VALID_IOCTL(ops, VIDIOC_S_EDID, vidioc_s_edid); 753 } 754 if (is_tx) { 755 if (is_io_mc) { 756 __set_bit(_IOC_NR(VIDIOC_ENUMOUTPUT), valid_ioctls); 757 __set_bit(_IOC_NR(VIDIOC_G_OUTPUT), valid_ioctls); 758 __set_bit(_IOC_NR(VIDIOC_S_OUTPUT), valid_ioctls); 759 } else { 760 SET_VALID_IOCTL(ops, VIDIOC_ENUMOUTPUT, vidioc_enum_output); 761 SET_VALID_IOCTL(ops, VIDIOC_G_OUTPUT, vidioc_g_output); 762 SET_VALID_IOCTL(ops, VIDIOC_S_OUTPUT, vidioc_s_output); 763 } 764 SET_VALID_IOCTL(ops, VIDIOC_ENUMAUDOUT, vidioc_enumaudout); 765 SET_VALID_IOCTL(ops, VIDIOC_G_AUDOUT, vidioc_g_audout); 766 SET_VALID_IOCTL(ops, VIDIOC_S_AUDOUT, vidioc_s_audout); 767 } 768 if (ops->vidioc_g_parm || ops->vidioc_g_std) 769 __set_bit(_IOC_NR(VIDIOC_G_PARM), valid_ioctls); 770 SET_VALID_IOCTL(ops, VIDIOC_S_PARM, vidioc_s_parm); 771 SET_VALID_IOCTL(ops, VIDIOC_S_DV_TIMINGS, vidioc_s_dv_timings); 772 SET_VALID_IOCTL(ops, VIDIOC_G_DV_TIMINGS, vidioc_g_dv_timings); 773 SET_VALID_IOCTL(ops, VIDIOC_ENUM_DV_TIMINGS, vidioc_enum_dv_timings); 774 SET_VALID_IOCTL(ops, VIDIOC_DV_TIMINGS_CAP, vidioc_dv_timings_cap); 775 SET_VALID_IOCTL(ops, VIDIOC_G_EDID, vidioc_g_edid); 776 } 777 if (is_tx && (is_radio || is_sdr)) { 778 /* radio transmitter only ioctls */ 779 SET_VALID_IOCTL(ops, VIDIOC_G_MODULATOR, vidioc_g_modulator); 780 SET_VALID_IOCTL(ops, VIDIOC_S_MODULATOR, vidioc_s_modulator); 781 } 782 if (is_rx && !is_tch) { 783 /* receiver only ioctls */ 784 SET_VALID_IOCTL(ops, VIDIOC_G_TUNER, vidioc_g_tuner); 785 SET_VALID_IOCTL(ops, VIDIOC_S_TUNER, vidioc_s_tuner); 786 SET_VALID_IOCTL(ops, VIDIOC_S_HW_FREQ_SEEK, vidioc_s_hw_freq_seek); 787 } 788 if (is_edid) { 789 SET_VALID_IOCTL(ops, VIDIOC_G_EDID, vidioc_g_edid); 790 if (is_tx) { 791 SET_VALID_IOCTL(ops, VIDIOC_G_OUTPUT, vidioc_g_output); 792 SET_VALID_IOCTL(ops, VIDIOC_S_OUTPUT, vidioc_s_output); 793 SET_VALID_IOCTL(ops, VIDIOC_ENUMOUTPUT, vidioc_enum_output); 794 } 795 if (is_rx) { 796 SET_VALID_IOCTL(ops, VIDIOC_ENUMINPUT, vidioc_enum_input); 797 SET_VALID_IOCTL(ops, VIDIOC_G_INPUT, vidioc_g_input); 798 SET_VALID_IOCTL(ops, VIDIOC_S_INPUT, vidioc_s_input); 799 SET_VALID_IOCTL(ops, VIDIOC_S_EDID, vidioc_s_edid); 800 } 801 } 802 803 bitmap_andnot(vdev->valid_ioctls, valid_ioctls, vdev->valid_ioctls, 804 BASE_VIDIOC_PRIVATE); 805 } 806 807 static int video_register_media_controller(struct video_device *vdev) 808 { 809 #if defined(CONFIG_MEDIA_CONTROLLER) 810 u32 intf_type; 811 int ret; 812 813 /* Memory-to-memory devices are more complex and use 814 * their own function to register its mc entities. 815 */ 816 if (!vdev->v4l2_dev->mdev || vdev->vfl_dir == VFL_DIR_M2M) 817 return 0; 818 819 vdev->entity.obj_type = MEDIA_ENTITY_TYPE_VIDEO_DEVICE; 820 vdev->entity.function = MEDIA_ENT_F_UNKNOWN; 821 822 switch (vdev->vfl_type) { 823 case VFL_TYPE_VIDEO: 824 intf_type = MEDIA_INTF_T_V4L_VIDEO; 825 vdev->entity.function = MEDIA_ENT_F_IO_V4L; 826 break; 827 case VFL_TYPE_VBI: 828 intf_type = MEDIA_INTF_T_V4L_VBI; 829 vdev->entity.function = MEDIA_ENT_F_IO_VBI; 830 break; 831 case VFL_TYPE_SDR: 832 intf_type = MEDIA_INTF_T_V4L_SWRADIO; 833 vdev->entity.function = MEDIA_ENT_F_IO_SWRADIO; 834 break; 835 case VFL_TYPE_TOUCH: 836 intf_type = MEDIA_INTF_T_V4L_TOUCH; 837 vdev->entity.function = MEDIA_ENT_F_IO_V4L; 838 break; 839 case VFL_TYPE_RADIO: 840 intf_type = MEDIA_INTF_T_V4L_RADIO; 841 /* 842 * Radio doesn't have an entity at the V4L2 side to represent 843 * radio input or output. Instead, the audio input/output goes 844 * via either physical wires or ALSA. 845 */ 846 break; 847 case VFL_TYPE_SUBDEV: 848 intf_type = MEDIA_INTF_T_V4L_SUBDEV; 849 /* Entity will be created via v4l2_device_register_subdev() */ 850 break; 851 default: 852 return 0; 853 } 854 855 if (vdev->entity.function != MEDIA_ENT_F_UNKNOWN) { 856 vdev->entity.name = vdev->name; 857 858 /* Needed just for backward compatibility with legacy MC API */ 859 vdev->entity.info.dev.major = VIDEO_MAJOR; 860 vdev->entity.info.dev.minor = vdev->minor; 861 862 ret = media_device_register_entity(vdev->v4l2_dev->mdev, 863 &vdev->entity); 864 if (ret < 0) { 865 pr_warn("%s: media_device_register_entity failed\n", 866 __func__); 867 return ret; 868 } 869 } 870 871 vdev->intf_devnode = media_devnode_create(vdev->v4l2_dev->mdev, 872 intf_type, 873 0, VIDEO_MAJOR, 874 vdev->minor); 875 if (!vdev->intf_devnode) { 876 media_device_unregister_entity(&vdev->entity); 877 return -ENOMEM; 878 } 879 880 if (vdev->entity.function != MEDIA_ENT_F_UNKNOWN) { 881 struct media_link *link; 882 883 link = media_create_intf_link(&vdev->entity, 884 &vdev->intf_devnode->intf, 885 MEDIA_LNK_FL_ENABLED | 886 MEDIA_LNK_FL_IMMUTABLE); 887 if (!link) { 888 media_devnode_remove(vdev->intf_devnode); 889 media_device_unregister_entity(&vdev->entity); 890 return -ENOMEM; 891 } 892 } 893 894 /* FIXME: how to create the other interface links? */ 895 896 #endif 897 return 0; 898 } 899 900 int __video_register_device(struct video_device *vdev, 901 enum vfl_devnode_type type, 902 int nr, int warn_if_nr_in_use, 903 struct module *owner) 904 { 905 int i = 0; 906 int ret; 907 int minor_offset = 0; 908 int minor_cnt = VIDEO_NUM_DEVICES; 909 const char *name_base; 910 911 /* A minor value of -1 marks this video device as never 912 having been registered */ 913 vdev->minor = -1; 914 915 /* the release callback MUST be present */ 916 if (WARN_ON(!vdev->release)) 917 return -EINVAL; 918 /* the v4l2_dev pointer MUST be present */ 919 if (WARN_ON(!vdev->v4l2_dev)) 920 return -EINVAL; 921 /* the device_caps field MUST be set for all but subdevs */ 922 if (WARN_ON(type != VFL_TYPE_SUBDEV && !vdev->device_caps)) 923 return -EINVAL; 924 925 /* v4l2_fh support */ 926 spin_lock_init(&vdev->fh_lock); 927 INIT_LIST_HEAD(&vdev->fh_list); 928 929 /* Part 1: check device type */ 930 switch (type) { 931 case VFL_TYPE_VIDEO: 932 name_base = "video"; 933 break; 934 case VFL_TYPE_VBI: 935 name_base = "vbi"; 936 break; 937 case VFL_TYPE_RADIO: 938 name_base = "radio"; 939 break; 940 case VFL_TYPE_SUBDEV: 941 name_base = "v4l-subdev"; 942 break; 943 case VFL_TYPE_SDR: 944 /* Use device name 'swradio' because 'sdr' was already taken. */ 945 name_base = "swradio"; 946 break; 947 case VFL_TYPE_TOUCH: 948 name_base = "v4l-touch"; 949 break; 950 default: 951 pr_err("%s called with unknown type: %d\n", 952 __func__, type); 953 return -EINVAL; 954 } 955 956 vdev->vfl_type = type; 957 vdev->cdev = NULL; 958 if (vdev->dev_parent == NULL) 959 vdev->dev_parent = vdev->v4l2_dev->dev; 960 if (vdev->ctrl_handler == NULL) 961 vdev->ctrl_handler = vdev->v4l2_dev->ctrl_handler; 962 /* If the prio state pointer is NULL, then use the v4l2_device 963 prio state. */ 964 if (vdev->prio == NULL) 965 vdev->prio = &vdev->v4l2_dev->prio; 966 967 /* Part 2: find a free minor, device node number and device index. */ 968 #ifdef CONFIG_VIDEO_FIXED_MINOR_RANGES 969 /* Keep the ranges for the first four types for historical 970 * reasons. 971 * Newer devices (not yet in place) should use the range 972 * of 128-191 and just pick the first free minor there 973 * (new style). */ 974 switch (type) { 975 case VFL_TYPE_VIDEO: 976 minor_offset = 0; 977 minor_cnt = 64; 978 break; 979 case VFL_TYPE_RADIO: 980 minor_offset = 64; 981 minor_cnt = 64; 982 break; 983 case VFL_TYPE_VBI: 984 minor_offset = 224; 985 minor_cnt = 32; 986 break; 987 default: 988 minor_offset = 128; 989 minor_cnt = 64; 990 break; 991 } 992 #endif 993 994 /* Pick a device node number */ 995 mutex_lock(&videodev_lock); 996 nr = devnode_find(vdev, nr == -1 ? 0 : nr, minor_cnt); 997 if (nr == minor_cnt) 998 nr = devnode_find(vdev, 0, minor_cnt); 999 if (nr == minor_cnt) { 1000 pr_err("could not get a free device node number\n"); 1001 mutex_unlock(&videodev_lock); 1002 return -ENFILE; 1003 } 1004 #ifdef CONFIG_VIDEO_FIXED_MINOR_RANGES 1005 /* 1-on-1 mapping of device node number to minor number */ 1006 i = nr; 1007 #else 1008 /* The device node number and minor numbers are independent, so 1009 we just find the first free minor number. */ 1010 for (i = 0; i < VIDEO_NUM_DEVICES; i++) 1011 if (video_devices[i] == NULL) 1012 break; 1013 if (i == VIDEO_NUM_DEVICES) { 1014 mutex_unlock(&videodev_lock); 1015 pr_err("could not get a free minor\n"); 1016 return -ENFILE; 1017 } 1018 #endif 1019 vdev->minor = i + minor_offset; 1020 vdev->num = nr; 1021 1022 /* Should not happen since we thought this minor was free */ 1023 if (WARN_ON(video_devices[vdev->minor])) { 1024 mutex_unlock(&videodev_lock); 1025 pr_err("video_device not empty!\n"); 1026 return -ENFILE; 1027 } 1028 devnode_set(vdev); 1029 vdev->index = get_index(vdev); 1030 video_devices[vdev->minor] = vdev; 1031 mutex_unlock(&videodev_lock); 1032 1033 if (vdev->ioctl_ops) 1034 determine_valid_ioctls(vdev); 1035 1036 /* Part 3: Initialize the character device */ 1037 vdev->cdev = cdev_alloc(); 1038 if (vdev->cdev == NULL) { 1039 ret = -ENOMEM; 1040 goto cleanup; 1041 } 1042 vdev->cdev->ops = &v4l2_fops; 1043 vdev->cdev->owner = owner; 1044 ret = cdev_add(vdev->cdev, MKDEV(VIDEO_MAJOR, vdev->minor), 1); 1045 if (ret < 0) { 1046 pr_err("%s: cdev_add failed\n", __func__); 1047 kfree(vdev->cdev); 1048 vdev->cdev = NULL; 1049 goto cleanup; 1050 } 1051 1052 /* Part 4: register the device with sysfs */ 1053 vdev->dev.class = &video_class; 1054 vdev->dev.devt = MKDEV(VIDEO_MAJOR, vdev->minor); 1055 vdev->dev.parent = vdev->dev_parent; 1056 dev_set_name(&vdev->dev, "%s%d", name_base, vdev->num); 1057 mutex_lock(&videodev_lock); 1058 ret = device_register(&vdev->dev); 1059 if (ret < 0) { 1060 mutex_unlock(&videodev_lock); 1061 pr_err("%s: device_register failed\n", __func__); 1062 goto cleanup; 1063 } 1064 /* Register the release callback that will be called when the last 1065 reference to the device goes away. */ 1066 vdev->dev.release = v4l2_device_release; 1067 1068 if (nr != -1 && nr != vdev->num && warn_if_nr_in_use) 1069 pr_warn("%s: requested %s%d, got %s\n", __func__, 1070 name_base, nr, video_device_node_name(vdev)); 1071 1072 /* Increase v4l2_device refcount */ 1073 v4l2_device_get(vdev->v4l2_dev); 1074 1075 /* Part 5: Register the entity. */ 1076 ret = video_register_media_controller(vdev); 1077 1078 /* Part 6: Activate this minor. The char device can now be used. */ 1079 set_bit(V4L2_FL_REGISTERED, &vdev->flags); 1080 mutex_unlock(&videodev_lock); 1081 1082 return 0; 1083 1084 cleanup: 1085 mutex_lock(&videodev_lock); 1086 if (vdev->cdev) 1087 cdev_del(vdev->cdev); 1088 video_devices[vdev->minor] = NULL; 1089 devnode_clear(vdev); 1090 mutex_unlock(&videodev_lock); 1091 /* Mark this video device as never having been registered. */ 1092 vdev->minor = -1; 1093 return ret; 1094 } 1095 EXPORT_SYMBOL(__video_register_device); 1096 1097 /** 1098 * video_unregister_device - unregister a video4linux device 1099 * @vdev: the device to unregister 1100 * 1101 * This unregisters the passed device. Future open calls will 1102 * be met with errors. 1103 */ 1104 void video_unregister_device(struct video_device *vdev) 1105 { 1106 /* Check if vdev was ever registered at all */ 1107 if (!vdev || !video_is_registered(vdev)) 1108 return; 1109 1110 mutex_lock(&videodev_lock); 1111 /* This must be in a critical section to prevent a race with v4l2_open. 1112 * Once this bit has been cleared video_get may never be called again. 1113 */ 1114 clear_bit(V4L2_FL_REGISTERED, &vdev->flags); 1115 mutex_unlock(&videodev_lock); 1116 if (test_bit(V4L2_FL_USES_V4L2_FH, &vdev->flags)) 1117 v4l2_event_wake_all(vdev); 1118 device_unregister(&vdev->dev); 1119 } 1120 EXPORT_SYMBOL(video_unregister_device); 1121 1122 #if defined(CONFIG_MEDIA_CONTROLLER) 1123 1124 __must_check int video_device_pipeline_start(struct video_device *vdev, 1125 struct media_pipeline *pipe) 1126 { 1127 struct media_entity *entity = &vdev->entity; 1128 1129 if (entity->num_pads != 1) 1130 return -ENODEV; 1131 1132 return media_pipeline_start(&entity->pads[0], pipe); 1133 } 1134 EXPORT_SYMBOL_GPL(video_device_pipeline_start); 1135 1136 __must_check int __video_device_pipeline_start(struct video_device *vdev, 1137 struct media_pipeline *pipe) 1138 { 1139 struct media_entity *entity = &vdev->entity; 1140 1141 if (entity->num_pads != 1) 1142 return -ENODEV; 1143 1144 return __media_pipeline_start(&entity->pads[0], pipe); 1145 } 1146 EXPORT_SYMBOL_GPL(__video_device_pipeline_start); 1147 1148 void video_device_pipeline_stop(struct video_device *vdev) 1149 { 1150 struct media_entity *entity = &vdev->entity; 1151 1152 if (WARN_ON(entity->num_pads != 1)) 1153 return; 1154 1155 return media_pipeline_stop(&entity->pads[0]); 1156 } 1157 EXPORT_SYMBOL_GPL(video_device_pipeline_stop); 1158 1159 void __video_device_pipeline_stop(struct video_device *vdev) 1160 { 1161 struct media_entity *entity = &vdev->entity; 1162 1163 if (WARN_ON(entity->num_pads != 1)) 1164 return; 1165 1166 return __media_pipeline_stop(&entity->pads[0]); 1167 } 1168 EXPORT_SYMBOL_GPL(__video_device_pipeline_stop); 1169 1170 __must_check int video_device_pipeline_alloc_start(struct video_device *vdev) 1171 { 1172 struct media_entity *entity = &vdev->entity; 1173 1174 if (entity->num_pads != 1) 1175 return -ENODEV; 1176 1177 return media_pipeline_alloc_start(&entity->pads[0]); 1178 } 1179 EXPORT_SYMBOL_GPL(video_device_pipeline_alloc_start); 1180 1181 struct media_pipeline *video_device_pipeline(struct video_device *vdev) 1182 { 1183 struct media_entity *entity = &vdev->entity; 1184 1185 if (WARN_ON(entity->num_pads != 1)) 1186 return NULL; 1187 1188 return media_pad_pipeline(&entity->pads[0]); 1189 } 1190 EXPORT_SYMBOL_GPL(video_device_pipeline); 1191 1192 #endif /* CONFIG_MEDIA_CONTROLLER */ 1193 1194 /* 1195 * Initialise video for linux 1196 */ 1197 static int __init videodev_init(void) 1198 { 1199 dev_t dev = MKDEV(VIDEO_MAJOR, 0); 1200 int ret; 1201 1202 pr_info("Linux video capture interface: v2.00\n"); 1203 ret = register_chrdev_region(dev, VIDEO_NUM_DEVICES, VIDEO_NAME); 1204 if (ret < 0) { 1205 pr_warn("videodev: unable to get major %d\n", 1206 VIDEO_MAJOR); 1207 return ret; 1208 } 1209 1210 ret = class_register(&video_class); 1211 if (ret < 0) { 1212 unregister_chrdev_region(dev, VIDEO_NUM_DEVICES); 1213 pr_warn("video_dev: class_register failed\n"); 1214 return -EIO; 1215 } 1216 1217 return 0; 1218 } 1219 1220 static void __exit videodev_exit(void) 1221 { 1222 dev_t dev = MKDEV(VIDEO_MAJOR, 0); 1223 1224 class_unregister(&video_class); 1225 unregister_chrdev_region(dev, VIDEO_NUM_DEVICES); 1226 } 1227 1228 subsys_initcall(videodev_init); 1229 module_exit(videodev_exit) 1230 1231 MODULE_AUTHOR("Alan Cox, Mauro Carvalho Chehab <mchehab@kernel.org>, Bill Dirks, Justin Schoeman, Gerd Knorr"); 1232 MODULE_DESCRIPTION("Video4Linux2 core driver"); 1233 MODULE_LICENSE("GPL"); 1234 MODULE_ALIAS_CHARDEV_MAJOR(VIDEO_MAJOR); 1235