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