Loading...
Note: File does not exist in v3.1.
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
45static 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}
52static DEVICE_ATTR_RO(index);
53
54static 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
62static 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}
76static DEVICE_ATTR_RW(dev_debug);
77
78static 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}
85static DEVICE_ATTR_RO(name);
86
87static struct attribute *video_device_attrs[] = {
88 &dev_attr_name.attr,
89 &dev_attr_dev_debug.attr,
90 &dev_attr_index.attr,
91 NULL,
92};
93ATTRIBUTE_GROUPS(video_device);
94
95/*
96 * Active devices
97 */
98static struct video_device *video_devices[VIDEO_NUM_DEVICES];
99static DEFINE_MUTEX(videodev_lock);
100static 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. */
109static 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. */
120static 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 */
127static 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 */
133static 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> */
139static 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
144struct video_device *video_device_alloc(void)
145{
146 return kzalloc(sizeof(struct video_device), GFP_KERNEL);
147}
148EXPORT_SYMBOL(video_device_alloc);
149
150void video_device_release(struct video_device *vdev)
151{
152 kfree(vdev);
153}
154EXPORT_SYMBOL(video_device_release);
155
156void video_device_release_empty(struct video_device *vdev)
157{
158 /* Do nothing */
159 /* Only valid when the video_device struct is a static. */
160}
161EXPORT_SYMBOL(video_device_release_empty);
162
163static inline void video_get(struct video_device *vdev)
164{
165 get_device(&vdev->dev);
166}
167
168static 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. */
174static 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
229static struct class video_class = {
230 .name = VIDEO_NAME,
231 .dev_groups = video_device_groups,
232};
233
234struct video_device *video_devdata(struct file *file)
235{
236 return video_devices[iminor(file_inode(file))];
237}
238EXPORT_SYMBOL(video_devdata);
239
240
241/* Priority handling */
242
243static 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
250void v4l2_prio_init(struct v4l2_prio_state *global)
251{
252 memset(global, 0, sizeof(*global));
253}
254EXPORT_SYMBOL(v4l2_prio_init);
255
256int 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}
270EXPORT_SYMBOL(v4l2_prio_change);
271
272void v4l2_prio_open(struct v4l2_prio_state *global, enum v4l2_priority *local)
273{
274 v4l2_prio_change(global, local, V4L2_PRIORITY_DEFAULT);
275}
276EXPORT_SYMBOL(v4l2_prio_open);
277
278void 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}
283EXPORT_SYMBOL(v4l2_prio_close);
284
285enum 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}
295EXPORT_SYMBOL(v4l2_prio_max);
296
297int v4l2_prio_check(struct v4l2_prio_state *global, enum v4l2_priority local)
298{
299 return (local < v4l2_prio_max(global)) ? -EBUSY : 0;
300}
301EXPORT_SYMBOL(v4l2_prio_check);
302
303
304static 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
321static 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
338static __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
353static 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
370static 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
389static 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 */
405static 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 */
438static 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
469static 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 */
498static 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 */
534static void determine_valid_ioctls(struct video_device *vdev)
535{
536 DECLARE_BITMAP(valid_ioctls, BASE_VIDIOC_PRIVATE);
537 const struct v4l2_ioctl_ops *ops = vdev->ioctl_ops;
538 bool is_vid = vdev->vfl_type == VFL_TYPE_GRABBER;
539 bool is_vbi = vdev->vfl_type == VFL_TYPE_VBI;
540 bool is_radio = vdev->vfl_type == VFL_TYPE_RADIO;
541 bool is_sdr = vdev->vfl_type == VFL_TYPE_SDR;
542 bool is_tch = vdev->vfl_type == VFL_TYPE_TOUCH;
543 bool is_rx = vdev->vfl_dir != VFL_DIR_TX;
544 bool is_tx = vdev->vfl_dir != VFL_DIR_RX;
545
546 bitmap_zero(valid_ioctls, BASE_VIDIOC_PRIVATE);
547
548 /* vfl_type and vfl_dir independent ioctls */
549
550 SET_VALID_IOCTL(ops, VIDIOC_QUERYCAP, vidioc_querycap);
551 set_bit(_IOC_NR(VIDIOC_G_PRIORITY), valid_ioctls);
552 set_bit(_IOC_NR(VIDIOC_S_PRIORITY), valid_ioctls);
553
554 /* Note: the control handler can also be passed through the filehandle,
555 and that can't be tested here. If the bit for these control ioctls
556 is set, then the ioctl is valid. But if it is 0, then it can still
557 be valid if the filehandle passed the control handler. */
558 if (vdev->ctrl_handler || ops->vidioc_queryctrl)
559 set_bit(_IOC_NR(VIDIOC_QUERYCTRL), valid_ioctls);
560 if (vdev->ctrl_handler || ops->vidioc_query_ext_ctrl)
561 set_bit(_IOC_NR(VIDIOC_QUERY_EXT_CTRL), valid_ioctls);
562 if (vdev->ctrl_handler || ops->vidioc_g_ctrl || ops->vidioc_g_ext_ctrls)
563 set_bit(_IOC_NR(VIDIOC_G_CTRL), valid_ioctls);
564 if (vdev->ctrl_handler || ops->vidioc_s_ctrl || ops->vidioc_s_ext_ctrls)
565 set_bit(_IOC_NR(VIDIOC_S_CTRL), valid_ioctls);
566 if (vdev->ctrl_handler || ops->vidioc_g_ext_ctrls)
567 set_bit(_IOC_NR(VIDIOC_G_EXT_CTRLS), valid_ioctls);
568 if (vdev->ctrl_handler || ops->vidioc_s_ext_ctrls)
569 set_bit(_IOC_NR(VIDIOC_S_EXT_CTRLS), valid_ioctls);
570 if (vdev->ctrl_handler || ops->vidioc_try_ext_ctrls)
571 set_bit(_IOC_NR(VIDIOC_TRY_EXT_CTRLS), valid_ioctls);
572 if (vdev->ctrl_handler || ops->vidioc_querymenu)
573 set_bit(_IOC_NR(VIDIOC_QUERYMENU), valid_ioctls);
574 SET_VALID_IOCTL(ops, VIDIOC_G_FREQUENCY, vidioc_g_frequency);
575 SET_VALID_IOCTL(ops, VIDIOC_S_FREQUENCY, vidioc_s_frequency);
576 SET_VALID_IOCTL(ops, VIDIOC_LOG_STATUS, vidioc_log_status);
577#ifdef CONFIG_VIDEO_ADV_DEBUG
578 set_bit(_IOC_NR(VIDIOC_DBG_G_CHIP_INFO), valid_ioctls);
579 set_bit(_IOC_NR(VIDIOC_DBG_G_REGISTER), valid_ioctls);
580 set_bit(_IOC_NR(VIDIOC_DBG_S_REGISTER), valid_ioctls);
581#endif
582 /* yes, really vidioc_subscribe_event */
583 SET_VALID_IOCTL(ops, VIDIOC_DQEVENT, vidioc_subscribe_event);
584 SET_VALID_IOCTL(ops, VIDIOC_SUBSCRIBE_EVENT, vidioc_subscribe_event);
585 SET_VALID_IOCTL(ops, VIDIOC_UNSUBSCRIBE_EVENT, vidioc_unsubscribe_event);
586 if (ops->vidioc_enum_freq_bands || ops->vidioc_g_tuner || ops->vidioc_g_modulator)
587 set_bit(_IOC_NR(VIDIOC_ENUM_FREQ_BANDS), valid_ioctls);
588
589 if (is_vid || is_tch) {
590 /* video and metadata specific ioctls */
591 if ((is_rx && (ops->vidioc_enum_fmt_vid_cap ||
592 ops->vidioc_enum_fmt_vid_overlay ||
593 ops->vidioc_enum_fmt_meta_cap)) ||
594 (is_tx && (ops->vidioc_enum_fmt_vid_out ||
595 ops->vidioc_enum_fmt_meta_out)))
596 set_bit(_IOC_NR(VIDIOC_ENUM_FMT), valid_ioctls);
597 if ((is_rx && (ops->vidioc_g_fmt_vid_cap ||
598 ops->vidioc_g_fmt_vid_cap_mplane ||
599 ops->vidioc_g_fmt_vid_overlay ||
600 ops->vidioc_g_fmt_meta_cap)) ||
601 (is_tx && (ops->vidioc_g_fmt_vid_out ||
602 ops->vidioc_g_fmt_vid_out_mplane ||
603 ops->vidioc_g_fmt_vid_out_overlay ||
604 ops->vidioc_g_fmt_meta_out)))
605 set_bit(_IOC_NR(VIDIOC_G_FMT), valid_ioctls);
606 if ((is_rx && (ops->vidioc_s_fmt_vid_cap ||
607 ops->vidioc_s_fmt_vid_cap_mplane ||
608 ops->vidioc_s_fmt_vid_overlay ||
609 ops->vidioc_s_fmt_meta_cap)) ||
610 (is_tx && (ops->vidioc_s_fmt_vid_out ||
611 ops->vidioc_s_fmt_vid_out_mplane ||
612 ops->vidioc_s_fmt_vid_out_overlay ||
613 ops->vidioc_s_fmt_meta_out)))
614 set_bit(_IOC_NR(VIDIOC_S_FMT), valid_ioctls);
615 if ((is_rx && (ops->vidioc_try_fmt_vid_cap ||
616 ops->vidioc_try_fmt_vid_cap_mplane ||
617 ops->vidioc_try_fmt_vid_overlay ||
618 ops->vidioc_try_fmt_meta_cap)) ||
619 (is_tx && (ops->vidioc_try_fmt_vid_out ||
620 ops->vidioc_try_fmt_vid_out_mplane ||
621 ops->vidioc_try_fmt_vid_out_overlay ||
622 ops->vidioc_try_fmt_meta_out)))
623 set_bit(_IOC_NR(VIDIOC_TRY_FMT), valid_ioctls);
624 SET_VALID_IOCTL(ops, VIDIOC_OVERLAY, vidioc_overlay);
625 SET_VALID_IOCTL(ops, VIDIOC_G_FBUF, vidioc_g_fbuf);
626 SET_VALID_IOCTL(ops, VIDIOC_S_FBUF, vidioc_s_fbuf);
627 SET_VALID_IOCTL(ops, VIDIOC_G_JPEGCOMP, vidioc_g_jpegcomp);
628 SET_VALID_IOCTL(ops, VIDIOC_S_JPEGCOMP, vidioc_s_jpegcomp);
629 SET_VALID_IOCTL(ops, VIDIOC_G_ENC_INDEX, vidioc_g_enc_index);
630 SET_VALID_IOCTL(ops, VIDIOC_ENCODER_CMD, vidioc_encoder_cmd);
631 SET_VALID_IOCTL(ops, VIDIOC_TRY_ENCODER_CMD, vidioc_try_encoder_cmd);
632 SET_VALID_IOCTL(ops, VIDIOC_DECODER_CMD, vidioc_decoder_cmd);
633 SET_VALID_IOCTL(ops, VIDIOC_TRY_DECODER_CMD, vidioc_try_decoder_cmd);
634 SET_VALID_IOCTL(ops, VIDIOC_ENUM_FRAMESIZES, vidioc_enum_framesizes);
635 SET_VALID_IOCTL(ops, VIDIOC_ENUM_FRAMEINTERVALS, vidioc_enum_frameintervals);
636 if (ops->vidioc_g_selection) {
637 set_bit(_IOC_NR(VIDIOC_G_CROP), valid_ioctls);
638 set_bit(_IOC_NR(VIDIOC_CROPCAP), valid_ioctls);
639 }
640 if (ops->vidioc_s_selection)
641 set_bit(_IOC_NR(VIDIOC_S_CROP), valid_ioctls);
642 SET_VALID_IOCTL(ops, VIDIOC_G_SELECTION, vidioc_g_selection);
643 SET_VALID_IOCTL(ops, VIDIOC_S_SELECTION, vidioc_s_selection);
644 } else if (is_vbi) {
645 /* vbi specific ioctls */
646 if ((is_rx && (ops->vidioc_g_fmt_vbi_cap ||
647 ops->vidioc_g_fmt_sliced_vbi_cap)) ||
648 (is_tx && (ops->vidioc_g_fmt_vbi_out ||
649 ops->vidioc_g_fmt_sliced_vbi_out)))
650 set_bit(_IOC_NR(VIDIOC_G_FMT), valid_ioctls);
651 if ((is_rx && (ops->vidioc_s_fmt_vbi_cap ||
652 ops->vidioc_s_fmt_sliced_vbi_cap)) ||
653 (is_tx && (ops->vidioc_s_fmt_vbi_out ||
654 ops->vidioc_s_fmt_sliced_vbi_out)))
655 set_bit(_IOC_NR(VIDIOC_S_FMT), valid_ioctls);
656 if ((is_rx && (ops->vidioc_try_fmt_vbi_cap ||
657 ops->vidioc_try_fmt_sliced_vbi_cap)) ||
658 (is_tx && (ops->vidioc_try_fmt_vbi_out ||
659 ops->vidioc_try_fmt_sliced_vbi_out)))
660 set_bit(_IOC_NR(VIDIOC_TRY_FMT), valid_ioctls);
661 SET_VALID_IOCTL(ops, VIDIOC_G_SLICED_VBI_CAP, vidioc_g_sliced_vbi_cap);
662 } else if (is_sdr && is_rx) {
663 /* SDR receiver specific ioctls */
664 if (ops->vidioc_enum_fmt_sdr_cap)
665 set_bit(_IOC_NR(VIDIOC_ENUM_FMT), valid_ioctls);
666 if (ops->vidioc_g_fmt_sdr_cap)
667 set_bit(_IOC_NR(VIDIOC_G_FMT), valid_ioctls);
668 if (ops->vidioc_s_fmt_sdr_cap)
669 set_bit(_IOC_NR(VIDIOC_S_FMT), valid_ioctls);
670 if (ops->vidioc_try_fmt_sdr_cap)
671 set_bit(_IOC_NR(VIDIOC_TRY_FMT), valid_ioctls);
672 } else if (is_sdr && is_tx) {
673 /* SDR transmitter specific ioctls */
674 if (ops->vidioc_enum_fmt_sdr_out)
675 set_bit(_IOC_NR(VIDIOC_ENUM_FMT), valid_ioctls);
676 if (ops->vidioc_g_fmt_sdr_out)
677 set_bit(_IOC_NR(VIDIOC_G_FMT), valid_ioctls);
678 if (ops->vidioc_s_fmt_sdr_out)
679 set_bit(_IOC_NR(VIDIOC_S_FMT), valid_ioctls);
680 if (ops->vidioc_try_fmt_sdr_out)
681 set_bit(_IOC_NR(VIDIOC_TRY_FMT), valid_ioctls);
682 }
683
684 if (is_vid || is_vbi || is_sdr || is_tch) {
685 /* ioctls valid for video, metadata, vbi or sdr */
686 SET_VALID_IOCTL(ops, VIDIOC_REQBUFS, vidioc_reqbufs);
687 SET_VALID_IOCTL(ops, VIDIOC_QUERYBUF, vidioc_querybuf);
688 SET_VALID_IOCTL(ops, VIDIOC_QBUF, vidioc_qbuf);
689 SET_VALID_IOCTL(ops, VIDIOC_EXPBUF, vidioc_expbuf);
690 SET_VALID_IOCTL(ops, VIDIOC_DQBUF, vidioc_dqbuf);
691 SET_VALID_IOCTL(ops, VIDIOC_CREATE_BUFS, vidioc_create_bufs);
692 SET_VALID_IOCTL(ops, VIDIOC_PREPARE_BUF, vidioc_prepare_buf);
693 SET_VALID_IOCTL(ops, VIDIOC_STREAMON, vidioc_streamon);
694 SET_VALID_IOCTL(ops, VIDIOC_STREAMOFF, vidioc_streamoff);
695 }
696
697 if (is_vid || is_vbi || is_tch) {
698 /* ioctls valid for video or vbi */
699 if (ops->vidioc_s_std)
700 set_bit(_IOC_NR(VIDIOC_ENUMSTD), valid_ioctls);
701 SET_VALID_IOCTL(ops, VIDIOC_S_STD, vidioc_s_std);
702 SET_VALID_IOCTL(ops, VIDIOC_G_STD, vidioc_g_std);
703 if (is_rx) {
704 SET_VALID_IOCTL(ops, VIDIOC_QUERYSTD, vidioc_querystd);
705 SET_VALID_IOCTL(ops, VIDIOC_ENUMINPUT, vidioc_enum_input);
706 SET_VALID_IOCTL(ops, VIDIOC_G_INPUT, vidioc_g_input);
707 SET_VALID_IOCTL(ops, VIDIOC_S_INPUT, vidioc_s_input);
708 SET_VALID_IOCTL(ops, VIDIOC_ENUMAUDIO, vidioc_enumaudio);
709 SET_VALID_IOCTL(ops, VIDIOC_G_AUDIO, vidioc_g_audio);
710 SET_VALID_IOCTL(ops, VIDIOC_S_AUDIO, vidioc_s_audio);
711 SET_VALID_IOCTL(ops, VIDIOC_QUERY_DV_TIMINGS, vidioc_query_dv_timings);
712 SET_VALID_IOCTL(ops, VIDIOC_S_EDID, vidioc_s_edid);
713 }
714 if (is_tx) {
715 SET_VALID_IOCTL(ops, VIDIOC_ENUMOUTPUT, vidioc_enum_output);
716 SET_VALID_IOCTL(ops, VIDIOC_G_OUTPUT, vidioc_g_output);
717 SET_VALID_IOCTL(ops, VIDIOC_S_OUTPUT, vidioc_s_output);
718 SET_VALID_IOCTL(ops, VIDIOC_ENUMAUDOUT, vidioc_enumaudout);
719 SET_VALID_IOCTL(ops, VIDIOC_G_AUDOUT, vidioc_g_audout);
720 SET_VALID_IOCTL(ops, VIDIOC_S_AUDOUT, vidioc_s_audout);
721 }
722 if (ops->vidioc_g_parm || (vdev->vfl_type == VFL_TYPE_GRABBER &&
723 ops->vidioc_g_std))
724 set_bit(_IOC_NR(VIDIOC_G_PARM), valid_ioctls);
725 SET_VALID_IOCTL(ops, VIDIOC_S_PARM, vidioc_s_parm);
726 SET_VALID_IOCTL(ops, VIDIOC_S_DV_TIMINGS, vidioc_s_dv_timings);
727 SET_VALID_IOCTL(ops, VIDIOC_G_DV_TIMINGS, vidioc_g_dv_timings);
728 SET_VALID_IOCTL(ops, VIDIOC_ENUM_DV_TIMINGS, vidioc_enum_dv_timings);
729 SET_VALID_IOCTL(ops, VIDIOC_DV_TIMINGS_CAP, vidioc_dv_timings_cap);
730 SET_VALID_IOCTL(ops, VIDIOC_G_EDID, vidioc_g_edid);
731 }
732 if (is_tx && (is_radio || is_sdr)) {
733 /* radio transmitter only ioctls */
734 SET_VALID_IOCTL(ops, VIDIOC_G_MODULATOR, vidioc_g_modulator);
735 SET_VALID_IOCTL(ops, VIDIOC_S_MODULATOR, vidioc_s_modulator);
736 }
737 if (is_rx) {
738 /* receiver only ioctls */
739 SET_VALID_IOCTL(ops, VIDIOC_G_TUNER, vidioc_g_tuner);
740 SET_VALID_IOCTL(ops, VIDIOC_S_TUNER, vidioc_s_tuner);
741 SET_VALID_IOCTL(ops, VIDIOC_S_HW_FREQ_SEEK, vidioc_s_hw_freq_seek);
742 }
743
744 bitmap_andnot(vdev->valid_ioctls, valid_ioctls, vdev->valid_ioctls,
745 BASE_VIDIOC_PRIVATE);
746}
747
748static int video_register_media_controller(struct video_device *vdev)
749{
750#if defined(CONFIG_MEDIA_CONTROLLER)
751 u32 intf_type;
752 int ret;
753
754 /* Memory-to-memory devices are more complex and use
755 * their own function to register its mc entities.
756 */
757 if (!vdev->v4l2_dev->mdev || vdev->vfl_dir == VFL_DIR_M2M)
758 return 0;
759
760 vdev->entity.obj_type = MEDIA_ENTITY_TYPE_VIDEO_DEVICE;
761 vdev->entity.function = MEDIA_ENT_F_UNKNOWN;
762
763 switch (vdev->vfl_type) {
764 case VFL_TYPE_GRABBER:
765 intf_type = MEDIA_INTF_T_V4L_VIDEO;
766 vdev->entity.function = MEDIA_ENT_F_IO_V4L;
767 break;
768 case VFL_TYPE_VBI:
769 intf_type = MEDIA_INTF_T_V4L_VBI;
770 vdev->entity.function = MEDIA_ENT_F_IO_VBI;
771 break;
772 case VFL_TYPE_SDR:
773 intf_type = MEDIA_INTF_T_V4L_SWRADIO;
774 vdev->entity.function = MEDIA_ENT_F_IO_SWRADIO;
775 break;
776 case VFL_TYPE_TOUCH:
777 intf_type = MEDIA_INTF_T_V4L_TOUCH;
778 vdev->entity.function = MEDIA_ENT_F_IO_V4L;
779 break;
780 case VFL_TYPE_RADIO:
781 intf_type = MEDIA_INTF_T_V4L_RADIO;
782 /*
783 * Radio doesn't have an entity at the V4L2 side to represent
784 * radio input or output. Instead, the audio input/output goes
785 * via either physical wires or ALSA.
786 */
787 break;
788 case VFL_TYPE_SUBDEV:
789 intf_type = MEDIA_INTF_T_V4L_SUBDEV;
790 /* Entity will be created via v4l2_device_register_subdev() */
791 break;
792 default:
793 return 0;
794 }
795
796 if (vdev->entity.function != MEDIA_ENT_F_UNKNOWN) {
797 vdev->entity.name = vdev->name;
798
799 /* Needed just for backward compatibility with legacy MC API */
800 vdev->entity.info.dev.major = VIDEO_MAJOR;
801 vdev->entity.info.dev.minor = vdev->minor;
802
803 ret = media_device_register_entity(vdev->v4l2_dev->mdev,
804 &vdev->entity);
805 if (ret < 0) {
806 pr_warn("%s: media_device_register_entity failed\n",
807 __func__);
808 return ret;
809 }
810 }
811
812 vdev->intf_devnode = media_devnode_create(vdev->v4l2_dev->mdev,
813 intf_type,
814 0, VIDEO_MAJOR,
815 vdev->minor);
816 if (!vdev->intf_devnode) {
817 media_device_unregister_entity(&vdev->entity);
818 return -ENOMEM;
819 }
820
821 if (vdev->entity.function != MEDIA_ENT_F_UNKNOWN) {
822 struct media_link *link;
823
824 link = media_create_intf_link(&vdev->entity,
825 &vdev->intf_devnode->intf,
826 MEDIA_LNK_FL_ENABLED |
827 MEDIA_LNK_FL_IMMUTABLE);
828 if (!link) {
829 media_devnode_remove(vdev->intf_devnode);
830 media_device_unregister_entity(&vdev->entity);
831 return -ENOMEM;
832 }
833 }
834
835 /* FIXME: how to create the other interface links? */
836
837#endif
838 return 0;
839}
840
841int __video_register_device(struct video_device *vdev,
842 enum vfl_devnode_type type,
843 int nr, int warn_if_nr_in_use,
844 struct module *owner)
845{
846 int i = 0;
847 int ret;
848 int minor_offset = 0;
849 int minor_cnt = VIDEO_NUM_DEVICES;
850 const char *name_base;
851
852 /* A minor value of -1 marks this video device as never
853 having been registered */
854 vdev->minor = -1;
855
856 /* the release callback MUST be present */
857 if (WARN_ON(!vdev->release))
858 return -EINVAL;
859 /* the v4l2_dev pointer MUST be present */
860 if (WARN_ON(!vdev->v4l2_dev))
861 return -EINVAL;
862 /* the device_caps field MUST be set for all but subdevs */
863 if (WARN_ON(type != VFL_TYPE_SUBDEV && !vdev->device_caps))
864 return -EINVAL;
865
866 /* v4l2_fh support */
867 spin_lock_init(&vdev->fh_lock);
868 INIT_LIST_HEAD(&vdev->fh_list);
869
870 /* Part 1: check device type */
871 switch (type) {
872 case VFL_TYPE_GRABBER:
873 name_base = "video";
874 break;
875 case VFL_TYPE_VBI:
876 name_base = "vbi";
877 break;
878 case VFL_TYPE_RADIO:
879 name_base = "radio";
880 break;
881 case VFL_TYPE_SUBDEV:
882 name_base = "v4l-subdev";
883 break;
884 case VFL_TYPE_SDR:
885 /* Use device name 'swradio' because 'sdr' was already taken. */
886 name_base = "swradio";
887 break;
888 case VFL_TYPE_TOUCH:
889 name_base = "v4l-touch";
890 break;
891 default:
892 pr_err("%s called with unknown type: %d\n",
893 __func__, type);
894 return -EINVAL;
895 }
896
897 vdev->vfl_type = type;
898 vdev->cdev = NULL;
899 if (vdev->dev_parent == NULL)
900 vdev->dev_parent = vdev->v4l2_dev->dev;
901 if (vdev->ctrl_handler == NULL)
902 vdev->ctrl_handler = vdev->v4l2_dev->ctrl_handler;
903 /* If the prio state pointer is NULL, then use the v4l2_device
904 prio state. */
905 if (vdev->prio == NULL)
906 vdev->prio = &vdev->v4l2_dev->prio;
907
908 /* Part 2: find a free minor, device node number and device index. */
909#ifdef CONFIG_VIDEO_FIXED_MINOR_RANGES
910 /* Keep the ranges for the first four types for historical
911 * reasons.
912 * Newer devices (not yet in place) should use the range
913 * of 128-191 and just pick the first free minor there
914 * (new style). */
915 switch (type) {
916 case VFL_TYPE_GRABBER:
917 minor_offset = 0;
918 minor_cnt = 64;
919 break;
920 case VFL_TYPE_RADIO:
921 minor_offset = 64;
922 minor_cnt = 64;
923 break;
924 case VFL_TYPE_VBI:
925 minor_offset = 224;
926 minor_cnt = 32;
927 break;
928 default:
929 minor_offset = 128;
930 minor_cnt = 64;
931 break;
932 }
933#endif
934
935 /* Pick a device node number */
936 mutex_lock(&videodev_lock);
937 nr = devnode_find(vdev, nr == -1 ? 0 : nr, minor_cnt);
938 if (nr == minor_cnt)
939 nr = devnode_find(vdev, 0, minor_cnt);
940 if (nr == minor_cnt) {
941 pr_err("could not get a free device node number\n");
942 mutex_unlock(&videodev_lock);
943 return -ENFILE;
944 }
945#ifdef CONFIG_VIDEO_FIXED_MINOR_RANGES
946 /* 1-on-1 mapping of device node number to minor number */
947 i = nr;
948#else
949 /* The device node number and minor numbers are independent, so
950 we just find the first free minor number. */
951 for (i = 0; i < VIDEO_NUM_DEVICES; i++)
952 if (video_devices[i] == NULL)
953 break;
954 if (i == VIDEO_NUM_DEVICES) {
955 mutex_unlock(&videodev_lock);
956 pr_err("could not get a free minor\n");
957 return -ENFILE;
958 }
959#endif
960 vdev->minor = i + minor_offset;
961 vdev->num = nr;
962
963 /* Should not happen since we thought this minor was free */
964 if (WARN_ON(video_devices[vdev->minor])) {
965 mutex_unlock(&videodev_lock);
966 pr_err("video_device not empty!\n");
967 return -ENFILE;
968 }
969 devnode_set(vdev);
970 vdev->index = get_index(vdev);
971 video_devices[vdev->minor] = vdev;
972 mutex_unlock(&videodev_lock);
973
974 if (vdev->ioctl_ops)
975 determine_valid_ioctls(vdev);
976
977 /* Part 3: Initialize the character device */
978 vdev->cdev = cdev_alloc();
979 if (vdev->cdev == NULL) {
980 ret = -ENOMEM;
981 goto cleanup;
982 }
983 vdev->cdev->ops = &v4l2_fops;
984 vdev->cdev->owner = owner;
985 ret = cdev_add(vdev->cdev, MKDEV(VIDEO_MAJOR, vdev->minor), 1);
986 if (ret < 0) {
987 pr_err("%s: cdev_add failed\n", __func__);
988 kfree(vdev->cdev);
989 vdev->cdev = NULL;
990 goto cleanup;
991 }
992
993 /* Part 4: register the device with sysfs */
994 vdev->dev.class = &video_class;
995 vdev->dev.devt = MKDEV(VIDEO_MAJOR, vdev->minor);
996 vdev->dev.parent = vdev->dev_parent;
997 dev_set_name(&vdev->dev, "%s%d", name_base, vdev->num);
998 ret = device_register(&vdev->dev);
999 if (ret < 0) {
1000 pr_err("%s: device_register failed\n", __func__);
1001 goto cleanup;
1002 }
1003 /* Register the release callback that will be called when the last
1004 reference to the device goes away. */
1005 vdev->dev.release = v4l2_device_release;
1006
1007 if (nr != -1 && nr != vdev->num && warn_if_nr_in_use)
1008 pr_warn("%s: requested %s%d, got %s\n", __func__,
1009 name_base, nr, video_device_node_name(vdev));
1010
1011 /* Increase v4l2_device refcount */
1012 v4l2_device_get(vdev->v4l2_dev);
1013
1014 /* Part 5: Register the entity. */
1015 ret = video_register_media_controller(vdev);
1016
1017 /* Part 6: Activate this minor. The char device can now be used. */
1018 set_bit(V4L2_FL_REGISTERED, &vdev->flags);
1019
1020 return 0;
1021
1022cleanup:
1023 mutex_lock(&videodev_lock);
1024 if (vdev->cdev)
1025 cdev_del(vdev->cdev);
1026 video_devices[vdev->minor] = NULL;
1027 devnode_clear(vdev);
1028 mutex_unlock(&videodev_lock);
1029 /* Mark this video device as never having been registered. */
1030 vdev->minor = -1;
1031 return ret;
1032}
1033EXPORT_SYMBOL(__video_register_device);
1034
1035/**
1036 * video_unregister_device - unregister a video4linux device
1037 * @vdev: the device to unregister
1038 *
1039 * This unregisters the passed device. Future open calls will
1040 * be met with errors.
1041 */
1042void video_unregister_device(struct video_device *vdev)
1043{
1044 /* Check if vdev was ever registered at all */
1045 if (!vdev || !video_is_registered(vdev))
1046 return;
1047
1048 mutex_lock(&videodev_lock);
1049 /* This must be in a critical section to prevent a race with v4l2_open.
1050 * Once this bit has been cleared video_get may never be called again.
1051 */
1052 clear_bit(V4L2_FL_REGISTERED, &vdev->flags);
1053 mutex_unlock(&videodev_lock);
1054 device_unregister(&vdev->dev);
1055}
1056EXPORT_SYMBOL(video_unregister_device);
1057
1058/*
1059 * Initialise video for linux
1060 */
1061static int __init videodev_init(void)
1062{
1063 dev_t dev = MKDEV(VIDEO_MAJOR, 0);
1064 int ret;
1065
1066 pr_info("Linux video capture interface: v2.00\n");
1067 ret = register_chrdev_region(dev, VIDEO_NUM_DEVICES, VIDEO_NAME);
1068 if (ret < 0) {
1069 pr_warn("videodev: unable to get major %d\n",
1070 VIDEO_MAJOR);
1071 return ret;
1072 }
1073
1074 ret = class_register(&video_class);
1075 if (ret < 0) {
1076 unregister_chrdev_region(dev, VIDEO_NUM_DEVICES);
1077 pr_warn("video_dev: class_register failed\n");
1078 return -EIO;
1079 }
1080
1081 return 0;
1082}
1083
1084static void __exit videodev_exit(void)
1085{
1086 dev_t dev = MKDEV(VIDEO_MAJOR, 0);
1087
1088 class_unregister(&video_class);
1089 unregister_chrdev_region(dev, VIDEO_NUM_DEVICES);
1090}
1091
1092subsys_initcall(videodev_init);
1093module_exit(videodev_exit)
1094
1095MODULE_AUTHOR("Alan Cox, Mauro Carvalho Chehab <mchehab@kernel.org>, Bill Dirks, Justin Schoeman, Gerd Knorr");
1096MODULE_DESCRIPTION("Video4Linux2 core driver");
1097MODULE_LICENSE("GPL");
1098MODULE_ALIAS_CHARDEV_MAJOR(VIDEO_MAJOR);