2 * Video capture interface for Linux version 2
4 * A generic video device interface for the LINUX operating system
5 * using a set of device structures/vectors for low level operations.
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.
12 * Authors: Alan Cox, <alan@lxorguk.ukuu.org.uk> (version 1)
13 * Mauro Carvalho Chehab <mchehab@infradead.org> (version 2)
15 * Fixes: 20000516 Claudio Matsuoka <claudio@conectiva.com>
16 * - Added procfs support
19 #include <linux/module.h>
20 #include <linux/types.h>
21 #include <linux/kernel.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>
30 #include <media/v4l2-common.h>
31 #include <media/v4l2-device.h>
32 #include <media/v4l2-ioctl.h>
34 #define VIDEO_NUM_DEVICES 256
35 #define VIDEO_NAME "video4linux"
41 static ssize_t
show_index(struct device
*cd
,
42 struct device_attribute
*attr
, char *buf
)
44 struct video_device
*vdev
= to_video_device(cd
);
46 return sprintf(buf
, "%i\n", vdev
->index
);
49 static ssize_t
show_name(struct device
*cd
,
50 struct device_attribute
*attr
, char *buf
)
52 struct video_device
*vdev
= to_video_device(cd
);
54 return sprintf(buf
, "%.*s\n", (int)sizeof(vdev
->name
), vdev
->name
);
57 static struct device_attribute video_device_attrs
[] = {
58 __ATTR(name
, S_IRUGO
, show_name
, NULL
),
59 __ATTR(index
, S_IRUGO
, show_index
, NULL
),
66 static struct video_device
*video_device
[VIDEO_NUM_DEVICES
];
67 static DEFINE_MUTEX(videodev_lock
);
68 static DECLARE_BITMAP(devnode_nums
[VFL_TYPE_MAX
], VIDEO_NUM_DEVICES
);
70 /* Device node utility functions */
72 /* Note: these utility functions all assume that vfl_type is in the range
73 [0, VFL_TYPE_MAX-1]. */
75 #ifdef CONFIG_VIDEO_FIXED_MINOR_RANGES
76 /* Return the bitmap corresponding to vfl_type. */
77 static inline unsigned long *devnode_bits(int vfl_type
)
79 /* Any types not assigned to fixed minor ranges must be mapped to
80 one single bitmap for the purposes of finding a free node number
81 since all those unassigned types use the same minor range. */
82 int idx
= (vfl_type
> VFL_TYPE_RADIO
) ? VFL_TYPE_MAX
- 1 : vfl_type
;
84 return devnode_nums
[idx
];
87 /* Return the bitmap corresponding to vfl_type. */
88 static inline unsigned long *devnode_bits(int vfl_type
)
90 return devnode_nums
[vfl_type
];
94 /* Mark device node number vdev->num as used */
95 static inline void devnode_set(struct video_device
*vdev
)
97 set_bit(vdev
->num
, devnode_bits(vdev
->vfl_type
));
100 /* Mark device node number vdev->num as unused */
101 static inline void devnode_clear(struct video_device
*vdev
)
103 clear_bit(vdev
->num
, devnode_bits(vdev
->vfl_type
));
106 /* Try to find a free device node number in the range [from, to> */
107 static inline int devnode_find(struct video_device
*vdev
, int from
, int to
)
109 return find_next_zero_bit(devnode_bits(vdev
->vfl_type
), to
, from
);
112 struct video_device
*video_device_alloc(void)
114 return kzalloc(sizeof(struct video_device
), GFP_KERNEL
);
116 EXPORT_SYMBOL(video_device_alloc
);
118 void video_device_release(struct video_device
*vdev
)
122 EXPORT_SYMBOL(video_device_release
);
124 void video_device_release_empty(struct video_device
*vdev
)
127 /* Only valid when the video_device struct is a static. */
129 EXPORT_SYMBOL(video_device_release_empty
);
131 static inline void video_get(struct video_device
*vdev
)
133 get_device(&vdev
->dev
);
136 static inline void video_put(struct video_device
*vdev
)
138 put_device(&vdev
->dev
);
141 /* Called when the last user of the video device exits. */
142 static void v4l2_device_release(struct device
*cd
)
144 struct video_device
*vdev
= to_video_device(cd
);
145 struct v4l2_device
*v4l2_dev
= vdev
->v4l2_dev
;
147 mutex_lock(&videodev_lock
);
148 if (WARN_ON(video_device
[vdev
->minor
] != vdev
)) {
149 /* should not happen */
150 mutex_unlock(&videodev_lock
);
154 /* Free up this device for reuse */
155 video_device
[vdev
->minor
] = NULL
;
157 /* Delete the cdev on this minor as well */
158 cdev_del(vdev
->cdev
);
159 /* Just in case some driver tries to access this from
160 the release() callback. */
163 /* Mark device node number as free */
166 mutex_unlock(&videodev_lock
);
168 #if defined(CONFIG_MEDIA_CONTROLLER)
169 if (v4l2_dev
&& v4l2_dev
->mdev
&&
170 vdev
->vfl_type
!= VFL_TYPE_SUBDEV
)
171 media_device_unregister_entity(&vdev
->entity
);
174 /* Do not call v4l2_device_put if there is no release callback set.
175 * Drivers that have no v4l2_device release callback might free the
176 * v4l2_dev instance in the video_device release callback below, so we
177 * must perform this check here.
179 * TODO: In the long run all drivers that use v4l2_device should use the
180 * v4l2_device release callback. This check will then be unnecessary.
182 if (v4l2_dev
&& v4l2_dev
->release
== NULL
)
185 /* Release video_device and perform other
186 cleanups as needed. */
189 /* Decrease v4l2_device refcount */
191 v4l2_device_put(v4l2_dev
);
194 static struct class video_class
= {
196 .dev_attrs
= video_device_attrs
,
199 struct video_device
*video_devdata(struct file
*file
)
201 return video_device
[iminor(file
->f_path
.dentry
->d_inode
)];
203 EXPORT_SYMBOL(video_devdata
);
206 /* Priority handling */
208 static inline bool prio_is_valid(enum v4l2_priority prio
)
210 return prio
== V4L2_PRIORITY_BACKGROUND
||
211 prio
== V4L2_PRIORITY_INTERACTIVE
||
212 prio
== V4L2_PRIORITY_RECORD
;
215 void v4l2_prio_init(struct v4l2_prio_state
*global
)
217 memset(global
, 0, sizeof(*global
));
219 EXPORT_SYMBOL(v4l2_prio_init
);
221 int v4l2_prio_change(struct v4l2_prio_state
*global
, enum v4l2_priority
*local
,
222 enum v4l2_priority
new)
224 if (!prio_is_valid(new))
229 atomic_inc(&global
->prios
[new]);
230 if (prio_is_valid(*local
))
231 atomic_dec(&global
->prios
[*local
]);
235 EXPORT_SYMBOL(v4l2_prio_change
);
237 void v4l2_prio_open(struct v4l2_prio_state
*global
, enum v4l2_priority
*local
)
239 v4l2_prio_change(global
, local
, V4L2_PRIORITY_DEFAULT
);
241 EXPORT_SYMBOL(v4l2_prio_open
);
243 void v4l2_prio_close(struct v4l2_prio_state
*global
, enum v4l2_priority local
)
245 if (prio_is_valid(local
))
246 atomic_dec(&global
->prios
[local
]);
248 EXPORT_SYMBOL(v4l2_prio_close
);
250 enum v4l2_priority
v4l2_prio_max(struct v4l2_prio_state
*global
)
252 if (atomic_read(&global
->prios
[V4L2_PRIORITY_RECORD
]) > 0)
253 return V4L2_PRIORITY_RECORD
;
254 if (atomic_read(&global
->prios
[V4L2_PRIORITY_INTERACTIVE
]) > 0)
255 return V4L2_PRIORITY_INTERACTIVE
;
256 if (atomic_read(&global
->prios
[V4L2_PRIORITY_BACKGROUND
]) > 0)
257 return V4L2_PRIORITY_BACKGROUND
;
258 return V4L2_PRIORITY_UNSET
;
260 EXPORT_SYMBOL(v4l2_prio_max
);
262 int v4l2_prio_check(struct v4l2_prio_state
*global
, enum v4l2_priority local
)
264 return (local
< v4l2_prio_max(global
)) ? -EBUSY
: 0;
266 EXPORT_SYMBOL(v4l2_prio_check
);
269 static ssize_t
v4l2_read(struct file
*filp
, char __user
*buf
,
270 size_t sz
, loff_t
*off
)
272 struct video_device
*vdev
= video_devdata(filp
);
275 if (!vdev
->fops
->read
)
277 if (test_bit(V4L2_FL_LOCK_ALL_FOPS
, &vdev
->flags
) &&
278 mutex_lock_interruptible(vdev
->lock
))
280 if (video_is_registered(vdev
))
281 ret
= vdev
->fops
->read(filp
, buf
, sz
, off
);
282 if (test_bit(V4L2_FL_LOCK_ALL_FOPS
, &vdev
->flags
))
283 mutex_unlock(vdev
->lock
);
287 static ssize_t
v4l2_write(struct file
*filp
, const char __user
*buf
,
288 size_t sz
, loff_t
*off
)
290 struct video_device
*vdev
= video_devdata(filp
);
293 if (!vdev
->fops
->write
)
295 if (test_bit(V4L2_FL_LOCK_ALL_FOPS
, &vdev
->flags
) &&
296 mutex_lock_interruptible(vdev
->lock
))
298 if (video_is_registered(vdev
))
299 ret
= vdev
->fops
->write(filp
, buf
, sz
, off
);
300 if (test_bit(V4L2_FL_LOCK_ALL_FOPS
, &vdev
->flags
))
301 mutex_unlock(vdev
->lock
);
305 static unsigned int v4l2_poll(struct file
*filp
, struct poll_table_struct
*poll
)
307 struct video_device
*vdev
= video_devdata(filp
);
308 int ret
= POLLERR
| POLLHUP
;
310 if (!vdev
->fops
->poll
)
311 return DEFAULT_POLLMASK
;
312 if (test_bit(V4L2_FL_LOCK_ALL_FOPS
, &vdev
->flags
))
313 mutex_lock(vdev
->lock
);
314 if (video_is_registered(vdev
))
315 ret
= vdev
->fops
->poll(filp
, poll
);
316 if (test_bit(V4L2_FL_LOCK_ALL_FOPS
, &vdev
->flags
))
317 mutex_unlock(vdev
->lock
);
321 static long v4l2_ioctl(struct file
*filp
, unsigned int cmd
, unsigned long arg
)
323 struct video_device
*vdev
= video_devdata(filp
);
326 if (vdev
->fops
->unlocked_ioctl
) {
330 /* always lock unless the cmd is marked as "don't use lock" */
331 locked
= !v4l2_is_known_ioctl(cmd
) ||
332 !test_bit(_IOC_NR(cmd
), vdev
->disable_locking
);
334 if (locked
&& mutex_lock_interruptible(vdev
->lock
))
337 if (video_is_registered(vdev
))
338 ret
= vdev
->fops
->unlocked_ioctl(filp
, cmd
, arg
);
340 mutex_unlock(vdev
->lock
);
341 } else if (vdev
->fops
->ioctl
) {
342 /* This code path is a replacement for the BKL. It is a major
343 * hack but it will have to do for those drivers that are not
344 * yet converted to use unlocked_ioctl.
346 * There are two options: if the driver implements struct
347 * v4l2_device, then the lock defined there is used to
348 * serialize the ioctls. Otherwise the v4l2 core lock defined
349 * below is used. This lock is really bad since it serializes
350 * completely independent devices.
352 * Both variants suffer from the same problem: if the driver
353 * sleeps, then it blocks all ioctls since the lock is still
354 * held. This is very common for VIDIOC_DQBUF since that
355 * normally waits for a frame to arrive. As a result any other
356 * ioctl calls will proceed very, very slowly since each call
357 * will have to wait for the VIDIOC_QBUF to finish. Things that
358 * should take 0.01s may now take 10-20 seconds.
360 * The workaround is to *not* take the lock for VIDIOC_DQBUF.
361 * This actually works OK for videobuf-based drivers, since
362 * videobuf will take its own internal lock.
364 static DEFINE_MUTEX(v4l2_ioctl_mutex
);
365 struct mutex
*m
= vdev
->v4l2_dev
?
366 &vdev
->v4l2_dev
->ioctl_lock
: &v4l2_ioctl_mutex
;
368 if (cmd
!= VIDIOC_DQBUF
&& mutex_lock_interruptible(m
))
370 if (video_is_registered(vdev
))
371 ret
= vdev
->fops
->ioctl(filp
, cmd
, arg
);
372 if (cmd
!= VIDIOC_DQBUF
)
381 #define v4l2_get_unmapped_area NULL
383 static unsigned long v4l2_get_unmapped_area(struct file
*filp
,
384 unsigned long addr
, unsigned long len
, unsigned long pgoff
,
387 struct video_device
*vdev
= video_devdata(filp
);
389 if (!vdev
->fops
->get_unmapped_area
)
391 if (!video_is_registered(vdev
))
393 return vdev
->fops
->get_unmapped_area(filp
, addr
, len
, pgoff
, flags
);
397 static int v4l2_mmap(struct file
*filp
, struct vm_area_struct
*vm
)
399 struct video_device
*vdev
= video_devdata(filp
);
402 if (!vdev
->fops
->mmap
)
404 if (test_bit(V4L2_FL_LOCK_ALL_FOPS
, &vdev
->flags
) &&
405 mutex_lock_interruptible(vdev
->lock
))
407 if (video_is_registered(vdev
))
408 ret
= vdev
->fops
->mmap(filp
, vm
);
409 if (test_bit(V4L2_FL_LOCK_ALL_FOPS
, &vdev
->flags
))
410 mutex_unlock(vdev
->lock
);
414 /* Override for the open function */
415 static int v4l2_open(struct inode
*inode
, struct file
*filp
)
417 struct video_device
*vdev
;
420 /* Check if the video device is available */
421 mutex_lock(&videodev_lock
);
422 vdev
= video_devdata(filp
);
423 /* return ENODEV if the video device has already been removed. */
424 if (vdev
== NULL
|| !video_is_registered(vdev
)) {
425 mutex_unlock(&videodev_lock
);
428 /* and increase the device refcount */
430 mutex_unlock(&videodev_lock
);
431 if (vdev
->fops
->open
) {
432 if (test_bit(V4L2_FL_LOCK_ALL_FOPS
, &vdev
->flags
) &&
433 mutex_lock_interruptible(vdev
->lock
)) {
437 if (video_is_registered(vdev
))
438 ret
= vdev
->fops
->open(filp
);
441 if (test_bit(V4L2_FL_LOCK_ALL_FOPS
, &vdev
->flags
))
442 mutex_unlock(vdev
->lock
);
446 /* decrease the refcount in case of an error */
452 /* Override for the release function */
453 static int v4l2_release(struct inode
*inode
, struct file
*filp
)
455 struct video_device
*vdev
= video_devdata(filp
);
458 if (vdev
->fops
->release
) {
459 if (test_bit(V4L2_FL_LOCK_ALL_FOPS
, &vdev
->flags
))
460 mutex_lock(vdev
->lock
);
461 vdev
->fops
->release(filp
);
462 if (test_bit(V4L2_FL_LOCK_ALL_FOPS
, &vdev
->flags
))
463 mutex_unlock(vdev
->lock
);
465 /* decrease the refcount unconditionally since the release()
466 return value is ignored. */
471 static const struct file_operations v4l2_fops
= {
472 .owner
= THIS_MODULE
,
476 .get_unmapped_area
= v4l2_get_unmapped_area
,
478 .unlocked_ioctl
= v4l2_ioctl
,
480 .compat_ioctl
= v4l2_compat_ioctl32
,
482 .release
= v4l2_release
,
488 * get_index - assign stream index number based on parent device
489 * @vdev: video_device to assign index number to, vdev->parent should be assigned
491 * Note that when this is called the new device has not yet been registered
492 * in the video_device array, but it was able to obtain a minor number.
494 * This means that we can always obtain a free stream index number since
495 * the worst case scenario is that there are VIDEO_NUM_DEVICES - 1 slots in
496 * use of the video_device array.
498 * Returns a free index number.
500 static int get_index(struct video_device
*vdev
)
502 /* This can be static since this function is called with the global
503 videodev_lock held. */
504 static DECLARE_BITMAP(used
, VIDEO_NUM_DEVICES
);
507 /* Some drivers do not set the parent. In that case always return 0. */
508 if (vdev
->parent
== NULL
)
511 bitmap_zero(used
, VIDEO_NUM_DEVICES
);
513 for (i
= 0; i
< VIDEO_NUM_DEVICES
; i
++) {
514 if (video_device
[i
] != NULL
&&
515 video_device
[i
]->parent
== vdev
->parent
) {
516 set_bit(video_device
[i
]->index
, used
);
520 return find_first_zero_bit(used
, VIDEO_NUM_DEVICES
);
523 #define SET_VALID_IOCTL(ops, cmd, op) \
525 set_bit(_IOC_NR(cmd), valid_ioctls)
527 /* This determines which ioctls are actually implemented in the driver.
528 It's a one-time thing which simplifies video_ioctl2 as it can just do
531 Note that drivers can override this by setting bits to 1 in
532 vdev->valid_ioctls. If an ioctl is marked as 1 when this function is
533 called, then that ioctl will actually be marked as unimplemented.
535 It does that by first setting up the local valid_ioctls bitmap, and
538 vdev->valid_ioctls = valid_ioctls & ~(vdev->valid_ioctls)
540 static void determine_valid_ioctls(struct video_device
*vdev
)
542 DECLARE_BITMAP(valid_ioctls
, BASE_VIDIOC_PRIVATE
);
543 const struct v4l2_ioctl_ops
*ops
= vdev
->ioctl_ops
;
545 bitmap_zero(valid_ioctls
, BASE_VIDIOC_PRIVATE
);
547 SET_VALID_IOCTL(ops
, VIDIOC_QUERYCAP
, vidioc_querycap
);
548 if (ops
->vidioc_g_priority
||
549 test_bit(V4L2_FL_USE_FH_PRIO
, &vdev
->flags
))
550 set_bit(_IOC_NR(VIDIOC_G_PRIORITY
), valid_ioctls
);
551 if (ops
->vidioc_s_priority
||
552 test_bit(V4L2_FL_USE_FH_PRIO
, &vdev
->flags
))
553 set_bit(_IOC_NR(VIDIOC_S_PRIORITY
), valid_ioctls
);
554 if (ops
->vidioc_enum_fmt_vid_cap
||
555 ops
->vidioc_enum_fmt_vid_out
||
556 ops
->vidioc_enum_fmt_vid_cap_mplane
||
557 ops
->vidioc_enum_fmt_vid_out_mplane
||
558 ops
->vidioc_enum_fmt_vid_overlay
||
559 ops
->vidioc_enum_fmt_type_private
)
560 set_bit(_IOC_NR(VIDIOC_ENUM_FMT
), valid_ioctls
);
561 if (ops
->vidioc_g_fmt_vid_cap
||
562 ops
->vidioc_g_fmt_vid_out
||
563 ops
->vidioc_g_fmt_vid_cap_mplane
||
564 ops
->vidioc_g_fmt_vid_out_mplane
||
565 ops
->vidioc_g_fmt_vid_overlay
||
566 ops
->vidioc_g_fmt_vbi_cap
||
567 ops
->vidioc_g_fmt_vid_out_overlay
||
568 ops
->vidioc_g_fmt_vbi_out
||
569 ops
->vidioc_g_fmt_sliced_vbi_cap
||
570 ops
->vidioc_g_fmt_sliced_vbi_out
||
571 ops
->vidioc_g_fmt_type_private
)
572 set_bit(_IOC_NR(VIDIOC_G_FMT
), valid_ioctls
);
573 if (ops
->vidioc_s_fmt_vid_cap
||
574 ops
->vidioc_s_fmt_vid_out
||
575 ops
->vidioc_s_fmt_vid_cap_mplane
||
576 ops
->vidioc_s_fmt_vid_out_mplane
||
577 ops
->vidioc_s_fmt_vid_overlay
||
578 ops
->vidioc_s_fmt_vbi_cap
||
579 ops
->vidioc_s_fmt_vid_out_overlay
||
580 ops
->vidioc_s_fmt_vbi_out
||
581 ops
->vidioc_s_fmt_sliced_vbi_cap
||
582 ops
->vidioc_s_fmt_sliced_vbi_out
||
583 ops
->vidioc_s_fmt_type_private
)
584 set_bit(_IOC_NR(VIDIOC_S_FMT
), valid_ioctls
);
585 if (ops
->vidioc_try_fmt_vid_cap
||
586 ops
->vidioc_try_fmt_vid_out
||
587 ops
->vidioc_try_fmt_vid_cap_mplane
||
588 ops
->vidioc_try_fmt_vid_out_mplane
||
589 ops
->vidioc_try_fmt_vid_overlay
||
590 ops
->vidioc_try_fmt_vbi_cap
||
591 ops
->vidioc_try_fmt_vid_out_overlay
||
592 ops
->vidioc_try_fmt_vbi_out
||
593 ops
->vidioc_try_fmt_sliced_vbi_cap
||
594 ops
->vidioc_try_fmt_sliced_vbi_out
||
595 ops
->vidioc_try_fmt_type_private
)
596 set_bit(_IOC_NR(VIDIOC_TRY_FMT
), valid_ioctls
);
597 SET_VALID_IOCTL(ops
, VIDIOC_REQBUFS
, vidioc_reqbufs
);
598 SET_VALID_IOCTL(ops
, VIDIOC_QUERYBUF
, vidioc_querybuf
);
599 SET_VALID_IOCTL(ops
, VIDIOC_QBUF
, vidioc_qbuf
);
600 SET_VALID_IOCTL(ops
, VIDIOC_DQBUF
, vidioc_dqbuf
);
601 SET_VALID_IOCTL(ops
, VIDIOC_OVERLAY
, vidioc_overlay
);
602 SET_VALID_IOCTL(ops
, VIDIOC_G_FBUF
, vidioc_g_fbuf
);
603 SET_VALID_IOCTL(ops
, VIDIOC_S_FBUF
, vidioc_s_fbuf
);
604 SET_VALID_IOCTL(ops
, VIDIOC_STREAMON
, vidioc_streamon
);
605 SET_VALID_IOCTL(ops
, VIDIOC_STREAMOFF
, vidioc_streamoff
);
607 set_bit(_IOC_NR(VIDIOC_ENUMSTD
), valid_ioctls
);
608 if (ops
->vidioc_g_std
|| vdev
->current_norm
)
609 set_bit(_IOC_NR(VIDIOC_G_STD
), valid_ioctls
);
610 SET_VALID_IOCTL(ops
, VIDIOC_S_STD
, vidioc_s_std
);
611 SET_VALID_IOCTL(ops
, VIDIOC_QUERYSTD
, vidioc_querystd
);
612 SET_VALID_IOCTL(ops
, VIDIOC_ENUMINPUT
, vidioc_enum_input
);
613 SET_VALID_IOCTL(ops
, VIDIOC_G_INPUT
, vidioc_g_input
);
614 SET_VALID_IOCTL(ops
, VIDIOC_S_INPUT
, vidioc_s_input
);
615 SET_VALID_IOCTL(ops
, VIDIOC_ENUMOUTPUT
, vidioc_enum_output
);
616 SET_VALID_IOCTL(ops
, VIDIOC_G_OUTPUT
, vidioc_g_output
);
617 SET_VALID_IOCTL(ops
, VIDIOC_S_OUTPUT
, vidioc_s_output
);
618 /* Note: the control handler can also be passed through the filehandle,
619 and that can't be tested here. If the bit for these control ioctls
620 is set, then the ioctl is valid. But if it is 0, then it can still
621 be valid if the filehandle passed the control handler. */
622 if (vdev
->ctrl_handler
|| ops
->vidioc_queryctrl
)
623 set_bit(_IOC_NR(VIDIOC_QUERYCTRL
), valid_ioctls
);
624 if (vdev
->ctrl_handler
|| ops
->vidioc_g_ctrl
|| ops
->vidioc_g_ext_ctrls
)
625 set_bit(_IOC_NR(VIDIOC_G_CTRL
), valid_ioctls
);
626 if (vdev
->ctrl_handler
|| ops
->vidioc_s_ctrl
|| ops
->vidioc_s_ext_ctrls
)
627 set_bit(_IOC_NR(VIDIOC_S_CTRL
), valid_ioctls
);
628 if (vdev
->ctrl_handler
|| ops
->vidioc_g_ext_ctrls
)
629 set_bit(_IOC_NR(VIDIOC_G_EXT_CTRLS
), valid_ioctls
);
630 if (vdev
->ctrl_handler
|| ops
->vidioc_s_ext_ctrls
)
631 set_bit(_IOC_NR(VIDIOC_S_EXT_CTRLS
), valid_ioctls
);
632 if (vdev
->ctrl_handler
|| ops
->vidioc_try_ext_ctrls
)
633 set_bit(_IOC_NR(VIDIOC_TRY_EXT_CTRLS
), valid_ioctls
);
634 if (vdev
->ctrl_handler
|| ops
->vidioc_querymenu
)
635 set_bit(_IOC_NR(VIDIOC_QUERYMENU
), valid_ioctls
);
636 SET_VALID_IOCTL(ops
, VIDIOC_ENUMAUDIO
, vidioc_enumaudio
);
637 SET_VALID_IOCTL(ops
, VIDIOC_G_AUDIO
, vidioc_g_audio
);
638 SET_VALID_IOCTL(ops
, VIDIOC_S_AUDIO
, vidioc_s_audio
);
639 SET_VALID_IOCTL(ops
, VIDIOC_ENUMAUDOUT
, vidioc_enumaudout
);
640 SET_VALID_IOCTL(ops
, VIDIOC_G_AUDOUT
, vidioc_g_audout
);
641 SET_VALID_IOCTL(ops
, VIDIOC_S_AUDOUT
, vidioc_s_audout
);
642 SET_VALID_IOCTL(ops
, VIDIOC_G_MODULATOR
, vidioc_g_modulator
);
643 SET_VALID_IOCTL(ops
, VIDIOC_S_MODULATOR
, vidioc_s_modulator
);
644 if (ops
->vidioc_g_crop
|| ops
->vidioc_g_selection
)
645 set_bit(_IOC_NR(VIDIOC_G_CROP
), valid_ioctls
);
646 if (ops
->vidioc_s_crop
|| ops
->vidioc_s_selection
)
647 set_bit(_IOC_NR(VIDIOC_S_CROP
), valid_ioctls
);
648 SET_VALID_IOCTL(ops
, VIDIOC_G_SELECTION
, vidioc_g_selection
);
649 SET_VALID_IOCTL(ops
, VIDIOC_S_SELECTION
, vidioc_s_selection
);
650 if (ops
->vidioc_cropcap
|| ops
->vidioc_g_selection
)
651 set_bit(_IOC_NR(VIDIOC_CROPCAP
), valid_ioctls
);
652 SET_VALID_IOCTL(ops
, VIDIOC_G_JPEGCOMP
, vidioc_g_jpegcomp
);
653 SET_VALID_IOCTL(ops
, VIDIOC_S_JPEGCOMP
, vidioc_s_jpegcomp
);
654 SET_VALID_IOCTL(ops
, VIDIOC_G_ENC_INDEX
, vidioc_g_enc_index
);
655 SET_VALID_IOCTL(ops
, VIDIOC_ENCODER_CMD
, vidioc_encoder_cmd
);
656 SET_VALID_IOCTL(ops
, VIDIOC_TRY_ENCODER_CMD
, vidioc_try_encoder_cmd
);
657 SET_VALID_IOCTL(ops
, VIDIOC_DECODER_CMD
, vidioc_decoder_cmd
);
658 SET_VALID_IOCTL(ops
, VIDIOC_TRY_DECODER_CMD
, vidioc_try_decoder_cmd
);
659 if (ops
->vidioc_g_parm
|| vdev
->current_norm
)
660 set_bit(_IOC_NR(VIDIOC_G_PARM
), valid_ioctls
);
661 SET_VALID_IOCTL(ops
, VIDIOC_S_PARM
, vidioc_s_parm
);
662 SET_VALID_IOCTL(ops
, VIDIOC_G_TUNER
, vidioc_g_tuner
);
663 SET_VALID_IOCTL(ops
, VIDIOC_S_TUNER
, vidioc_s_tuner
);
664 SET_VALID_IOCTL(ops
, VIDIOC_G_FREQUENCY
, vidioc_g_frequency
);
665 SET_VALID_IOCTL(ops
, VIDIOC_S_FREQUENCY
, vidioc_s_frequency
);
666 SET_VALID_IOCTL(ops
, VIDIOC_G_SLICED_VBI_CAP
, vidioc_g_sliced_vbi_cap
);
667 SET_VALID_IOCTL(ops
, VIDIOC_LOG_STATUS
, vidioc_log_status
);
668 #ifdef CONFIG_VIDEO_ADV_DEBUG
669 SET_VALID_IOCTL(ops
, VIDIOC_DBG_G_REGISTER
, vidioc_g_register
);
670 SET_VALID_IOCTL(ops
, VIDIOC_DBG_S_REGISTER
, vidioc_s_register
);
672 SET_VALID_IOCTL(ops
, VIDIOC_DBG_G_CHIP_IDENT
, vidioc_g_chip_ident
);
673 SET_VALID_IOCTL(ops
, VIDIOC_S_HW_FREQ_SEEK
, vidioc_s_hw_freq_seek
);
674 SET_VALID_IOCTL(ops
, VIDIOC_ENUM_FRAMESIZES
, vidioc_enum_framesizes
);
675 SET_VALID_IOCTL(ops
, VIDIOC_ENUM_FRAMEINTERVALS
, vidioc_enum_frameintervals
);
676 SET_VALID_IOCTL(ops
, VIDIOC_ENUM_DV_PRESETS
, vidioc_enum_dv_presets
);
677 SET_VALID_IOCTL(ops
, VIDIOC_S_DV_PRESET
, vidioc_s_dv_preset
);
678 SET_VALID_IOCTL(ops
, VIDIOC_G_DV_PRESET
, vidioc_g_dv_preset
);
679 SET_VALID_IOCTL(ops
, VIDIOC_QUERY_DV_PRESET
, vidioc_query_dv_preset
);
680 SET_VALID_IOCTL(ops
, VIDIOC_S_DV_TIMINGS
, vidioc_s_dv_timings
);
681 SET_VALID_IOCTL(ops
, VIDIOC_G_DV_TIMINGS
, vidioc_g_dv_timings
);
682 /* yes, really vidioc_subscribe_event */
683 SET_VALID_IOCTL(ops
, VIDIOC_DQEVENT
, vidioc_subscribe_event
);
684 SET_VALID_IOCTL(ops
, VIDIOC_SUBSCRIBE_EVENT
, vidioc_subscribe_event
);
685 SET_VALID_IOCTL(ops
, VIDIOC_UNSUBSCRIBE_EVENT
, vidioc_unsubscribe_event
);
686 SET_VALID_IOCTL(ops
, VIDIOC_CREATE_BUFS
, vidioc_create_bufs
);
687 SET_VALID_IOCTL(ops
, VIDIOC_PREPARE_BUF
, vidioc_prepare_buf
);
688 bitmap_andnot(vdev
->valid_ioctls
, valid_ioctls
, vdev
->valid_ioctls
,
689 BASE_VIDIOC_PRIVATE
);
693 * __video_register_device - register video4linux devices
694 * @vdev: video device structure we want to register
695 * @type: type of device to register
696 * @nr: which device node number (0 == /dev/video0, 1 == /dev/video1, ...
698 * @warn_if_nr_in_use: warn if the desired device node number
699 * was already in use and another number was chosen instead.
700 * @owner: module that owns the video device node
702 * The registration code assigns minor numbers and device node numbers
703 * based on the requested type and registers the new device node with
706 * This function assumes that struct video_device was zeroed when it
707 * was allocated and does not contain any stale date.
709 * An error is returned if no free minor or device node number could be
710 * found, or if the registration of the device node failed.
712 * Zero is returned on success.
716 * %VFL_TYPE_GRABBER - A frame grabber
718 * %VFL_TYPE_VBI - Vertical blank data (undecoded)
720 * %VFL_TYPE_RADIO - A radio card
722 * %VFL_TYPE_SUBDEV - A subdevice
724 int __video_register_device(struct video_device
*vdev
, int type
, int nr
,
725 int warn_if_nr_in_use
, struct module
*owner
)
729 int minor_offset
= 0;
730 int minor_cnt
= VIDEO_NUM_DEVICES
;
731 const char *name_base
;
733 /* A minor value of -1 marks this video device as never
734 having been registered */
737 /* the release callback MUST be present */
738 if (WARN_ON(!vdev
->release
))
741 /* v4l2_fh support */
742 spin_lock_init(&vdev
->fh_lock
);
743 INIT_LIST_HEAD(&vdev
->fh_list
);
745 /* Part 1: check device type */
747 case VFL_TYPE_GRABBER
:
756 case VFL_TYPE_SUBDEV
:
757 name_base
= "v4l-subdev";
760 printk(KERN_ERR
"%s called with unknown type: %d\n",
765 vdev
->vfl_type
= type
;
767 if (vdev
->v4l2_dev
) {
768 if (vdev
->v4l2_dev
->dev
)
769 vdev
->parent
= vdev
->v4l2_dev
->dev
;
770 if (vdev
->ctrl_handler
== NULL
)
771 vdev
->ctrl_handler
= vdev
->v4l2_dev
->ctrl_handler
;
772 /* If the prio state pointer is NULL, then use the v4l2_device
774 if (vdev
->prio
== NULL
)
775 vdev
->prio
= &vdev
->v4l2_dev
->prio
;
778 /* Part 2: find a free minor, device node number and device index. */
779 #ifdef CONFIG_VIDEO_FIXED_MINOR_RANGES
780 /* Keep the ranges for the first four types for historical
782 * Newer devices (not yet in place) should use the range
783 * of 128-191 and just pick the first free minor there
786 case VFL_TYPE_GRABBER
:
805 /* Pick a device node number */
806 mutex_lock(&videodev_lock
);
807 nr
= devnode_find(vdev
, nr
== -1 ? 0 : nr
, minor_cnt
);
809 nr
= devnode_find(vdev
, 0, minor_cnt
);
810 if (nr
== minor_cnt
) {
811 printk(KERN_ERR
"could not get a free device node number\n");
812 mutex_unlock(&videodev_lock
);
815 #ifdef CONFIG_VIDEO_FIXED_MINOR_RANGES
816 /* 1-on-1 mapping of device node number to minor number */
819 /* The device node number and minor numbers are independent, so
820 we just find the first free minor number. */
821 for (i
= 0; i
< VIDEO_NUM_DEVICES
; i
++)
822 if (video_device
[i
] == NULL
)
824 if (i
== VIDEO_NUM_DEVICES
) {
825 mutex_unlock(&videodev_lock
);
826 printk(KERN_ERR
"could not get a free minor\n");
830 vdev
->minor
= i
+ minor_offset
;
834 /* Should not happen since we thought this minor was free */
835 WARN_ON(video_device
[vdev
->minor
] != NULL
);
836 vdev
->index
= get_index(vdev
);
837 mutex_unlock(&videodev_lock
);
838 /* if no lock was passed, then make sure the LOCK_ALL_FOPS bit is
839 clear and warn if it wasn't. */
840 if (vdev
->lock
== NULL
)
841 WARN_ON(test_and_clear_bit(V4L2_FL_LOCK_ALL_FOPS
, &vdev
->flags
));
844 determine_valid_ioctls(vdev
);
846 /* Part 3: Initialize the character device */
847 vdev
->cdev
= cdev_alloc();
848 if (vdev
->cdev
== NULL
) {
852 vdev
->cdev
->ops
= &v4l2_fops
;
853 vdev
->cdev
->owner
= owner
;
854 ret
= cdev_add(vdev
->cdev
, MKDEV(VIDEO_MAJOR
, vdev
->minor
), 1);
856 printk(KERN_ERR
"%s: cdev_add failed\n", __func__
);
862 /* Part 4: register the device with sysfs */
863 vdev
->dev
.class = &video_class
;
864 vdev
->dev
.devt
= MKDEV(VIDEO_MAJOR
, vdev
->minor
);
866 vdev
->dev
.parent
= vdev
->parent
;
867 dev_set_name(&vdev
->dev
, "%s%d", name_base
, vdev
->num
);
868 ret
= device_register(&vdev
->dev
);
870 printk(KERN_ERR
"%s: device_register failed\n", __func__
);
873 /* Register the release callback that will be called when the last
874 reference to the device goes away. */
875 vdev
->dev
.release
= v4l2_device_release
;
877 if (nr
!= -1 && nr
!= vdev
->num
&& warn_if_nr_in_use
)
878 printk(KERN_WARNING
"%s: requested %s%d, got %s\n", __func__
,
879 name_base
, nr
, video_device_node_name(vdev
));
881 /* Increase v4l2_device refcount */
883 v4l2_device_get(vdev
->v4l2_dev
);
885 #if defined(CONFIG_MEDIA_CONTROLLER)
886 /* Part 5: Register the entity. */
887 if (vdev
->v4l2_dev
&& vdev
->v4l2_dev
->mdev
&&
888 vdev
->vfl_type
!= VFL_TYPE_SUBDEV
) {
889 vdev
->entity
.type
= MEDIA_ENT_T_DEVNODE_V4L
;
890 vdev
->entity
.name
= vdev
->name
;
891 vdev
->entity
.info
.v4l
.major
= VIDEO_MAJOR
;
892 vdev
->entity
.info
.v4l
.minor
= vdev
->minor
;
893 ret
= media_device_register_entity(vdev
->v4l2_dev
->mdev
,
897 "%s: media_device_register_entity failed\n",
901 /* Part 6: Activate this minor. The char device can now be used. */
902 set_bit(V4L2_FL_REGISTERED
, &vdev
->flags
);
903 mutex_lock(&videodev_lock
);
904 video_device
[vdev
->minor
] = vdev
;
905 mutex_unlock(&videodev_lock
);
910 mutex_lock(&videodev_lock
);
912 cdev_del(vdev
->cdev
);
914 mutex_unlock(&videodev_lock
);
915 /* Mark this video device as never having been registered. */
919 EXPORT_SYMBOL(__video_register_device
);
922 * video_unregister_device - unregister a video4linux device
923 * @vdev: the device to unregister
925 * This unregisters the passed device. Future open calls will
926 * be met with errors.
928 void video_unregister_device(struct video_device
*vdev
)
930 /* Check if vdev was ever registered at all */
931 if (!vdev
|| !video_is_registered(vdev
))
934 mutex_lock(&videodev_lock
);
935 /* This must be in a critical section to prevent a race with v4l2_open.
936 * Once this bit has been cleared video_get may never be called again.
938 clear_bit(V4L2_FL_REGISTERED
, &vdev
->flags
);
939 mutex_unlock(&videodev_lock
);
940 device_unregister(&vdev
->dev
);
942 EXPORT_SYMBOL(video_unregister_device
);
945 * Initialise video for linux
947 static int __init
videodev_init(void)
949 dev_t dev
= MKDEV(VIDEO_MAJOR
, 0);
952 printk(KERN_INFO
"Linux video capture interface: v2.00\n");
953 ret
= register_chrdev_region(dev
, VIDEO_NUM_DEVICES
, VIDEO_NAME
);
955 printk(KERN_WARNING
"videodev: unable to get major %d\n",
960 ret
= class_register(&video_class
);
962 unregister_chrdev_region(dev
, VIDEO_NUM_DEVICES
);
963 printk(KERN_WARNING
"video_dev: class_register failed\n");
970 static void __exit
videodev_exit(void)
972 dev_t dev
= MKDEV(VIDEO_MAJOR
, 0);
974 class_unregister(&video_class
);
975 unregister_chrdev_region(dev
, VIDEO_NUM_DEVICES
);
978 subsys_initcall(videodev_init
);
979 module_exit(videodev_exit
)
981 MODULE_AUTHOR("Alan Cox, Mauro Carvalho Chehab <mchehab@infradead.org>");
982 MODULE_DESCRIPTION("Device registrar for Video4Linux drivers v2");
983 MODULE_LICENSE("GPL");
984 MODULE_ALIAS_CHARDEV_MAJOR(VIDEO_MAJOR
);