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