1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
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
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
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
99
100
101
102
103#ifdef CONFIG_VIDEO_FIXED_MINOR_RANGES
104
105static inline unsigned long *devnode_bits(int vfl_type)
106{
107
108
109
110 int idx = (vfl_type > VFL_TYPE_RADIO) ? VFL_TYPE_MAX - 1 : vfl_type;
111
112 return devnode_nums[idx];
113}
114#else
115
116static inline unsigned long *devnode_bits(int vfl_type)
117{
118 return devnode_nums[vfl_type];
119}
120#endif
121
122
123static inline void devnode_set(struct video_device *vdev)
124{
125 set_bit(vdev->num, devnode_bits(vdev->vfl_type));
126}
127
128
129static inline void devnode_clear(struct video_device *vdev)
130{
131 clear_bit(vdev->num, devnode_bits(vdev->vfl_type));
132}
133
134
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
155
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
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
178 mutex_unlock(&videodev_lock);
179 return;
180 }
181
182
183 video_device[vdev->minor] = NULL;
184
185
186 cdev_del(vdev->cdev);
187
188
189 vdev->cdev = NULL;
190
191
192 devnode_clear(vdev);
193
194 mutex_unlock(&videodev_lock);
195
196#if defined(CONFIG_MEDIA_CONTROLLER)
197 if (v4l2_dev->mdev &&
198 vdev->vfl_type != VFL_TYPE_SUBDEV)
199 media_device_unregister_entity(&vdev->entity);
200#endif
201
202
203
204
205
206
207
208
209
210 if (v4l2_dev->release == NULL)
211 v4l2_dev = NULL;
212
213
214
215 vdev->release(vdev);
216
217
218 if (v4l2_dev)
219 v4l2_device_put(v4l2_dev);
220}
221
222static struct class video_class = {
223 .name = VIDEO_NAME,
224 .dev_groups = video_device_groups,
225};
226
227struct video_device *video_devdata(struct file *file)
228{
229 return video_device[iminor(file_inode(file))];
230}
231EXPORT_SYMBOL(video_devdata);
232
233
234
235
236static inline bool prio_is_valid(enum v4l2_priority prio)
237{
238 return prio == V4L2_PRIORITY_BACKGROUND ||
239 prio == V4L2_PRIORITY_INTERACTIVE ||
240 prio == V4L2_PRIORITY_RECORD;
241}
242
243void v4l2_prio_init(struct v4l2_prio_state *global)
244{
245 memset(global, 0, sizeof(*global));
246}
247EXPORT_SYMBOL(v4l2_prio_init);
248
249int v4l2_prio_change(struct v4l2_prio_state *global, enum v4l2_priority *local,
250 enum v4l2_priority new)
251{
252 if (!prio_is_valid(new))
253 return -EINVAL;
254 if (*local == new)
255 return 0;
256
257 atomic_inc(&global->prios[new]);
258 if (prio_is_valid(*local))
259 atomic_dec(&global->prios[*local]);
260 *local = new;
261 return 0;
262}
263EXPORT_SYMBOL(v4l2_prio_change);
264
265void v4l2_prio_open(struct v4l2_prio_state *global, enum v4l2_priority *local)
266{
267 v4l2_prio_change(global, local, V4L2_PRIORITY_DEFAULT);
268}
269EXPORT_SYMBOL(v4l2_prio_open);
270
271void v4l2_prio_close(struct v4l2_prio_state *global, enum v4l2_priority local)
272{
273 if (prio_is_valid(local))
274 atomic_dec(&global->prios[local]);
275}
276EXPORT_SYMBOL(v4l2_prio_close);
277
278enum v4l2_priority v4l2_prio_max(struct v4l2_prio_state *global)
279{
280 if (atomic_read(&global->prios[V4L2_PRIORITY_RECORD]) > 0)
281 return V4L2_PRIORITY_RECORD;
282 if (atomic_read(&global->prios[V4L2_PRIORITY_INTERACTIVE]) > 0)
283 return V4L2_PRIORITY_INTERACTIVE;
284 if (atomic_read(&global->prios[V4L2_PRIORITY_BACKGROUND]) > 0)
285 return V4L2_PRIORITY_BACKGROUND;
286 return V4L2_PRIORITY_UNSET;
287}
288EXPORT_SYMBOL(v4l2_prio_max);
289
290int v4l2_prio_check(struct v4l2_prio_state *global, enum v4l2_priority local)
291{
292 return (local < v4l2_prio_max(global)) ? -EBUSY : 0;
293}
294EXPORT_SYMBOL(v4l2_prio_check);
295
296
297static ssize_t v4l2_read(struct file *filp, char __user *buf,
298 size_t sz, loff_t *off)
299{
300 struct video_device *vdev = video_devdata(filp);
301 int ret = -ENODEV;
302
303 if (!vdev->fops->read)
304 return -EINVAL;
305 if (video_is_registered(vdev))
306 ret = vdev->fops->read(filp, buf, sz, off);
307 if ((vdev->dev_debug & V4L2_DEV_DEBUG_FOP) &&
308 (vdev->dev_debug & V4L2_DEV_DEBUG_STREAMING))
309 printk(KERN_DEBUG "%s: read: %zd (%d)\n",
310 video_device_node_name(vdev), sz, ret);
311 return ret;
312}
313
314static ssize_t v4l2_write(struct file *filp, const char __user *buf,
315 size_t sz, loff_t *off)
316{
317 struct video_device *vdev = video_devdata(filp);
318 int ret = -ENODEV;
319
320 if (!vdev->fops->write)
321 return -EINVAL;
322 if (video_is_registered(vdev))
323 ret = vdev->fops->write(filp, buf, sz, off);
324 if ((vdev->dev_debug & V4L2_DEV_DEBUG_FOP) &&
325 (vdev->dev_debug & V4L2_DEV_DEBUG_STREAMING))
326 printk(KERN_DEBUG "%s: write: %zd (%d)\n",
327 video_device_node_name(vdev), sz, ret);
328 return ret;
329}
330
331static unsigned int v4l2_poll(struct file *filp, struct poll_table_struct *poll)
332{
333 struct video_device *vdev = video_devdata(filp);
334 unsigned int res = POLLERR | POLLHUP;
335
336 if (!vdev->fops->poll)
337 return DEFAULT_POLLMASK;
338 if (video_is_registered(vdev))
339 res = vdev->fops->poll(filp, poll);
340 if (vdev->dev_debug & V4L2_DEV_DEBUG_POLL)
341 printk(KERN_DEBUG "%s: poll: %08x\n",
342 video_device_node_name(vdev), res);
343 return res;
344}
345
346static long v4l2_ioctl(struct file *filp, unsigned int cmd, unsigned long arg)
347{
348 struct video_device *vdev = video_devdata(filp);
349 int ret = -ENODEV;
350
351 if (vdev->fops->unlocked_ioctl) {
352 struct mutex *lock = v4l2_ioctl_get_lock(vdev, cmd);
353
354 if (lock && mutex_lock_interruptible(lock))
355 return -ERESTARTSYS;
356 if (video_is_registered(vdev))
357 ret = vdev->fops->unlocked_ioctl(filp, cmd, arg);
358 if (lock)
359 mutex_unlock(lock);
360 } else
361 ret = -ENOTTY;
362
363 return ret;
364}
365
366#ifdef CONFIG_MMU
367#define v4l2_get_unmapped_area NULL
368#else
369static unsigned long v4l2_get_unmapped_area(struct file *filp,
370 unsigned long addr, unsigned long len, unsigned long pgoff,
371 unsigned long flags)
372{
373 struct video_device *vdev = video_devdata(filp);
374 int ret;
375
376 if (!vdev->fops->get_unmapped_area)
377 return -ENOSYS;
378 if (!video_is_registered(vdev))
379 return -ENODEV;
380 ret = vdev->fops->get_unmapped_area(filp, addr, len, pgoff, flags);
381 if (vdev->dev_debug & V4L2_DEV_DEBUG_FOP)
382 printk(KERN_DEBUG "%s: get_unmapped_area (%d)\n",
383 video_device_node_name(vdev), ret);
384 return ret;
385}
386#endif
387
388static int v4l2_mmap(struct file *filp, struct vm_area_struct *vm)
389{
390 struct video_device *vdev = video_devdata(filp);
391 int ret = -ENODEV;
392
393 if (!vdev->fops->mmap)
394 return -ENODEV;
395 if (video_is_registered(vdev))
396 ret = vdev->fops->mmap(filp, vm);
397 if (vdev->dev_debug & V4L2_DEV_DEBUG_FOP)
398 printk(KERN_DEBUG "%s: mmap (%d)\n",
399 video_device_node_name(vdev), ret);
400 return ret;
401}
402
403
404static int v4l2_open(struct inode *inode, struct file *filp)
405{
406 struct video_device *vdev;
407 int ret = 0;
408
409
410 mutex_lock(&videodev_lock);
411 vdev = video_devdata(filp);
412
413 if (vdev == NULL || !video_is_registered(vdev)) {
414 mutex_unlock(&videodev_lock);
415 return -ENODEV;
416 }
417
418 video_get(vdev);
419 mutex_unlock(&videodev_lock);
420 if (vdev->fops->open) {
421 if (video_is_registered(vdev))
422 ret = vdev->fops->open(filp);
423 else
424 ret = -ENODEV;
425 }
426
427 if (vdev->dev_debug & V4L2_DEV_DEBUG_FOP)
428 printk(KERN_DEBUG "%s: open (%d)\n",
429 video_device_node_name(vdev), ret);
430
431 if (ret)
432 video_put(vdev);
433 return ret;
434}
435
436
437static int v4l2_release(struct inode *inode, struct file *filp)
438{
439 struct video_device *vdev = video_devdata(filp);
440 int ret = 0;
441
442 if (vdev->fops->release)
443 ret = vdev->fops->release(filp);
444 if (vdev->dev_debug & V4L2_DEV_DEBUG_FOP)
445 printk(KERN_DEBUG "%s: release\n",
446 video_device_node_name(vdev));
447
448
449
450 video_put(vdev);
451 return ret;
452}
453
454static const struct file_operations v4l2_fops = {
455 .owner = THIS_MODULE,
456 .read = v4l2_read,
457 .write = v4l2_write,
458 .open = v4l2_open,
459 .get_unmapped_area = v4l2_get_unmapped_area,
460 .mmap = v4l2_mmap,
461 .unlocked_ioctl = v4l2_ioctl,
462#ifdef CONFIG_COMPAT
463 .compat_ioctl = v4l2_compat_ioctl32,
464#endif
465 .release = v4l2_release,
466 .poll = v4l2_poll,
467 .llseek = no_llseek,
468};
469
470
471
472
473
474
475
476
477
478
479
480
481
482
483static int get_index(struct video_device *vdev)
484{
485
486
487 static DECLARE_BITMAP(used, VIDEO_NUM_DEVICES);
488 int i;
489
490 bitmap_zero(used, VIDEO_NUM_DEVICES);
491
492 for (i = 0; i < VIDEO_NUM_DEVICES; i++) {
493 if (video_device[i] != NULL &&
494 video_device[i]->v4l2_dev == vdev->v4l2_dev) {
495 set_bit(video_device[i]->index, used);
496 }
497 }
498
499 return find_first_zero_bit(used, VIDEO_NUM_DEVICES);
500}
501
502#define SET_VALID_IOCTL(ops, cmd, op) \
503 if (ops->op) \
504 set_bit(_IOC_NR(cmd), valid_ioctls)
505
506
507
508
509
510
511
512
513
514
515
516
517
518
519static void determine_valid_ioctls(struct video_device *vdev)
520{
521 DECLARE_BITMAP(valid_ioctls, BASE_VIDIOC_PRIVATE);
522 const struct v4l2_ioctl_ops *ops = vdev->ioctl_ops;
523 bool is_vid = vdev->vfl_type == VFL_TYPE_GRABBER;
524 bool is_vbi = vdev->vfl_type == VFL_TYPE_VBI;
525 bool is_radio = vdev->vfl_type == VFL_TYPE_RADIO;
526 bool is_sdr = vdev->vfl_type == VFL_TYPE_SDR;
527 bool is_rx = vdev->vfl_dir != VFL_DIR_TX;
528 bool is_tx = vdev->vfl_dir != VFL_DIR_RX;
529
530 bitmap_zero(valid_ioctls, BASE_VIDIOC_PRIVATE);
531
532
533
534 SET_VALID_IOCTL(ops, VIDIOC_QUERYCAP, vidioc_querycap);
535 set_bit(_IOC_NR(VIDIOC_G_PRIORITY), valid_ioctls);
536 set_bit(_IOC_NR(VIDIOC_S_PRIORITY), valid_ioctls);
537
538
539
540
541
542 if (vdev->ctrl_handler || ops->vidioc_queryctrl)
543 set_bit(_IOC_NR(VIDIOC_QUERYCTRL), valid_ioctls);
544 if (vdev->ctrl_handler || ops->vidioc_query_ext_ctrl)
545 set_bit(_IOC_NR(VIDIOC_QUERY_EXT_CTRL), valid_ioctls);
546 if (vdev->ctrl_handler || ops->vidioc_g_ctrl || ops->vidioc_g_ext_ctrls)
547 set_bit(_IOC_NR(VIDIOC_G_CTRL), valid_ioctls);
548 if (vdev->ctrl_handler || ops->vidioc_s_ctrl || ops->vidioc_s_ext_ctrls)
549 set_bit(_IOC_NR(VIDIOC_S_CTRL), valid_ioctls);
550 if (vdev->ctrl_handler || ops->vidioc_g_ext_ctrls)
551 set_bit(_IOC_NR(VIDIOC_G_EXT_CTRLS), valid_ioctls);
552 if (vdev->ctrl_handler || ops->vidioc_s_ext_ctrls)
553 set_bit(_IOC_NR(VIDIOC_S_EXT_CTRLS), valid_ioctls);
554 if (vdev->ctrl_handler || ops->vidioc_try_ext_ctrls)
555 set_bit(_IOC_NR(VIDIOC_TRY_EXT_CTRLS), valid_ioctls);
556 if (vdev->ctrl_handler || ops->vidioc_querymenu)
557 set_bit(_IOC_NR(VIDIOC_QUERYMENU), valid_ioctls);
558 SET_VALID_IOCTL(ops, VIDIOC_G_FREQUENCY, vidioc_g_frequency);
559 SET_VALID_IOCTL(ops, VIDIOC_S_FREQUENCY, vidioc_s_frequency);
560 SET_VALID_IOCTL(ops, VIDIOC_LOG_STATUS, vidioc_log_status);
561#ifdef CONFIG_VIDEO_ADV_DEBUG
562 set_bit(_IOC_NR(VIDIOC_DBG_G_CHIP_INFO), valid_ioctls);
563 set_bit(_IOC_NR(VIDIOC_DBG_G_REGISTER), valid_ioctls);
564 set_bit(_IOC_NR(VIDIOC_DBG_S_REGISTER), valid_ioctls);
565#endif
566
567 SET_VALID_IOCTL(ops, VIDIOC_DQEVENT, vidioc_subscribe_event);
568 SET_VALID_IOCTL(ops, VIDIOC_SUBSCRIBE_EVENT, vidioc_subscribe_event);
569 SET_VALID_IOCTL(ops, VIDIOC_UNSUBSCRIBE_EVENT, vidioc_unsubscribe_event);
570 if (ops->vidioc_enum_freq_bands || ops->vidioc_g_tuner || ops->vidioc_g_modulator)
571 set_bit(_IOC_NR(VIDIOC_ENUM_FREQ_BANDS), valid_ioctls);
572
573 if (is_vid) {
574
575 if ((is_rx && (ops->vidioc_enum_fmt_vid_cap ||
576 ops->vidioc_enum_fmt_vid_cap_mplane ||
577 ops->vidioc_enum_fmt_vid_overlay)) ||
578 (is_tx && (ops->vidioc_enum_fmt_vid_out ||
579 ops->vidioc_enum_fmt_vid_out_mplane)))
580 set_bit(_IOC_NR(VIDIOC_ENUM_FMT), valid_ioctls);
581 if ((is_rx && (ops->vidioc_g_fmt_vid_cap ||
582 ops->vidioc_g_fmt_vid_cap_mplane ||
583 ops->vidioc_g_fmt_vid_overlay)) ||
584 (is_tx && (ops->vidioc_g_fmt_vid_out ||
585 ops->vidioc_g_fmt_vid_out_mplane ||
586 ops->vidioc_g_fmt_vid_out_overlay)))
587 set_bit(_IOC_NR(VIDIOC_G_FMT), valid_ioctls);
588 if ((is_rx && (ops->vidioc_s_fmt_vid_cap ||
589 ops->vidioc_s_fmt_vid_cap_mplane ||
590 ops->vidioc_s_fmt_vid_overlay)) ||
591 (is_tx && (ops->vidioc_s_fmt_vid_out ||
592 ops->vidioc_s_fmt_vid_out_mplane ||
593 ops->vidioc_s_fmt_vid_out_overlay)))
594 set_bit(_IOC_NR(VIDIOC_S_FMT), valid_ioctls);
595 if ((is_rx && (ops->vidioc_try_fmt_vid_cap ||
596 ops->vidioc_try_fmt_vid_cap_mplane ||
597 ops->vidioc_try_fmt_vid_overlay)) ||
598 (is_tx && (ops->vidioc_try_fmt_vid_out ||
599 ops->vidioc_try_fmt_vid_out_mplane ||
600 ops->vidioc_try_fmt_vid_out_overlay)))
601 set_bit(_IOC_NR(VIDIOC_TRY_FMT), valid_ioctls);
602 SET_VALID_IOCTL(ops, VIDIOC_OVERLAY, vidioc_overlay);
603 SET_VALID_IOCTL(ops, VIDIOC_G_FBUF, vidioc_g_fbuf);
604 SET_VALID_IOCTL(ops, VIDIOC_S_FBUF, vidioc_s_fbuf);
605 SET_VALID_IOCTL(ops, VIDIOC_G_JPEGCOMP, vidioc_g_jpegcomp);
606 SET_VALID_IOCTL(ops, VIDIOC_S_JPEGCOMP, vidioc_s_jpegcomp);
607 SET_VALID_IOCTL(ops, VIDIOC_G_ENC_INDEX, vidioc_g_enc_index);
608 SET_VALID_IOCTL(ops, VIDIOC_ENCODER_CMD, vidioc_encoder_cmd);
609 SET_VALID_IOCTL(ops, VIDIOC_TRY_ENCODER_CMD, vidioc_try_encoder_cmd);
610 SET_VALID_IOCTL(ops, VIDIOC_DECODER_CMD, vidioc_decoder_cmd);
611 SET_VALID_IOCTL(ops, VIDIOC_TRY_DECODER_CMD, vidioc_try_decoder_cmd);
612 SET_VALID_IOCTL(ops, VIDIOC_ENUM_FRAMESIZES, vidioc_enum_framesizes);
613 SET_VALID_IOCTL(ops, VIDIOC_ENUM_FRAMEINTERVALS, vidioc_enum_frameintervals);
614 if (ops->vidioc_g_crop || ops->vidioc_g_selection)
615 set_bit(_IOC_NR(VIDIOC_G_CROP), valid_ioctls);
616 if (ops->vidioc_s_crop || ops->vidioc_s_selection)
617 set_bit(_IOC_NR(VIDIOC_S_CROP), valid_ioctls);
618 SET_VALID_IOCTL(ops, VIDIOC_G_SELECTION, vidioc_g_selection);
619 SET_VALID_IOCTL(ops, VIDIOC_S_SELECTION, vidioc_s_selection);
620 if (ops->vidioc_cropcap || ops->vidioc_g_selection)
621 set_bit(_IOC_NR(VIDIOC_CROPCAP), valid_ioctls);
622 } else if (is_vbi) {
623
624 if ((is_rx && (ops->vidioc_g_fmt_vbi_cap ||
625 ops->vidioc_g_fmt_sliced_vbi_cap)) ||
626 (is_tx && (ops->vidioc_g_fmt_vbi_out ||
627 ops->vidioc_g_fmt_sliced_vbi_out)))
628 set_bit(_IOC_NR(VIDIOC_G_FMT), valid_ioctls);
629 if ((is_rx && (ops->vidioc_s_fmt_vbi_cap ||
630 ops->vidioc_s_fmt_sliced_vbi_cap)) ||
631 (is_tx && (ops->vidioc_s_fmt_vbi_out ||
632 ops->vidioc_s_fmt_sliced_vbi_out)))
633 set_bit(_IOC_NR(VIDIOC_S_FMT), valid_ioctls);
634 if ((is_rx && (ops->vidioc_try_fmt_vbi_cap ||
635 ops->vidioc_try_fmt_sliced_vbi_cap)) ||
636 (is_tx && (ops->vidioc_try_fmt_vbi_out ||
637 ops->vidioc_try_fmt_sliced_vbi_out)))
638 set_bit(_IOC_NR(VIDIOC_TRY_FMT), valid_ioctls);
639 SET_VALID_IOCTL(ops, VIDIOC_G_SLICED_VBI_CAP, vidioc_g_sliced_vbi_cap);
640 } else if (is_sdr) {
641
642 if (ops->vidioc_enum_fmt_sdr_cap)
643 set_bit(_IOC_NR(VIDIOC_ENUM_FMT), valid_ioctls);
644 if (ops->vidioc_g_fmt_sdr_cap)
645 set_bit(_IOC_NR(VIDIOC_G_FMT), valid_ioctls);
646 if (ops->vidioc_s_fmt_sdr_cap)
647 set_bit(_IOC_NR(VIDIOC_S_FMT), valid_ioctls);
648 if (ops->vidioc_try_fmt_sdr_cap)
649 set_bit(_IOC_NR(VIDIOC_TRY_FMT), valid_ioctls);
650 }
651
652 if (is_vid || is_vbi || is_sdr) {
653
654 SET_VALID_IOCTL(ops, VIDIOC_REQBUFS, vidioc_reqbufs);
655 SET_VALID_IOCTL(ops, VIDIOC_QUERYBUF, vidioc_querybuf);
656 SET_VALID_IOCTL(ops, VIDIOC_QBUF, vidioc_qbuf);
657 SET_VALID_IOCTL(ops, VIDIOC_EXPBUF, vidioc_expbuf);
658 SET_VALID_IOCTL(ops, VIDIOC_DQBUF, vidioc_dqbuf);
659 SET_VALID_IOCTL(ops, VIDIOC_CREATE_BUFS, vidioc_create_bufs);
660 SET_VALID_IOCTL(ops, VIDIOC_PREPARE_BUF, vidioc_prepare_buf);
661 SET_VALID_IOCTL(ops, VIDIOC_STREAMON, vidioc_streamon);
662 SET_VALID_IOCTL(ops, VIDIOC_STREAMOFF, vidioc_streamoff);
663 }
664
665 if (is_vid || is_vbi) {
666
667 if (ops->vidioc_s_std)
668 set_bit(_IOC_NR(VIDIOC_ENUMSTD), valid_ioctls);
669 SET_VALID_IOCTL(ops, VIDIOC_S_STD, vidioc_s_std);
670 SET_VALID_IOCTL(ops, VIDIOC_G_STD, vidioc_g_std);
671 if (is_rx) {
672 SET_VALID_IOCTL(ops, VIDIOC_QUERYSTD, vidioc_querystd);
673 SET_VALID_IOCTL(ops, VIDIOC_ENUMINPUT, vidioc_enum_input);
674 SET_VALID_IOCTL(ops, VIDIOC_G_INPUT, vidioc_g_input);
675 SET_VALID_IOCTL(ops, VIDIOC_S_INPUT, vidioc_s_input);
676 SET_VALID_IOCTL(ops, VIDIOC_ENUMAUDIO, vidioc_enumaudio);
677 SET_VALID_IOCTL(ops, VIDIOC_G_AUDIO, vidioc_g_audio);
678 SET_VALID_IOCTL(ops, VIDIOC_S_AUDIO, vidioc_s_audio);
679 SET_VALID_IOCTL(ops, VIDIOC_QUERY_DV_TIMINGS, vidioc_query_dv_timings);
680 SET_VALID_IOCTL(ops, VIDIOC_S_EDID, vidioc_s_edid);
681 }
682 if (is_tx) {
683 SET_VALID_IOCTL(ops, VIDIOC_ENUMOUTPUT, vidioc_enum_output);
684 SET_VALID_IOCTL(ops, VIDIOC_G_OUTPUT, vidioc_g_output);
685 SET_VALID_IOCTL(ops, VIDIOC_S_OUTPUT, vidioc_s_output);
686 SET_VALID_IOCTL(ops, VIDIOC_ENUMAUDOUT, vidioc_enumaudout);
687 SET_VALID_IOCTL(ops, VIDIOC_G_AUDOUT, vidioc_g_audout);
688 SET_VALID_IOCTL(ops, VIDIOC_S_AUDOUT, vidioc_s_audout);
689 }
690 if (ops->vidioc_g_parm || (vdev->vfl_type == VFL_TYPE_GRABBER &&
691 ops->vidioc_g_std))
692 set_bit(_IOC_NR(VIDIOC_G_PARM), valid_ioctls);
693 SET_VALID_IOCTL(ops, VIDIOC_S_PARM, vidioc_s_parm);
694 SET_VALID_IOCTL(ops, VIDIOC_S_DV_TIMINGS, vidioc_s_dv_timings);
695 SET_VALID_IOCTL(ops, VIDIOC_G_DV_TIMINGS, vidioc_g_dv_timings);
696 SET_VALID_IOCTL(ops, VIDIOC_ENUM_DV_TIMINGS, vidioc_enum_dv_timings);
697 SET_VALID_IOCTL(ops, VIDIOC_DV_TIMINGS_CAP, vidioc_dv_timings_cap);
698 SET_VALID_IOCTL(ops, VIDIOC_G_EDID, vidioc_g_edid);
699 }
700 if (is_tx && (is_radio || is_sdr)) {
701
702 SET_VALID_IOCTL(ops, VIDIOC_G_MODULATOR, vidioc_g_modulator);
703 SET_VALID_IOCTL(ops, VIDIOC_S_MODULATOR, vidioc_s_modulator);
704 }
705 if (is_rx) {
706
707 SET_VALID_IOCTL(ops, VIDIOC_G_TUNER, vidioc_g_tuner);
708 SET_VALID_IOCTL(ops, VIDIOC_S_TUNER, vidioc_s_tuner);
709 SET_VALID_IOCTL(ops, VIDIOC_S_HW_FREQ_SEEK, vidioc_s_hw_freq_seek);
710 }
711
712 bitmap_andnot(vdev->valid_ioctls, valid_ioctls, vdev->valid_ioctls,
713 BASE_VIDIOC_PRIVATE);
714}
715
716
717
718
719
720
721
722
723
724
725
726
727
728
729
730
731
732
733
734
735
736
737
738
739
740
741
742
743
744
745
746
747
748
749
750int __video_register_device(struct video_device *vdev, int type, int nr,
751 int warn_if_nr_in_use, struct module *owner)
752{
753 int i = 0;
754 int ret;
755 int minor_offset = 0;
756 int minor_cnt = VIDEO_NUM_DEVICES;
757 const char *name_base;
758
759
760
761 vdev->minor = -1;
762
763
764 if (WARN_ON(!vdev->release))
765 return -EINVAL;
766
767 if (WARN_ON(!vdev->v4l2_dev))
768 return -EINVAL;
769
770
771 spin_lock_init(&vdev->fh_lock);
772 INIT_LIST_HEAD(&vdev->fh_list);
773
774
775 switch (type) {
776 case VFL_TYPE_GRABBER:
777 name_base = "video";
778 break;
779 case VFL_TYPE_VBI:
780 name_base = "vbi";
781 break;
782 case VFL_TYPE_RADIO:
783 name_base = "radio";
784 break;
785 case VFL_TYPE_SUBDEV:
786 name_base = "v4l-subdev";
787 break;
788 case VFL_TYPE_SDR:
789
790 name_base = "swradio";
791 break;
792 default:
793 printk(KERN_ERR "%s called with unknown type: %d\n",
794 __func__, type);
795 return -EINVAL;
796 }
797
798 vdev->vfl_type = type;
799 vdev->cdev = NULL;
800 if (vdev->dev_parent == NULL)
801 vdev->dev_parent = vdev->v4l2_dev->dev;
802 if (vdev->ctrl_handler == NULL)
803 vdev->ctrl_handler = vdev->v4l2_dev->ctrl_handler;
804
805
806 if (vdev->prio == NULL)
807 vdev->prio = &vdev->v4l2_dev->prio;
808
809
810#ifdef CONFIG_VIDEO_FIXED_MINOR_RANGES
811
812
813
814
815
816 switch (type) {
817 case VFL_TYPE_GRABBER:
818 minor_offset = 0;
819 minor_cnt = 64;
820 break;
821 case VFL_TYPE_RADIO:
822 minor_offset = 64;
823 minor_cnt = 64;
824 break;
825 case VFL_TYPE_VBI:
826 minor_offset = 224;
827 minor_cnt = 32;
828 break;
829 default:
830 minor_offset = 128;
831 minor_cnt = 64;
832 break;
833 }
834#endif
835
836
837 mutex_lock(&videodev_lock);
838 nr = devnode_find(vdev, nr == -1 ? 0 : nr, minor_cnt);
839 if (nr == minor_cnt)
840 nr = devnode_find(vdev, 0, minor_cnt);
841 if (nr == minor_cnt) {
842 printk(KERN_ERR "could not get a free device node number\n");
843 mutex_unlock(&videodev_lock);
844 return -ENFILE;
845 }
846#ifdef CONFIG_VIDEO_FIXED_MINOR_RANGES
847
848 i = nr;
849#else
850
851
852 for (i = 0; i < VIDEO_NUM_DEVICES; i++)
853 if (video_device[i] == NULL)
854 break;
855 if (i == VIDEO_NUM_DEVICES) {
856 mutex_unlock(&videodev_lock);
857 printk(KERN_ERR "could not get a free minor\n");
858 return -ENFILE;
859 }
860#endif
861 vdev->minor = i + minor_offset;
862 vdev->num = nr;
863 devnode_set(vdev);
864
865
866 WARN_ON(video_device[vdev->minor] != NULL);
867 vdev->index = get_index(vdev);
868 video_device[vdev->minor] = vdev;
869 mutex_unlock(&videodev_lock);
870
871 if (vdev->ioctl_ops)
872 determine_valid_ioctls(vdev);
873
874
875 vdev->cdev = cdev_alloc();
876 if (vdev->cdev == NULL) {
877 ret = -ENOMEM;
878 goto cleanup;
879 }
880 vdev->cdev->ops = &v4l2_fops;
881 vdev->cdev->owner = owner;
882 ret = cdev_add(vdev->cdev, MKDEV(VIDEO_MAJOR, vdev->minor), 1);
883 if (ret < 0) {
884 printk(KERN_ERR "%s: cdev_add failed\n", __func__);
885 kfree(vdev->cdev);
886 vdev->cdev = NULL;
887 goto cleanup;
888 }
889
890
891 vdev->dev.class = &video_class;
892 vdev->dev.devt = MKDEV(VIDEO_MAJOR, vdev->minor);
893 vdev->dev.parent = vdev->dev_parent;
894 dev_set_name(&vdev->dev, "%s%d", name_base, vdev->num);
895 ret = device_register(&vdev->dev);
896 if (ret < 0) {
897 printk(KERN_ERR "%s: device_register failed\n", __func__);
898 goto cleanup;
899 }
900
901
902 vdev->dev.release = v4l2_device_release;
903
904 if (nr != -1 && nr != vdev->num && warn_if_nr_in_use)
905 printk(KERN_WARNING "%s: requested %s%d, got %s\n", __func__,
906 name_base, nr, video_device_node_name(vdev));
907
908
909 v4l2_device_get(vdev->v4l2_dev);
910
911#if defined(CONFIG_MEDIA_CONTROLLER)
912
913 if (vdev->v4l2_dev->mdev &&
914 vdev->vfl_type != VFL_TYPE_SUBDEV) {
915 vdev->entity.type = MEDIA_ENT_T_DEVNODE_V4L;
916 vdev->entity.name = vdev->name;
917 vdev->entity.info.dev.major = VIDEO_MAJOR;
918 vdev->entity.info.dev.minor = vdev->minor;
919 ret = media_device_register_entity(vdev->v4l2_dev->mdev,
920 &vdev->entity);
921 if (ret < 0)
922 printk(KERN_WARNING
923 "%s: media_device_register_entity failed\n",
924 __func__);
925 }
926#endif
927
928 set_bit(V4L2_FL_REGISTERED, &vdev->flags);
929
930 return 0;
931
932cleanup:
933 mutex_lock(&videodev_lock);
934 if (vdev->cdev)
935 cdev_del(vdev->cdev);
936 video_device[vdev->minor] = NULL;
937 devnode_clear(vdev);
938 mutex_unlock(&videodev_lock);
939
940 vdev->minor = -1;
941 return ret;
942}
943EXPORT_SYMBOL(__video_register_device);
944
945
946
947
948
949
950
951
952void video_unregister_device(struct video_device *vdev)
953{
954
955 if (!vdev || !video_is_registered(vdev))
956 return;
957
958 mutex_lock(&videodev_lock);
959
960
961
962 clear_bit(V4L2_FL_REGISTERED, &vdev->flags);
963 mutex_unlock(&videodev_lock);
964 device_unregister(&vdev->dev);
965}
966EXPORT_SYMBOL(video_unregister_device);
967
968
969
970
971static int __init videodev_init(void)
972{
973 dev_t dev = MKDEV(VIDEO_MAJOR, 0);
974 int ret;
975
976 printk(KERN_INFO "Linux video capture interface: v2.00\n");
977 ret = register_chrdev_region(dev, VIDEO_NUM_DEVICES, VIDEO_NAME);
978 if (ret < 0) {
979 printk(KERN_WARNING "videodev: unable to get major %d\n",
980 VIDEO_MAJOR);
981 return ret;
982 }
983
984 ret = class_register(&video_class);
985 if (ret < 0) {
986 unregister_chrdev_region(dev, VIDEO_NUM_DEVICES);
987 printk(KERN_WARNING "video_dev: class_register failed\n");
988 return -EIO;
989 }
990
991 return 0;
992}
993
994static void __exit videodev_exit(void)
995{
996 dev_t dev = MKDEV(VIDEO_MAJOR, 0);
997
998 class_unregister(&video_class);
999 unregister_chrdev_region(dev, VIDEO_NUM_DEVICES);
1000}
1001
1002subsys_initcall(videodev_init);
1003module_exit(videodev_exit)
1004
1005MODULE_AUTHOR("Alan Cox, Mauro Carvalho Chehab <mchehab@infradead.org>");
1006MODULE_DESCRIPTION("Device registrar for Video4Linux drivers v2");
1007MODULE_LICENSE("GPL");
1008MODULE_ALIAS_CHARDEV_MAJOR(VIDEO_MAJOR);
1009