1 // SPDX-License-Identifier: GPL-2.0-or-later
3 * Video capture interface for Linux version 2
5 * A generic video device interface for the LINUX operating system
6 * using a set of device structures/vectors for low level operations.
8 * Authors: Alan Cox, <alan@lxorguk.ukuu.org.uk> (version 1)
9 * Mauro Carvalho Chehab <mchehab@kernel.org> (version 2)
11 * Fixes: 20000516 Claudio Matsuoka <claudio@conectiva.com>
12 * - Added procfs support
15 #define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
17 #include <linux/debugfs.h>
18 #include <linux/module.h>
19 #include <linux/types.h>
20 #include <linux/kernel.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>
29 #include <media/v4l2-common.h>
30 #include <media/v4l2-device.h>
31 #include <media/v4l2-ioctl.h>
32 #include <media/v4l2-event.h>
34 #define VIDEO_NUM_DEVICES 256
35 #define VIDEO_NAME "video4linux"
37 #define dprintk(fmt, arg...) do { \
38 printk(KERN_DEBUG pr_fmt("%s: " fmt), \
46 static ssize_t index_show(struct device *cd,
47 struct device_attribute *attr, char *buf)
49 struct video_device *vdev = to_video_device(cd);
51 return sprintf(buf, "%i\n", vdev->index);
53 static DEVICE_ATTR_RO(index);
55 static ssize_t dev_debug_show(struct device *cd,
56 struct device_attribute *attr, char *buf)
58 struct video_device *vdev = to_video_device(cd);
60 return sprintf(buf, "%i\n", vdev->dev_debug);
63 static ssize_t dev_debug_store(struct device *cd, struct device_attribute *attr,
64 const char *buf, size_t len)
66 struct video_device *vdev = to_video_device(cd);
70 res = kstrtou16(buf, 0, &value);
74 vdev->dev_debug = value;
77 static DEVICE_ATTR_RW(dev_debug);
79 static ssize_t name_show(struct device *cd,
80 struct device_attribute *attr, char *buf)
82 struct video_device *vdev = to_video_device(cd);
84 return sprintf(buf, "%.*s\n", (int)sizeof(vdev->name), vdev->name);
86 static DEVICE_ATTR_RO(name);
88 static struct attribute *video_device_attrs[] = {
90 &dev_attr_dev_debug.attr,
94 ATTRIBUTE_GROUPS(video_device);
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);
103 /* Device node utility functions */
105 /* Note: these utility functions all assume that vfl_type is in the range
106 [0, VFL_TYPE_MAX-1]. */
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)
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;
117 return devnode_nums[idx];
120 /* Return the bitmap corresponding to vfl_type. */
121 static inline unsigned long *devnode_bits(enum vfl_devnode_type vfl_type)
123 return devnode_nums[vfl_type];
127 /* Mark device node number vdev->num as used */
128 static inline void devnode_set(struct video_device *vdev)
130 set_bit(vdev->num, devnode_bits(vdev->vfl_type));
133 /* Mark device node number vdev->num as unused */
134 static inline void devnode_clear(struct video_device *vdev)
136 clear_bit(vdev->num, devnode_bits(vdev->vfl_type));
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)
142 return find_next_zero_bit(devnode_bits(vdev->vfl_type), to, from);
145 struct video_device *video_device_alloc(void)
147 return kzalloc(sizeof(struct video_device), GFP_KERNEL);
149 EXPORT_SYMBOL(video_device_alloc);
151 void video_device_release(struct video_device *vdev)
155 EXPORT_SYMBOL(video_device_release);
157 void video_device_release_empty(struct video_device *vdev)
160 /* Only valid when the video_device struct is a static. */
162 EXPORT_SYMBOL(video_device_release_empty);
164 static inline void video_get(struct video_device *vdev)
166 get_device(&vdev->dev);
169 static inline void video_put(struct video_device *vdev)
171 put_device(&vdev->dev);
174 /* Called when the last user of the video device exits. */
175 static void v4l2_device_release(struct device *cd)
177 struct video_device *vdev = to_video_device(cd);
178 struct v4l2_device *v4l2_dev = vdev->v4l2_dev;
180 mutex_lock(&videodev_lock);
181 if (WARN_ON(video_devices[vdev->minor] != vdev)) {
182 /* should not happen */
183 mutex_unlock(&videodev_lock);
187 /* Free up this device for reuse */
188 video_devices[vdev->minor] = NULL;
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. */
196 /* Mark device node number as free */
199 mutex_unlock(&videodev_lock);
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);
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.
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.
218 if (v4l2_dev->release == NULL)
221 /* Release video_device and perform other
222 cleanups as needed. */
225 /* Decrease v4l2_device refcount */
227 v4l2_device_put(v4l2_dev);
230 static struct class video_class = {
232 .dev_groups = video_device_groups,
235 struct video_device *video_devdata(struct file *file)
237 return video_devices[iminor(file_inode(file))];
239 EXPORT_SYMBOL(video_devdata);
242 /* Priority handling */
244 static inline bool prio_is_valid(enum v4l2_priority prio)
246 return prio == V4L2_PRIORITY_BACKGROUND ||
247 prio == V4L2_PRIORITY_INTERACTIVE ||
248 prio == V4L2_PRIORITY_RECORD;
251 void v4l2_prio_init(struct v4l2_prio_state *global)
253 memset(global, 0, sizeof(*global));
255 EXPORT_SYMBOL(v4l2_prio_init);
257 int v4l2_prio_change(struct v4l2_prio_state *global, enum v4l2_priority *local,
258 enum v4l2_priority new)
260 if (!prio_is_valid(new))
265 atomic_inc(&global->prios[new]);
266 if (prio_is_valid(*local))
267 atomic_dec(&global->prios[*local]);
271 EXPORT_SYMBOL(v4l2_prio_change);
273 void v4l2_prio_open(struct v4l2_prio_state *global, enum v4l2_priority *local)
275 v4l2_prio_change(global, local, V4L2_PRIORITY_DEFAULT);
277 EXPORT_SYMBOL(v4l2_prio_open);
279 void v4l2_prio_close(struct v4l2_prio_state *global, enum v4l2_priority local)
281 if (prio_is_valid(local))
282 atomic_dec(&global->prios[local]);
284 EXPORT_SYMBOL(v4l2_prio_close);
286 enum v4l2_priority v4l2_prio_max(struct v4l2_prio_state *global)
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;
296 EXPORT_SYMBOL(v4l2_prio_max);
298 int v4l2_prio_check(struct v4l2_prio_state *global, enum v4l2_priority local)
300 return (local < v4l2_prio_max(global)) ? -EBUSY : 0;
302 EXPORT_SYMBOL(v4l2_prio_check);
305 static ssize_t v4l2_read(struct file *filp, char __user *buf,
306 size_t sz, loff_t *off)
308 struct video_device *vdev = video_devdata(filp);
311 if (!vdev->fops->read)
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);
322 static ssize_t v4l2_write(struct file *filp, const char __user *buf,
323 size_t sz, loff_t *off)
325 struct video_device *vdev = video_devdata(filp);
328 if (!vdev->fops->write)
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);
339 static __poll_t v4l2_poll(struct file *filp, struct poll_table_struct *poll)
341 struct video_device *vdev = video_devdata(filp);
342 __poll_t res = EPOLLERR | EPOLLHUP | EPOLLPRI;
344 if (video_is_registered(vdev)) {
345 if (!vdev->fops->poll)
346 res = DEFAULT_POLLMASK;
348 res = vdev->fops->poll(filp, poll);
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));
357 static long v4l2_ioctl(struct file *filp, unsigned int cmd, unsigned long arg)
359 struct video_device *vdev = video_devdata(filp);
362 if (vdev->fops->unlocked_ioctl) {
363 if (video_is_registered(vdev))
364 ret = vdev->fops->unlocked_ioctl(filp, cmd, arg);
372 #define v4l2_get_unmapped_area NULL
374 static unsigned long v4l2_get_unmapped_area(struct file *filp,
375 unsigned long addr, unsigned long len, unsigned long pgoff,
378 struct video_device *vdev = video_devdata(filp);
381 if (!vdev->fops->get_unmapped_area)
383 if (!video_is_registered(vdev))
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);
393 static int v4l2_mmap(struct file *filp, struct vm_area_struct *vm)
395 struct video_device *vdev = video_devdata(filp);
398 if (!vdev->fops->mmap)
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);
408 /* Override for the open function */
409 static int v4l2_open(struct inode *inode, struct file *filp)
411 struct video_device *vdev;
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);
422 /* and increase the device refcount */
424 mutex_unlock(&videodev_lock);
425 if (vdev->fops->open) {
426 if (video_is_registered(vdev))
427 ret = vdev->fops->open(filp);
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 */
441 /* Override for the release function */
442 static int v4l2_release(struct inode *inode, struct file *filp)
444 struct video_device *vdev = video_devdata(filp);
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.
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);
459 ret = vdev->fops->release(filp);
463 if (vdev->dev_debug & V4L2_DEV_DEBUG_FOP)
464 dprintk("%s: release\n",
465 video_device_node_name(vdev));
467 /* decrease the refcount unconditionally since the release()
468 return value is ignored. */
473 static const struct file_operations v4l2_fops = {
474 .owner = THIS_MODULE,
478 .get_unmapped_area = v4l2_get_unmapped_area,
480 .unlocked_ioctl = v4l2_ioctl,
482 .compat_ioctl = v4l2_compat_ioctl32,
484 .release = v4l2_release,
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
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.
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.
500 * Returns a free index number.
502 static int get_index(struct video_device *vdev)
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);
509 bitmap_zero(used, VIDEO_NUM_DEVICES);
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);
518 return find_first_zero_bit(used, VIDEO_NUM_DEVICES);
521 #define SET_VALID_IOCTL(ops, cmd, op) \
522 do { if ((ops)->op) __set_bit(_IOC_NR(cmd), valid_ioctls); } while (0)
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
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.
532 It does that by first setting up the local valid_ioctls bitmap, and
535 vdev->valid_ioctls = valid_ioctls & ~(vdev->valid_ioctls)
537 static void determine_valid_ioctls(struct video_device *vdev)
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;
561 bitmap_zero(valid_ioctls, BASE_VIDIOC_PRIVATE);
563 /* vfl_type and vfl_dir independent ioctls */
565 SET_VALID_IOCTL(ops, VIDIOC_QUERYCAP, vidioc_querycap);
566 __set_bit(_IOC_NR(VIDIOC_G_PRIORITY), valid_ioctls);
567 __set_bit(_IOC_NR(VIDIOC_S_PRIORITY), valid_ioctls);
569 /* Note: the control handler can also be passed through the filehandle,
570 and that can't be tested here. If the bit for these control ioctls
571 is set, then the ioctl is valid. But if it is 0, then it can still
572 be valid if the filehandle passed the control handler. */
573 if (vdev->ctrl_handler || ops->vidioc_queryctrl)
574 __set_bit(_IOC_NR(VIDIOC_QUERYCTRL), valid_ioctls);
575 if (vdev->ctrl_handler || ops->vidioc_query_ext_ctrl)
576 __set_bit(_IOC_NR(VIDIOC_QUERY_EXT_CTRL), valid_ioctls);
577 if (vdev->ctrl_handler || ops->vidioc_g_ctrl || ops->vidioc_g_ext_ctrls)
578 __set_bit(_IOC_NR(VIDIOC_G_CTRL), valid_ioctls);
579 if (vdev->ctrl_handler || ops->vidioc_s_ctrl || ops->vidioc_s_ext_ctrls)
580 __set_bit(_IOC_NR(VIDIOC_S_CTRL), valid_ioctls);
581 if (vdev->ctrl_handler || ops->vidioc_g_ext_ctrls)
582 __set_bit(_IOC_NR(VIDIOC_G_EXT_CTRLS), valid_ioctls);
583 if (vdev->ctrl_handler || ops->vidioc_s_ext_ctrls)
584 __set_bit(_IOC_NR(VIDIOC_S_EXT_CTRLS), valid_ioctls);
585 if (vdev->ctrl_handler || ops->vidioc_try_ext_ctrls)
586 __set_bit(_IOC_NR(VIDIOC_TRY_EXT_CTRLS), valid_ioctls);
587 if (vdev->ctrl_handler || ops->vidioc_querymenu)
588 __set_bit(_IOC_NR(VIDIOC_QUERYMENU), valid_ioctls);
590 SET_VALID_IOCTL(ops, VIDIOC_G_FREQUENCY, vidioc_g_frequency);
591 SET_VALID_IOCTL(ops, VIDIOC_S_FREQUENCY, vidioc_s_frequency);
593 SET_VALID_IOCTL(ops, VIDIOC_LOG_STATUS, vidioc_log_status);
594 #ifdef CONFIG_VIDEO_ADV_DEBUG
595 __set_bit(_IOC_NR(VIDIOC_DBG_G_CHIP_INFO), valid_ioctls);
596 __set_bit(_IOC_NR(VIDIOC_DBG_G_REGISTER), valid_ioctls);
597 __set_bit(_IOC_NR(VIDIOC_DBG_S_REGISTER), valid_ioctls);
599 /* yes, really vidioc_subscribe_event */
600 SET_VALID_IOCTL(ops, VIDIOC_DQEVENT, vidioc_subscribe_event);
601 SET_VALID_IOCTL(ops, VIDIOC_SUBSCRIBE_EVENT, vidioc_subscribe_event);
602 SET_VALID_IOCTL(ops, VIDIOC_UNSUBSCRIBE_EVENT, vidioc_unsubscribe_event);
603 if (ops->vidioc_enum_freq_bands || ops->vidioc_g_tuner || ops->vidioc_g_modulator)
604 __set_bit(_IOC_NR(VIDIOC_ENUM_FREQ_BANDS), valid_ioctls);
607 /* video specific ioctls */
608 if ((is_rx && (ops->vidioc_enum_fmt_vid_cap ||
609 ops->vidioc_enum_fmt_vid_overlay)) ||
610 (is_tx && ops->vidioc_enum_fmt_vid_out))
611 __set_bit(_IOC_NR(VIDIOC_ENUM_FMT), valid_ioctls);
612 if ((is_rx && (ops->vidioc_g_fmt_vid_cap ||
613 ops->vidioc_g_fmt_vid_cap_mplane ||
614 ops->vidioc_g_fmt_vid_overlay)) ||
615 (is_tx && (ops->vidioc_g_fmt_vid_out ||
616 ops->vidioc_g_fmt_vid_out_mplane ||
617 ops->vidioc_g_fmt_vid_out_overlay)))
618 __set_bit(_IOC_NR(VIDIOC_G_FMT), valid_ioctls);
619 if ((is_rx && (ops->vidioc_s_fmt_vid_cap ||
620 ops->vidioc_s_fmt_vid_cap_mplane ||
621 ops->vidioc_s_fmt_vid_overlay)) ||
622 (is_tx && (ops->vidioc_s_fmt_vid_out ||
623 ops->vidioc_s_fmt_vid_out_mplane ||
624 ops->vidioc_s_fmt_vid_out_overlay)))
625 __set_bit(_IOC_NR(VIDIOC_S_FMT), valid_ioctls);
626 if ((is_rx && (ops->vidioc_try_fmt_vid_cap ||
627 ops->vidioc_try_fmt_vid_cap_mplane ||
628 ops->vidioc_try_fmt_vid_overlay)) ||
629 (is_tx && (ops->vidioc_try_fmt_vid_out ||
630 ops->vidioc_try_fmt_vid_out_mplane ||
631 ops->vidioc_try_fmt_vid_out_overlay)))
632 __set_bit(_IOC_NR(VIDIOC_TRY_FMT), valid_ioctls);
633 SET_VALID_IOCTL(ops, VIDIOC_OVERLAY, vidioc_overlay);
634 SET_VALID_IOCTL(ops, VIDIOC_G_FBUF, vidioc_g_fbuf);
635 SET_VALID_IOCTL(ops, VIDIOC_S_FBUF, vidioc_s_fbuf);
636 SET_VALID_IOCTL(ops, VIDIOC_G_JPEGCOMP, vidioc_g_jpegcomp);
637 SET_VALID_IOCTL(ops, VIDIOC_S_JPEGCOMP, vidioc_s_jpegcomp);
638 SET_VALID_IOCTL(ops, VIDIOC_G_ENC_INDEX, vidioc_g_enc_index);
639 SET_VALID_IOCTL(ops, VIDIOC_ENCODER_CMD, vidioc_encoder_cmd);
640 SET_VALID_IOCTL(ops, VIDIOC_TRY_ENCODER_CMD, vidioc_try_encoder_cmd);
641 SET_VALID_IOCTL(ops, VIDIOC_DECODER_CMD, vidioc_decoder_cmd);
642 SET_VALID_IOCTL(ops, VIDIOC_TRY_DECODER_CMD, vidioc_try_decoder_cmd);
643 SET_VALID_IOCTL(ops, VIDIOC_ENUM_FRAMESIZES, vidioc_enum_framesizes);
644 SET_VALID_IOCTL(ops, VIDIOC_ENUM_FRAMEINTERVALS, vidioc_enum_frameintervals);
645 if (ops->vidioc_g_selection &&
646 !test_bit(_IOC_NR(VIDIOC_G_SELECTION), vdev->valid_ioctls)) {
647 __set_bit(_IOC_NR(VIDIOC_G_CROP), valid_ioctls);
648 __set_bit(_IOC_NR(VIDIOC_CROPCAP), valid_ioctls);
650 if (ops->vidioc_s_selection &&
651 !test_bit(_IOC_NR(VIDIOC_S_SELECTION), vdev->valid_ioctls))
652 __set_bit(_IOC_NR(VIDIOC_S_CROP), valid_ioctls);
653 SET_VALID_IOCTL(ops, VIDIOC_G_SELECTION, vidioc_g_selection);
654 SET_VALID_IOCTL(ops, VIDIOC_S_SELECTION, vidioc_s_selection);
656 if (is_meta && is_rx) {
657 /* metadata capture specific ioctls */
658 SET_VALID_IOCTL(ops, VIDIOC_ENUM_FMT, vidioc_enum_fmt_meta_cap);
659 SET_VALID_IOCTL(ops, VIDIOC_G_FMT, vidioc_g_fmt_meta_cap);
660 SET_VALID_IOCTL(ops, VIDIOC_S_FMT, vidioc_s_fmt_meta_cap);
661 SET_VALID_IOCTL(ops, VIDIOC_TRY_FMT, vidioc_try_fmt_meta_cap);
662 } else if (is_meta && is_tx) {
663 /* metadata output specific ioctls */
664 SET_VALID_IOCTL(ops, VIDIOC_ENUM_FMT, vidioc_enum_fmt_meta_out);
665 SET_VALID_IOCTL(ops, VIDIOC_G_FMT, vidioc_g_fmt_meta_out);
666 SET_VALID_IOCTL(ops, VIDIOC_S_FMT, vidioc_s_fmt_meta_out);
667 SET_VALID_IOCTL(ops, VIDIOC_TRY_FMT, vidioc_try_fmt_meta_out);
670 /* vbi specific ioctls */
671 if ((is_rx && (ops->vidioc_g_fmt_vbi_cap ||
672 ops->vidioc_g_fmt_sliced_vbi_cap)) ||
673 (is_tx && (ops->vidioc_g_fmt_vbi_out ||
674 ops->vidioc_g_fmt_sliced_vbi_out)))
675 __set_bit(_IOC_NR(VIDIOC_G_FMT), valid_ioctls);
676 if ((is_rx && (ops->vidioc_s_fmt_vbi_cap ||
677 ops->vidioc_s_fmt_sliced_vbi_cap)) ||
678 (is_tx && (ops->vidioc_s_fmt_vbi_out ||
679 ops->vidioc_s_fmt_sliced_vbi_out)))
680 __set_bit(_IOC_NR(VIDIOC_S_FMT), valid_ioctls);
681 if ((is_rx && (ops->vidioc_try_fmt_vbi_cap ||
682 ops->vidioc_try_fmt_sliced_vbi_cap)) ||
683 (is_tx && (ops->vidioc_try_fmt_vbi_out ||
684 ops->vidioc_try_fmt_sliced_vbi_out)))
685 __set_bit(_IOC_NR(VIDIOC_TRY_FMT), valid_ioctls);
686 SET_VALID_IOCTL(ops, VIDIOC_G_SLICED_VBI_CAP, vidioc_g_sliced_vbi_cap);
688 /* touch specific ioctls */
689 SET_VALID_IOCTL(ops, VIDIOC_ENUM_FMT, vidioc_enum_fmt_vid_cap);
690 SET_VALID_IOCTL(ops, VIDIOC_G_FMT, vidioc_g_fmt_vid_cap);
691 SET_VALID_IOCTL(ops, VIDIOC_S_FMT, vidioc_s_fmt_vid_cap);
692 SET_VALID_IOCTL(ops, VIDIOC_TRY_FMT, vidioc_try_fmt_vid_cap);
693 SET_VALID_IOCTL(ops, VIDIOC_ENUM_FRAMESIZES, vidioc_enum_framesizes);
694 SET_VALID_IOCTL(ops, VIDIOC_ENUM_FRAMEINTERVALS, vidioc_enum_frameintervals);
695 SET_VALID_IOCTL(ops, VIDIOC_ENUMINPUT, vidioc_enum_input);
696 SET_VALID_IOCTL(ops, VIDIOC_G_INPUT, vidioc_g_input);
697 SET_VALID_IOCTL(ops, VIDIOC_S_INPUT, vidioc_s_input);
698 SET_VALID_IOCTL(ops, VIDIOC_G_PARM, vidioc_g_parm);
699 SET_VALID_IOCTL(ops, VIDIOC_S_PARM, vidioc_s_parm);
700 } else if (is_sdr && is_rx) {
701 /* SDR receiver specific ioctls */
702 SET_VALID_IOCTL(ops, VIDIOC_ENUM_FMT, vidioc_enum_fmt_sdr_cap);
703 SET_VALID_IOCTL(ops, VIDIOC_G_FMT, vidioc_g_fmt_sdr_cap);
704 SET_VALID_IOCTL(ops, VIDIOC_S_FMT, vidioc_s_fmt_sdr_cap);
705 SET_VALID_IOCTL(ops, VIDIOC_TRY_FMT, vidioc_try_fmt_sdr_cap);
706 } else if (is_sdr && is_tx) {
707 /* SDR transmitter specific ioctls */
708 SET_VALID_IOCTL(ops, VIDIOC_ENUM_FMT, vidioc_enum_fmt_sdr_out);
709 SET_VALID_IOCTL(ops, VIDIOC_G_FMT, vidioc_g_fmt_sdr_out);
710 SET_VALID_IOCTL(ops, VIDIOC_S_FMT, vidioc_s_fmt_sdr_out);
711 SET_VALID_IOCTL(ops, VIDIOC_TRY_FMT, vidioc_try_fmt_sdr_out);
715 /* ioctls valid for streaming I/O */
716 SET_VALID_IOCTL(ops, VIDIOC_REQBUFS, vidioc_reqbufs);
717 SET_VALID_IOCTL(ops, VIDIOC_QUERYBUF, vidioc_querybuf);
718 SET_VALID_IOCTL(ops, VIDIOC_QBUF, vidioc_qbuf);
719 SET_VALID_IOCTL(ops, VIDIOC_EXPBUF, vidioc_expbuf);
720 SET_VALID_IOCTL(ops, VIDIOC_DQBUF, vidioc_dqbuf);
721 SET_VALID_IOCTL(ops, VIDIOC_CREATE_BUFS, vidioc_create_bufs);
722 SET_VALID_IOCTL(ops, VIDIOC_PREPARE_BUF, vidioc_prepare_buf);
723 SET_VALID_IOCTL(ops, VIDIOC_STREAMON, vidioc_streamon);
724 SET_VALID_IOCTL(ops, VIDIOC_STREAMOFF, vidioc_streamoff);
727 if (is_vid || is_vbi || is_meta) {
728 /* ioctls valid for video, vbi and metadata */
729 if (ops->vidioc_s_std)
730 __set_bit(_IOC_NR(VIDIOC_ENUMSTD), valid_ioctls);
731 SET_VALID_IOCTL(ops, VIDIOC_S_STD, vidioc_s_std);
732 SET_VALID_IOCTL(ops, VIDIOC_G_STD, vidioc_g_std);
734 SET_VALID_IOCTL(ops, VIDIOC_QUERYSTD, vidioc_querystd);
736 __set_bit(_IOC_NR(VIDIOC_ENUMINPUT), valid_ioctls);
737 __set_bit(_IOC_NR(VIDIOC_G_INPUT), valid_ioctls);
738 __set_bit(_IOC_NR(VIDIOC_S_INPUT), valid_ioctls);
740 SET_VALID_IOCTL(ops, VIDIOC_ENUMINPUT, vidioc_enum_input);
741 SET_VALID_IOCTL(ops, VIDIOC_G_INPUT, vidioc_g_input);
742 SET_VALID_IOCTL(ops, VIDIOC_S_INPUT, vidioc_s_input);
744 SET_VALID_IOCTL(ops, VIDIOC_ENUMAUDIO, vidioc_enumaudio);
745 SET_VALID_IOCTL(ops, VIDIOC_G_AUDIO, vidioc_g_audio);
746 SET_VALID_IOCTL(ops, VIDIOC_S_AUDIO, vidioc_s_audio);
747 SET_VALID_IOCTL(ops, VIDIOC_QUERY_DV_TIMINGS, vidioc_query_dv_timings);
748 SET_VALID_IOCTL(ops, VIDIOC_S_EDID, vidioc_s_edid);
752 __set_bit(_IOC_NR(VIDIOC_ENUMOUTPUT), valid_ioctls);
753 __set_bit(_IOC_NR(VIDIOC_G_OUTPUT), valid_ioctls);
754 __set_bit(_IOC_NR(VIDIOC_S_OUTPUT), valid_ioctls);
756 SET_VALID_IOCTL(ops, VIDIOC_ENUMOUTPUT, vidioc_enum_output);
757 SET_VALID_IOCTL(ops, VIDIOC_G_OUTPUT, vidioc_g_output);
758 SET_VALID_IOCTL(ops, VIDIOC_S_OUTPUT, vidioc_s_output);
760 SET_VALID_IOCTL(ops, VIDIOC_ENUMAUDOUT, vidioc_enumaudout);
761 SET_VALID_IOCTL(ops, VIDIOC_G_AUDOUT, vidioc_g_audout);
762 SET_VALID_IOCTL(ops, VIDIOC_S_AUDOUT, vidioc_s_audout);
764 if (ops->vidioc_g_parm || ops->vidioc_g_std)
765 __set_bit(_IOC_NR(VIDIOC_G_PARM), valid_ioctls);
766 SET_VALID_IOCTL(ops, VIDIOC_S_PARM, vidioc_s_parm);
767 SET_VALID_IOCTL(ops, VIDIOC_S_DV_TIMINGS, vidioc_s_dv_timings);
768 SET_VALID_IOCTL(ops, VIDIOC_G_DV_TIMINGS, vidioc_g_dv_timings);
769 SET_VALID_IOCTL(ops, VIDIOC_ENUM_DV_TIMINGS, vidioc_enum_dv_timings);
770 SET_VALID_IOCTL(ops, VIDIOC_DV_TIMINGS_CAP, vidioc_dv_timings_cap);
771 SET_VALID_IOCTL(ops, VIDIOC_G_EDID, vidioc_g_edid);
773 if (is_tx && (is_radio || is_sdr)) {
774 /* radio transmitter only ioctls */
775 SET_VALID_IOCTL(ops, VIDIOC_G_MODULATOR, vidioc_g_modulator);
776 SET_VALID_IOCTL(ops, VIDIOC_S_MODULATOR, vidioc_s_modulator);
778 if (is_rx && !is_tch) {
779 /* receiver only ioctls */
780 SET_VALID_IOCTL(ops, VIDIOC_G_TUNER, vidioc_g_tuner);
781 SET_VALID_IOCTL(ops, VIDIOC_S_TUNER, vidioc_s_tuner);
782 SET_VALID_IOCTL(ops, VIDIOC_S_HW_FREQ_SEEK, vidioc_s_hw_freq_seek);
785 bitmap_andnot(vdev->valid_ioctls, valid_ioctls, vdev->valid_ioctls,
786 BASE_VIDIOC_PRIVATE);
789 static int video_register_media_controller(struct video_device *vdev)
791 #if defined(CONFIG_MEDIA_CONTROLLER)
795 /* Memory-to-memory devices are more complex and use
796 * their own function to register its mc entities.
798 if (!vdev->v4l2_dev->mdev || vdev->vfl_dir == VFL_DIR_M2M)
801 vdev->entity.obj_type = MEDIA_ENTITY_TYPE_VIDEO_DEVICE;
802 vdev->entity.function = MEDIA_ENT_F_UNKNOWN;
804 switch (vdev->vfl_type) {
806 intf_type = MEDIA_INTF_T_V4L_VIDEO;
807 vdev->entity.function = MEDIA_ENT_F_IO_V4L;
810 intf_type = MEDIA_INTF_T_V4L_VBI;
811 vdev->entity.function = MEDIA_ENT_F_IO_VBI;
814 intf_type = MEDIA_INTF_T_V4L_SWRADIO;
815 vdev->entity.function = MEDIA_ENT_F_IO_SWRADIO;
818 intf_type = MEDIA_INTF_T_V4L_TOUCH;
819 vdev->entity.function = MEDIA_ENT_F_IO_V4L;
822 intf_type = MEDIA_INTF_T_V4L_RADIO;
824 * Radio doesn't have an entity at the V4L2 side to represent
825 * radio input or output. Instead, the audio input/output goes
826 * via either physical wires or ALSA.
829 case VFL_TYPE_SUBDEV:
830 intf_type = MEDIA_INTF_T_V4L_SUBDEV;
831 /* Entity will be created via v4l2_device_register_subdev() */
837 if (vdev->entity.function != MEDIA_ENT_F_UNKNOWN) {
838 vdev->entity.name = vdev->name;
840 /* Needed just for backward compatibility with legacy MC API */
841 vdev->entity.info.dev.major = VIDEO_MAJOR;
842 vdev->entity.info.dev.minor = vdev->minor;
844 ret = media_device_register_entity(vdev->v4l2_dev->mdev,
847 pr_warn("%s: media_device_register_entity failed\n",
853 vdev->intf_devnode = media_devnode_create(vdev->v4l2_dev->mdev,
857 if (!vdev->intf_devnode) {
858 media_device_unregister_entity(&vdev->entity);
862 if (vdev->entity.function != MEDIA_ENT_F_UNKNOWN) {
863 struct media_link *link;
865 link = media_create_intf_link(&vdev->entity,
866 &vdev->intf_devnode->intf,
867 MEDIA_LNK_FL_ENABLED |
868 MEDIA_LNK_FL_IMMUTABLE);
870 media_devnode_remove(vdev->intf_devnode);
871 media_device_unregister_entity(&vdev->entity);
876 /* FIXME: how to create the other interface links? */
882 int __video_register_device(struct video_device *vdev,
883 enum vfl_devnode_type type,
884 int nr, int warn_if_nr_in_use,
885 struct module *owner)
889 int minor_offset = 0;
890 int minor_cnt = VIDEO_NUM_DEVICES;
891 const char *name_base;
893 /* A minor value of -1 marks this video device as never
894 having been registered */
897 /* the release callback MUST be present */
898 if (WARN_ON(!vdev->release))
900 /* the v4l2_dev pointer MUST be present */
901 if (WARN_ON(!vdev->v4l2_dev))
903 /* the device_caps field MUST be set for all but subdevs */
904 if (WARN_ON(type != VFL_TYPE_SUBDEV && !vdev->device_caps))
907 /* v4l2_fh support */
908 spin_lock_init(&vdev->fh_lock);
909 INIT_LIST_HEAD(&vdev->fh_list);
911 /* Part 1: check device type */
922 case VFL_TYPE_SUBDEV:
923 name_base = "v4l-subdev";
926 /* Use device name 'swradio' because 'sdr' was already taken. */
927 name_base = "swradio";
930 name_base = "v4l-touch";
933 pr_err("%s called with unknown type: %d\n",
938 vdev->vfl_type = type;
940 if (vdev->dev_parent == NULL)
941 vdev->dev_parent = vdev->v4l2_dev->dev;
942 if (vdev->ctrl_handler == NULL)
943 vdev->ctrl_handler = vdev->v4l2_dev->ctrl_handler;
944 /* If the prio state pointer is NULL, then use the v4l2_device
946 if (vdev->prio == NULL)
947 vdev->prio = &vdev->v4l2_dev->prio;
949 /* Part 2: find a free minor, device node number and device index. */
950 #ifdef CONFIG_VIDEO_FIXED_MINOR_RANGES
951 /* Keep the ranges for the first four types for historical
953 * Newer devices (not yet in place) should use the range
954 * of 128-191 and just pick the first free minor there
976 /* Pick a device node number */
977 mutex_lock(&videodev_lock);
978 nr = devnode_find(vdev, nr == -1 ? 0 : nr, minor_cnt);
980 nr = devnode_find(vdev, 0, minor_cnt);
981 if (nr == minor_cnt) {
982 pr_err("could not get a free device node number\n");
983 mutex_unlock(&videodev_lock);
986 #ifdef CONFIG_VIDEO_FIXED_MINOR_RANGES
987 /* 1-on-1 mapping of device node number to minor number */
990 /* The device node number and minor numbers are independent, so
991 we just find the first free minor number. */
992 for (i = 0; i < VIDEO_NUM_DEVICES; i++)
993 if (video_devices[i] == NULL)
995 if (i == VIDEO_NUM_DEVICES) {
996 mutex_unlock(&videodev_lock);
997 pr_err("could not get a free minor\n");
1001 vdev->minor = i + minor_offset;
1004 /* Should not happen since we thought this minor was free */
1005 if (WARN_ON(video_devices[vdev->minor])) {
1006 mutex_unlock(&videodev_lock);
1007 pr_err("video_device not empty!\n");
1011 vdev->index = get_index(vdev);
1012 video_devices[vdev->minor] = vdev;
1013 mutex_unlock(&videodev_lock);
1015 if (vdev->ioctl_ops)
1016 determine_valid_ioctls(vdev);
1018 /* Part 3: Initialize the character device */
1019 vdev->cdev = cdev_alloc();
1020 if (vdev->cdev == NULL) {
1024 vdev->cdev->ops = &v4l2_fops;
1025 vdev->cdev->owner = owner;
1026 ret = cdev_add(vdev->cdev, MKDEV(VIDEO_MAJOR, vdev->minor), 1);
1028 pr_err("%s: cdev_add failed\n", __func__);
1034 /* Part 4: register the device with sysfs */
1035 vdev->dev.class = &video_class;
1036 vdev->dev.devt = MKDEV(VIDEO_MAJOR, vdev->minor);
1037 vdev->dev.parent = vdev->dev_parent;
1038 dev_set_name(&vdev->dev, "%s%d", name_base, vdev->num);
1039 ret = device_register(&vdev->dev);
1041 pr_err("%s: device_register failed\n", __func__);
1044 /* Register the release callback that will be called when the last
1045 reference to the device goes away. */
1046 vdev->dev.release = v4l2_device_release;
1048 if (nr != -1 && nr != vdev->num && warn_if_nr_in_use)
1049 pr_warn("%s: requested %s%d, got %s\n", __func__,
1050 name_base, nr, video_device_node_name(vdev));
1052 /* Increase v4l2_device refcount */
1053 v4l2_device_get(vdev->v4l2_dev);
1055 /* Part 5: Register the entity. */
1056 ret = video_register_media_controller(vdev);
1058 /* Part 6: Activate this minor. The char device can now be used. */
1059 set_bit(V4L2_FL_REGISTERED, &vdev->flags);
1064 mutex_lock(&videodev_lock);
1066 cdev_del(vdev->cdev);
1067 video_devices[vdev->minor] = NULL;
1068 devnode_clear(vdev);
1069 mutex_unlock(&videodev_lock);
1070 /* Mark this video device as never having been registered. */
1074 EXPORT_SYMBOL(__video_register_device);
1077 * video_unregister_device - unregister a video4linux device
1078 * @vdev: the device to unregister
1080 * This unregisters the passed device. Future open calls will
1081 * be met with errors.
1083 void video_unregister_device(struct video_device *vdev)
1085 /* Check if vdev was ever registered at all */
1086 if (!vdev || !video_is_registered(vdev))
1089 mutex_lock(&videodev_lock);
1090 /* This must be in a critical section to prevent a race with v4l2_open.
1091 * Once this bit has been cleared video_get may never be called again.
1093 clear_bit(V4L2_FL_REGISTERED, &vdev->flags);
1094 mutex_unlock(&videodev_lock);
1095 if (test_bit(V4L2_FL_USES_V4L2_FH, &vdev->flags))
1096 v4l2_event_wake_all(vdev);
1097 device_unregister(&vdev->dev);
1099 EXPORT_SYMBOL(video_unregister_device);
1101 #if defined(CONFIG_MEDIA_CONTROLLER)
1103 __must_check int video_device_pipeline_start(struct video_device *vdev,
1104 struct media_pipeline *pipe)
1106 struct media_entity *entity = &vdev->entity;
1108 if (entity->num_pads != 1)
1111 return media_pipeline_start(&entity->pads[0], pipe);
1113 EXPORT_SYMBOL_GPL(video_device_pipeline_start);
1115 __must_check int __video_device_pipeline_start(struct video_device *vdev,
1116 struct media_pipeline *pipe)
1118 struct media_entity *entity = &vdev->entity;
1120 if (entity->num_pads != 1)
1123 return __media_pipeline_start(&entity->pads[0], pipe);
1125 EXPORT_SYMBOL_GPL(__video_device_pipeline_start);
1127 void video_device_pipeline_stop(struct video_device *vdev)
1129 struct media_entity *entity = &vdev->entity;
1131 if (WARN_ON(entity->num_pads != 1))
1134 return media_pipeline_stop(&entity->pads[0]);
1136 EXPORT_SYMBOL_GPL(video_device_pipeline_stop);
1138 void __video_device_pipeline_stop(struct video_device *vdev)
1140 struct media_entity *entity = &vdev->entity;
1142 if (WARN_ON(entity->num_pads != 1))
1145 return __media_pipeline_stop(&entity->pads[0]);
1147 EXPORT_SYMBOL_GPL(__video_device_pipeline_stop);
1149 __must_check int video_device_pipeline_alloc_start(struct video_device *vdev)
1151 struct media_entity *entity = &vdev->entity;
1153 if (entity->num_pads != 1)
1156 return media_pipeline_alloc_start(&entity->pads[0]);
1158 EXPORT_SYMBOL_GPL(video_device_pipeline_alloc_start);
1160 struct media_pipeline *video_device_pipeline(struct video_device *vdev)
1162 struct media_entity *entity = &vdev->entity;
1164 if (WARN_ON(entity->num_pads != 1))
1167 return media_pad_pipeline(&entity->pads[0]);
1169 EXPORT_SYMBOL_GPL(video_device_pipeline);
1171 #endif /* CONFIG_MEDIA_CONTROLLER */
1174 * Initialise video for linux
1176 static int __init videodev_init(void)
1178 dev_t dev = MKDEV(VIDEO_MAJOR, 0);
1181 pr_info("Linux video capture interface: v2.00\n");
1182 ret = register_chrdev_region(dev, VIDEO_NUM_DEVICES, VIDEO_NAME);
1184 pr_warn("videodev: unable to get major %d\n",
1189 ret = class_register(&video_class);
1191 unregister_chrdev_region(dev, VIDEO_NUM_DEVICES);
1192 pr_warn("video_dev: class_register failed\n");
1199 static void __exit videodev_exit(void)
1201 dev_t dev = MKDEV(VIDEO_MAJOR, 0);
1203 class_unregister(&video_class);
1204 unregister_chrdev_region(dev, VIDEO_NUM_DEVICES);
1207 subsys_initcall(videodev_init);
1208 module_exit(videodev_exit)
1210 MODULE_AUTHOR("Alan Cox, Mauro Carvalho Chehab <mchehab@kernel.org>, Bill Dirks, Justin Schoeman, Gerd Knorr");
1211 MODULE_DESCRIPTION("Video4Linux2 core driver");
1212 MODULE_LICENSE("GPL");
1213 MODULE_ALIAS_CHARDEV_MAJOR(VIDEO_MAJOR);