1
2
3
4
5
6
7
8
9
10
11
12
13
14
15#define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
16
17#include <linux/debugfs.h>
18#include <linux/module.h>
19#include <linux/types.h>
20#include <linux/kernel.h>
21#include <linux/mm.h>
22#include <linux/string.h>
23#include <linux/errno.h>
24#include <linux/init.h>
25#include <linux/kmod.h>
26#include <linux/slab.h>
27#include <linux/uaccess.h>
28
29#include <media/v4l2-common.h>
30#include <media/v4l2-device.h>
31#include <media/v4l2-ioctl.h>
32#include <media/v4l2-event.h>
33
34#define VIDEO_NUM_DEVICES 256
35#define VIDEO_NAME "video4linux"
36
37#define dprintk(fmt, arg...) do { \
38 printk(KERN_DEBUG pr_fmt("%s: " fmt), \
39 __func__, ##arg); \
40} while (0)
41
42
43
44
45
46static ssize_t index_show(struct device *cd,
47 struct device_attribute *attr, char *buf)
48{
49 struct video_device *vdev = to_video_device(cd);
50
51 return sprintf(buf, "%i\n", vdev->index);
52}
53static DEVICE_ATTR_RO(index);
54
55static ssize_t dev_debug_show(struct device *cd,
56 struct device_attribute *attr, char *buf)
57{
58 struct video_device *vdev = to_video_device(cd);
59
60 return sprintf(buf, "%i\n", vdev->dev_debug);
61}
62
63static ssize_t dev_debug_store(struct device *cd, struct device_attribute *attr,
64 const char *buf, size_t len)
65{
66 struct video_device *vdev = to_video_device(cd);
67 int res = 0;
68 u16 value;
69
70 res = kstrtou16(buf, 0, &value);
71 if (res)
72 return res;
73
74 vdev->dev_debug = value;
75 return len;
76}
77static DEVICE_ATTR_RW(dev_debug);
78
79static ssize_t name_show(struct device *cd,
80 struct device_attribute *attr, char *buf)
81{
82 struct video_device *vdev = to_video_device(cd);
83
84 return sprintf(buf, "%.*s\n", (int)sizeof(vdev->name), vdev->name);
85}
86static DEVICE_ATTR_RO(name);
87
88static struct attribute *video_device_attrs[] = {
89 &dev_attr_name.attr,
90 &dev_attr_dev_debug.attr,
91 &dev_attr_index.attr,
92 NULL,
93};
94ATTRIBUTE_GROUPS(video_device);
95
96
97
98
99static struct video_device *video_devices[VIDEO_NUM_DEVICES];
100static DEFINE_MUTEX(videodev_lock);
101static DECLARE_BITMAP(devnode_nums[VFL_TYPE_MAX], VIDEO_NUM_DEVICES);
102
103
104
105
106
107
108#ifdef CONFIG_VIDEO_FIXED_MINOR_RANGES
109
110static inline unsigned long *devnode_bits(enum vfl_devnode_type vfl_type)
111{
112
113
114
115 int idx = (vfl_type > VFL_TYPE_RADIO) ? VFL_TYPE_MAX - 1 : vfl_type;
116
117 return devnode_nums[idx];
118}
119#else
120
121static inline unsigned long *devnode_bits(enum vfl_devnode_type vfl_type)
122{
123 return devnode_nums[vfl_type];
124}
125#endif
126
127
128static inline void devnode_set(struct video_device *vdev)
129{
130 set_bit(vdev->num, devnode_bits(vdev->vfl_type));
131}
132
133
134static inline void devnode_clear(struct video_device *vdev)
135{
136 clear_bit(vdev->num, devnode_bits(vdev->vfl_type));
137}
138
139
140static inline int devnode_find(struct video_device *vdev, int from, int to)
141{
142 return find_next_zero_bit(devnode_bits(vdev->vfl_type), to, from);
143}
144
145struct video_device *video_device_alloc(void)
146{
147 return kzalloc(sizeof(struct video_device), GFP_KERNEL);
148}
149EXPORT_SYMBOL(video_device_alloc);
150
151void video_device_release(struct video_device *vdev)
152{
153 kfree(vdev);
154}
155EXPORT_SYMBOL(video_device_release);
156
157void video_device_release_empty(struct video_device *vdev)
158{
159
160
161}
162EXPORT_SYMBOL(video_device_release_empty);
163
164static inline void video_get(struct video_device *vdev)
165{
166 get_device(&vdev->dev);
167}
168
169static inline void video_put(struct video_device *vdev)
170{
171 put_device(&vdev->dev);
172}
173
174
175static void v4l2_device_release(struct device *cd)
176{
177 struct video_device *vdev = to_video_device(cd);
178 struct v4l2_device *v4l2_dev = vdev->v4l2_dev;
179
180 mutex_lock(&videodev_lock);
181 if (WARN_ON(video_devices[vdev->minor] != vdev)) {
182
183 mutex_unlock(&videodev_lock);
184 return;
185 }
186
187
188 video_devices[vdev->minor] = NULL;
189
190
191 cdev_del(vdev->cdev);
192
193
194 vdev->cdev = NULL;
195
196
197 devnode_clear(vdev);
198
199 mutex_unlock(&videodev_lock);
200
201#if defined(CONFIG_MEDIA_CONTROLLER)
202 if (v4l2_dev->mdev && vdev->vfl_dir != VFL_DIR_M2M) {
203
204 media_devnode_remove(vdev->intf_devnode);
205 if (vdev->entity.function != MEDIA_ENT_F_UNKNOWN)
206 media_device_unregister_entity(&vdev->entity);
207 }
208#endif
209
210
211
212
213
214
215
216
217
218 if (v4l2_dev->release == NULL)
219 v4l2_dev = NULL;
220
221
222
223 vdev->release(vdev);
224
225
226 if (v4l2_dev)
227 v4l2_device_put(v4l2_dev);
228}
229
230static struct class video_class = {
231 .name = VIDEO_NAME,
232 .dev_groups = video_device_groups,
233};
234
235struct video_device *video_devdata(struct file *file)
236{
237 return video_devices[iminor(file_inode(file))];
238}
239EXPORT_SYMBOL(video_devdata);
240
241
242
243
244static inline bool prio_is_valid(enum v4l2_priority prio)
245{
246 return prio == V4L2_PRIORITY_BACKGROUND ||
247 prio == V4L2_PRIORITY_INTERACTIVE ||
248 prio == V4L2_PRIORITY_RECORD;
249}
250
251void v4l2_prio_init(struct v4l2_prio_state *global)
252{
253 memset(global, 0, sizeof(*global));
254}
255EXPORT_SYMBOL(v4l2_prio_init);
256
257int v4l2_prio_change(struct v4l2_prio_state *global, enum v4l2_priority *local,
258 enum v4l2_priority new)
259{
260 if (!prio_is_valid(new))
261 return -EINVAL;
262 if (*local == new)
263 return 0;
264
265 atomic_inc(&global->prios[new]);
266 if (prio_is_valid(*local))
267 atomic_dec(&global->prios[*local]);
268 *local = new;
269 return 0;
270}
271EXPORT_SYMBOL(v4l2_prio_change);
272
273void v4l2_prio_open(struct v4l2_prio_state *global, enum v4l2_priority *local)
274{
275 v4l2_prio_change(global, local, V4L2_PRIORITY_DEFAULT);
276}
277EXPORT_SYMBOL(v4l2_prio_open);
278
279void v4l2_prio_close(struct v4l2_prio_state *global, enum v4l2_priority local)
280{
281 if (prio_is_valid(local))
282 atomic_dec(&global->prios[local]);
283}
284EXPORT_SYMBOL(v4l2_prio_close);
285
286enum v4l2_priority v4l2_prio_max(struct v4l2_prio_state *global)
287{
288 if (atomic_read(&global->prios[V4L2_PRIORITY_RECORD]) > 0)
289 return V4L2_PRIORITY_RECORD;
290 if (atomic_read(&global->prios[V4L2_PRIORITY_INTERACTIVE]) > 0)
291 return V4L2_PRIORITY_INTERACTIVE;
292 if (atomic_read(&global->prios[V4L2_PRIORITY_BACKGROUND]) > 0)
293 return V4L2_PRIORITY_BACKGROUND;
294 return V4L2_PRIORITY_UNSET;
295}
296EXPORT_SYMBOL(v4l2_prio_max);
297
298int v4l2_prio_check(struct v4l2_prio_state *global, enum v4l2_priority local)
299{
300 return (local < v4l2_prio_max(global)) ? -EBUSY : 0;
301}
302EXPORT_SYMBOL(v4l2_prio_check);
303
304
305static ssize_t v4l2_read(struct file *filp, char __user *buf,
306 size_t sz, loff_t *off)
307{
308 struct video_device *vdev = video_devdata(filp);
309 int ret = -ENODEV;
310
311 if (!vdev->fops->read)
312 return -EINVAL;
313 if (video_is_registered(vdev))
314 ret = vdev->fops->read(filp, buf, sz, off);
315 if ((vdev->dev_debug & V4L2_DEV_DEBUG_FOP) &&
316 (vdev->dev_debug & V4L2_DEV_DEBUG_STREAMING))
317 dprintk("%s: read: %zd (%d)\n",
318 video_device_node_name(vdev), sz, ret);
319 return ret;
320}
321
322static ssize_t v4l2_write(struct file *filp, const char __user *buf,
323 size_t sz, loff_t *off)
324{
325 struct video_device *vdev = video_devdata(filp);
326 int ret = -ENODEV;
327
328 if (!vdev->fops->write)
329 return -EINVAL;
330 if (video_is_registered(vdev))
331 ret = vdev->fops->write(filp, buf, sz, off);
332 if ((vdev->dev_debug & V4L2_DEV_DEBUG_FOP) &&
333 (vdev->dev_debug & V4L2_DEV_DEBUG_STREAMING))
334 dprintk("%s: write: %zd (%d)\n",
335 video_device_node_name(vdev), sz, ret);
336 return ret;
337}
338
339static __poll_t v4l2_poll(struct file *filp, struct poll_table_struct *poll)
340{
341 struct video_device *vdev = video_devdata(filp);
342 __poll_t res = EPOLLERR | EPOLLHUP | EPOLLPRI;
343
344 if (video_is_registered(vdev)) {
345 if (!vdev->fops->poll)
346 res = DEFAULT_POLLMASK;
347 else
348 res = vdev->fops->poll(filp, poll);
349 }
350 if (vdev->dev_debug & V4L2_DEV_DEBUG_POLL)
351 dprintk("%s: poll: %08x %08x\n",
352 video_device_node_name(vdev), res,
353 poll_requested_events(poll));
354 return res;
355}
356
357static long v4l2_ioctl(struct file *filp, unsigned int cmd, unsigned long arg)
358{
359 struct video_device *vdev = video_devdata(filp);
360 int ret = -ENODEV;
361
362 if (vdev->fops->unlocked_ioctl) {
363 if (video_is_registered(vdev))
364 ret = vdev->fops->unlocked_ioctl(filp, cmd, arg);
365 } else
366 ret = -ENOTTY;
367
368 return ret;
369}
370
371#ifdef CONFIG_MMU
372#define v4l2_get_unmapped_area NULL
373#else
374static unsigned long v4l2_get_unmapped_area(struct file *filp,
375 unsigned long addr, unsigned long len, unsigned long pgoff,
376 unsigned long flags)
377{
378 struct video_device *vdev = video_devdata(filp);
379 int ret;
380
381 if (!vdev->fops->get_unmapped_area)
382 return -ENOSYS;
383 if (!video_is_registered(vdev))
384 return -ENODEV;
385 ret = vdev->fops->get_unmapped_area(filp, addr, len, pgoff, flags);
386 if (vdev->dev_debug & V4L2_DEV_DEBUG_FOP)
387 dprintk("%s: get_unmapped_area (%d)\n",
388 video_device_node_name(vdev), ret);
389 return ret;
390}
391#endif
392
393static int v4l2_mmap(struct file *filp, struct vm_area_struct *vm)
394{
395 struct video_device *vdev = video_devdata(filp);
396 int ret = -ENODEV;
397
398 if (!vdev->fops->mmap)
399 return -ENODEV;
400 if (video_is_registered(vdev))
401 ret = vdev->fops->mmap(filp, vm);
402 if (vdev->dev_debug & V4L2_DEV_DEBUG_FOP)
403 dprintk("%s: mmap (%d)\n",
404 video_device_node_name(vdev), ret);
405 return ret;
406}
407
408
409static int v4l2_open(struct inode *inode, struct file *filp)
410{
411 struct video_device *vdev;
412 int ret = 0;
413
414
415 mutex_lock(&videodev_lock);
416 vdev = video_devdata(filp);
417
418 if (vdev == NULL || !video_is_registered(vdev)) {
419 mutex_unlock(&videodev_lock);
420 return -ENODEV;
421 }
422
423 video_get(vdev);
424 mutex_unlock(&videodev_lock);
425 if (vdev->fops->open) {
426 if (video_is_registered(vdev))
427 ret = vdev->fops->open(filp);
428 else
429 ret = -ENODEV;
430 }
431
432 if (vdev->dev_debug & V4L2_DEV_DEBUG_FOP)
433 dprintk("%s: open (%d)\n",
434 video_device_node_name(vdev), ret);
435
436 if (ret)
437 video_put(vdev);
438 return ret;
439}
440
441
442static int v4l2_release(struct inode *inode, struct file *filp)
443{
444 struct video_device *vdev = video_devdata(filp);
445 int ret = 0;
446
447
448
449
450
451
452
453 if (vdev->fops->release) {
454 if (v4l2_device_supports_requests(vdev->v4l2_dev)) {
455 mutex_lock(&vdev->v4l2_dev->mdev->req_queue_mutex);
456 ret = vdev->fops->release(filp);
457 mutex_unlock(&vdev->v4l2_dev->mdev->req_queue_mutex);
458 } else {
459 ret = vdev->fops->release(filp);
460 }
461 }
462
463 if (vdev->dev_debug & V4L2_DEV_DEBUG_FOP)
464 dprintk("%s: release\n",
465 video_device_node_name(vdev));
466
467
468
469 video_put(vdev);
470 return ret;
471}
472
473static const struct file_operations v4l2_fops = {
474 .owner = THIS_MODULE,
475 .read = v4l2_read,
476 .write = v4l2_write,
477 .open = v4l2_open,
478 .get_unmapped_area = v4l2_get_unmapped_area,
479 .mmap = v4l2_mmap,
480 .unlocked_ioctl = v4l2_ioctl,
481#ifdef CONFIG_COMPAT
482 .compat_ioctl = v4l2_compat_ioctl32,
483#endif
484 .release = v4l2_release,
485 .poll = v4l2_poll,
486 .llseek = no_llseek,
487};
488
489
490
491
492
493
494
495
496
497
498
499
500
501
502static int get_index(struct video_device *vdev)
503{
504
505
506 static DECLARE_BITMAP(used, VIDEO_NUM_DEVICES);
507 int i;
508
509 bitmap_zero(used, VIDEO_NUM_DEVICES);
510
511 for (i = 0; i < VIDEO_NUM_DEVICES; i++) {
512 if (video_devices[i] != NULL &&
513 video_devices[i]->v4l2_dev == vdev->v4l2_dev) {
514 set_bit(video_devices[i]->index, used);
515 }
516 }
517
518 return find_first_zero_bit(used, VIDEO_NUM_DEVICES);
519}
520
521#define SET_VALID_IOCTL(ops, cmd, op) \
522 do { if ((ops)->op) set_bit(_IOC_NR(cmd), valid_ioctls); } while (0)
523
524
525
526
527
528
529
530
531
532
533
534
535
536
537static void determine_valid_ioctls(struct video_device *vdev)
538{
539 const u32 vid_caps = V4L2_CAP_VIDEO_CAPTURE |
540 V4L2_CAP_VIDEO_CAPTURE_MPLANE |
541 V4L2_CAP_VIDEO_OUTPUT |
542 V4L2_CAP_VIDEO_OUTPUT_MPLANE |
543 V4L2_CAP_VIDEO_M2M | V4L2_CAP_VIDEO_M2M_MPLANE;
544 const u32 meta_caps = V4L2_CAP_META_CAPTURE |
545 V4L2_CAP_META_OUTPUT;
546 DECLARE_BITMAP(valid_ioctls, BASE_VIDIOC_PRIVATE);
547 const struct v4l2_ioctl_ops *ops = vdev->ioctl_ops;
548 bool is_vid = vdev->vfl_type == VFL_TYPE_VIDEO &&
549 (vdev->device_caps & vid_caps);
550 bool is_vbi = vdev->vfl_type == VFL_TYPE_VBI;
551 bool is_radio = vdev->vfl_type == VFL_TYPE_RADIO;
552 bool is_sdr = vdev->vfl_type == VFL_TYPE_SDR;
553 bool is_tch = vdev->vfl_type == VFL_TYPE_TOUCH;
554 bool is_meta = vdev->vfl_type == VFL_TYPE_VIDEO &&
555 (vdev->device_caps & meta_caps);
556 bool is_rx = vdev->vfl_dir != VFL_DIR_TX;
557 bool is_tx = vdev->vfl_dir != VFL_DIR_RX;
558 bool is_io_mc = vdev->device_caps & V4L2_CAP_IO_MC;
559
560 bitmap_zero(valid_ioctls, BASE_VIDIOC_PRIVATE);
561
562
563
564 SET_VALID_IOCTL(ops, VIDIOC_QUERYCAP, vidioc_querycap);
565 set_bit(_IOC_NR(VIDIOC_G_PRIORITY), valid_ioctls);
566 set_bit(_IOC_NR(VIDIOC_S_PRIORITY), valid_ioctls);
567
568
569
570
571
572 if (vdev->ctrl_handler || ops->vidioc_queryctrl)
573 set_bit(_IOC_NR(VIDIOC_QUERYCTRL), valid_ioctls);
574 if (vdev->ctrl_handler || ops->vidioc_query_ext_ctrl)
575 set_bit(_IOC_NR(VIDIOC_QUERY_EXT_CTRL), valid_ioctls);
576 if (vdev->ctrl_handler || ops->vidioc_g_ctrl || ops->vidioc_g_ext_ctrls)
577 set_bit(_IOC_NR(VIDIOC_G_CTRL), valid_ioctls);
578 if (vdev->ctrl_handler || ops->vidioc_s_ctrl || ops->vidioc_s_ext_ctrls)
579 set_bit(_IOC_NR(VIDIOC_S_CTRL), valid_ioctls);
580 if (vdev->ctrl_handler || ops->vidioc_g_ext_ctrls)
581 set_bit(_IOC_NR(VIDIOC_G_EXT_CTRLS), valid_ioctls);
582 if (vdev->ctrl_handler || ops->vidioc_s_ext_ctrls)
583 set_bit(_IOC_NR(VIDIOC_S_EXT_CTRLS), valid_ioctls);
584 if (vdev->ctrl_handler || ops->vidioc_try_ext_ctrls)
585 set_bit(_IOC_NR(VIDIOC_TRY_EXT_CTRLS), valid_ioctls);
586 if (vdev->ctrl_handler || ops->vidioc_querymenu)
587 set_bit(_IOC_NR(VIDIOC_QUERYMENU), valid_ioctls);
588 if (!is_tch) {
589 SET_VALID_IOCTL(ops, VIDIOC_G_FREQUENCY, vidioc_g_frequency);
590 SET_VALID_IOCTL(ops, VIDIOC_S_FREQUENCY, vidioc_s_frequency);
591 }
592 SET_VALID_IOCTL(ops, VIDIOC_LOG_STATUS, vidioc_log_status);
593#ifdef CONFIG_VIDEO_ADV_DEBUG
594 set_bit(_IOC_NR(VIDIOC_DBG_G_CHIP_INFO), valid_ioctls);
595 set_bit(_IOC_NR(VIDIOC_DBG_G_REGISTER), valid_ioctls);
596 set_bit(_IOC_NR(VIDIOC_DBG_S_REGISTER), valid_ioctls);
597#endif
598
599 SET_VALID_IOCTL(ops, VIDIOC_DQEVENT, vidioc_subscribe_event);
600 SET_VALID_IOCTL(ops, VIDIOC_SUBSCRIBE_EVENT, vidioc_subscribe_event);
601 SET_VALID_IOCTL(ops, VIDIOC_UNSUBSCRIBE_EVENT, vidioc_unsubscribe_event);
602 if (ops->vidioc_enum_freq_bands || ops->vidioc_g_tuner || ops->vidioc_g_modulator)
603 set_bit(_IOC_NR(VIDIOC_ENUM_FREQ_BANDS), valid_ioctls);
604
605 if (is_vid) {
606
607 if ((is_rx && (ops->vidioc_enum_fmt_vid_cap ||
608 ops->vidioc_enum_fmt_vid_overlay)) ||
609 (is_tx && ops->vidioc_enum_fmt_vid_out))
610 set_bit(_IOC_NR(VIDIOC_ENUM_FMT), valid_ioctls);
611 if ((is_rx && (ops->vidioc_g_fmt_vid_cap ||
612 ops->vidioc_g_fmt_vid_cap_mplane ||
613 ops->vidioc_g_fmt_vid_overlay)) ||
614 (is_tx && (ops->vidioc_g_fmt_vid_out ||
615 ops->vidioc_g_fmt_vid_out_mplane ||
616 ops->vidioc_g_fmt_vid_out_overlay)))
617 set_bit(_IOC_NR(VIDIOC_G_FMT), valid_ioctls);
618 if ((is_rx && (ops->vidioc_s_fmt_vid_cap ||
619 ops->vidioc_s_fmt_vid_cap_mplane ||
620 ops->vidioc_s_fmt_vid_overlay)) ||
621 (is_tx && (ops->vidioc_s_fmt_vid_out ||
622 ops->vidioc_s_fmt_vid_out_mplane ||
623 ops->vidioc_s_fmt_vid_out_overlay)))
624 set_bit(_IOC_NR(VIDIOC_S_FMT), valid_ioctls);
625 if ((is_rx && (ops->vidioc_try_fmt_vid_cap ||
626 ops->vidioc_try_fmt_vid_cap_mplane ||
627 ops->vidioc_try_fmt_vid_overlay)) ||
628 (is_tx && (ops->vidioc_try_fmt_vid_out ||
629 ops->vidioc_try_fmt_vid_out_mplane ||
630 ops->vidioc_try_fmt_vid_out_overlay)))
631 set_bit(_IOC_NR(VIDIOC_TRY_FMT), valid_ioctls);
632 SET_VALID_IOCTL(ops, VIDIOC_OVERLAY, vidioc_overlay);
633 SET_VALID_IOCTL(ops, VIDIOC_G_FBUF, vidioc_g_fbuf);
634 SET_VALID_IOCTL(ops, VIDIOC_S_FBUF, vidioc_s_fbuf);
635 SET_VALID_IOCTL(ops, VIDIOC_G_JPEGCOMP, vidioc_g_jpegcomp);
636 SET_VALID_IOCTL(ops, VIDIOC_S_JPEGCOMP, vidioc_s_jpegcomp);
637 SET_VALID_IOCTL(ops, VIDIOC_G_ENC_INDEX, vidioc_g_enc_index);
638 SET_VALID_IOCTL(ops, VIDIOC_ENCODER_CMD, vidioc_encoder_cmd);
639 SET_VALID_IOCTL(ops, VIDIOC_TRY_ENCODER_CMD, vidioc_try_encoder_cmd);
640 SET_VALID_IOCTL(ops, VIDIOC_DECODER_CMD, vidioc_decoder_cmd);
641 SET_VALID_IOCTL(ops, VIDIOC_TRY_DECODER_CMD, vidioc_try_decoder_cmd);
642 SET_VALID_IOCTL(ops, VIDIOC_ENUM_FRAMESIZES, vidioc_enum_framesizes);
643 SET_VALID_IOCTL(ops, VIDIOC_ENUM_FRAMEINTERVALS, vidioc_enum_frameintervals);
644 if (ops->vidioc_g_selection) {
645 set_bit(_IOC_NR(VIDIOC_G_CROP), valid_ioctls);
646 set_bit(_IOC_NR(VIDIOC_CROPCAP), valid_ioctls);
647 }
648 if (ops->vidioc_s_selection)
649 set_bit(_IOC_NR(VIDIOC_S_CROP), valid_ioctls);
650 SET_VALID_IOCTL(ops, VIDIOC_G_SELECTION, vidioc_g_selection);
651 SET_VALID_IOCTL(ops, VIDIOC_S_SELECTION, vidioc_s_selection);
652 }
653 if (is_meta && is_rx) {
654
655 SET_VALID_IOCTL(ops, VIDIOC_ENUM_FMT, vidioc_enum_fmt_meta_cap);
656 SET_VALID_IOCTL(ops, VIDIOC_G_FMT, vidioc_g_fmt_meta_cap);
657 SET_VALID_IOCTL(ops, VIDIOC_S_FMT, vidioc_s_fmt_meta_cap);
658 SET_VALID_IOCTL(ops, VIDIOC_TRY_FMT, vidioc_try_fmt_meta_cap);
659 } else if (is_meta && is_tx) {
660
661 SET_VALID_IOCTL(ops, VIDIOC_ENUM_FMT, vidioc_enum_fmt_meta_out);
662 SET_VALID_IOCTL(ops, VIDIOC_G_FMT, vidioc_g_fmt_meta_out);
663 SET_VALID_IOCTL(ops, VIDIOC_S_FMT, vidioc_s_fmt_meta_out);
664 SET_VALID_IOCTL(ops, VIDIOC_TRY_FMT, vidioc_try_fmt_meta_out);
665 }
666 if (is_vbi) {
667
668 if ((is_rx && (ops->vidioc_g_fmt_vbi_cap ||
669 ops->vidioc_g_fmt_sliced_vbi_cap)) ||
670 (is_tx && (ops->vidioc_g_fmt_vbi_out ||
671 ops->vidioc_g_fmt_sliced_vbi_out)))
672 set_bit(_IOC_NR(VIDIOC_G_FMT), valid_ioctls);
673 if ((is_rx && (ops->vidioc_s_fmt_vbi_cap ||
674 ops->vidioc_s_fmt_sliced_vbi_cap)) ||
675 (is_tx && (ops->vidioc_s_fmt_vbi_out ||
676 ops->vidioc_s_fmt_sliced_vbi_out)))
677 set_bit(_IOC_NR(VIDIOC_S_FMT), valid_ioctls);
678 if ((is_rx && (ops->vidioc_try_fmt_vbi_cap ||
679 ops->vidioc_try_fmt_sliced_vbi_cap)) ||
680 (is_tx && (ops->vidioc_try_fmt_vbi_out ||
681 ops->vidioc_try_fmt_sliced_vbi_out)))
682 set_bit(_IOC_NR(VIDIOC_TRY_FMT), valid_ioctls);
683 SET_VALID_IOCTL(ops, VIDIOC_G_SLICED_VBI_CAP, vidioc_g_sliced_vbi_cap);
684 } else if (is_tch) {
685
686 SET_VALID_IOCTL(ops, VIDIOC_ENUM_FMT, vidioc_enum_fmt_vid_cap);
687 SET_VALID_IOCTL(ops, VIDIOC_G_FMT, vidioc_g_fmt_vid_cap);
688 SET_VALID_IOCTL(ops, VIDIOC_S_FMT, vidioc_s_fmt_vid_cap);
689 SET_VALID_IOCTL(ops, VIDIOC_TRY_FMT, vidioc_try_fmt_vid_cap);
690 SET_VALID_IOCTL(ops, VIDIOC_ENUM_FRAMESIZES, vidioc_enum_framesizes);
691 SET_VALID_IOCTL(ops, VIDIOC_ENUM_FRAMEINTERVALS, vidioc_enum_frameintervals);
692 SET_VALID_IOCTL(ops, VIDIOC_ENUMINPUT, vidioc_enum_input);
693 SET_VALID_IOCTL(ops, VIDIOC_G_INPUT, vidioc_g_input);
694 SET_VALID_IOCTL(ops, VIDIOC_S_INPUT, vidioc_s_input);
695 SET_VALID_IOCTL(ops, VIDIOC_G_PARM, vidioc_g_parm);
696 SET_VALID_IOCTL(ops, VIDIOC_S_PARM, vidioc_s_parm);
697 } else if (is_sdr && is_rx) {
698
699 SET_VALID_IOCTL(ops, VIDIOC_ENUM_FMT, vidioc_enum_fmt_sdr_cap);
700 SET_VALID_IOCTL(ops, VIDIOC_G_FMT, vidioc_g_fmt_sdr_cap);
701 SET_VALID_IOCTL(ops, VIDIOC_S_FMT, vidioc_s_fmt_sdr_cap);
702 SET_VALID_IOCTL(ops, VIDIOC_TRY_FMT, vidioc_try_fmt_sdr_cap);
703 } else if (is_sdr && is_tx) {
704
705 SET_VALID_IOCTL(ops, VIDIOC_ENUM_FMT, vidioc_enum_fmt_sdr_out);
706 SET_VALID_IOCTL(ops, VIDIOC_G_FMT, vidioc_g_fmt_sdr_out);
707 SET_VALID_IOCTL(ops, VIDIOC_S_FMT, vidioc_s_fmt_sdr_out);
708 SET_VALID_IOCTL(ops, VIDIOC_TRY_FMT, vidioc_try_fmt_sdr_out);
709 }
710
711 if (is_vid || is_vbi || is_sdr || is_tch || is_meta) {
712
713 SET_VALID_IOCTL(ops, VIDIOC_REQBUFS, vidioc_reqbufs);
714 SET_VALID_IOCTL(ops, VIDIOC_QUERYBUF, vidioc_querybuf);
715 SET_VALID_IOCTL(ops, VIDIOC_QBUF, vidioc_qbuf);
716 SET_VALID_IOCTL(ops, VIDIOC_EXPBUF, vidioc_expbuf);
717 SET_VALID_IOCTL(ops, VIDIOC_DQBUF, vidioc_dqbuf);
718 SET_VALID_IOCTL(ops, VIDIOC_CREATE_BUFS, vidioc_create_bufs);
719 SET_VALID_IOCTL(ops, VIDIOC_PREPARE_BUF, vidioc_prepare_buf);
720 SET_VALID_IOCTL(ops, VIDIOC_STREAMON, vidioc_streamon);
721 SET_VALID_IOCTL(ops, VIDIOC_STREAMOFF, vidioc_streamoff);
722 }
723
724 if (is_vid || is_vbi || is_meta) {
725
726 if (ops->vidioc_s_std)
727 set_bit(_IOC_NR(VIDIOC_ENUMSTD), valid_ioctls);
728 SET_VALID_IOCTL(ops, VIDIOC_S_STD, vidioc_s_std);
729 SET_VALID_IOCTL(ops, VIDIOC_G_STD, vidioc_g_std);
730 if (is_rx) {
731 SET_VALID_IOCTL(ops, VIDIOC_QUERYSTD, vidioc_querystd);
732 if (is_io_mc) {
733 set_bit(_IOC_NR(VIDIOC_ENUMINPUT), valid_ioctls);
734 set_bit(_IOC_NR(VIDIOC_G_INPUT), valid_ioctls);
735 set_bit(_IOC_NR(VIDIOC_S_INPUT), valid_ioctls);
736 } else {
737 SET_VALID_IOCTL(ops, VIDIOC_ENUMINPUT, vidioc_enum_input);
738 SET_VALID_IOCTL(ops, VIDIOC_G_INPUT, vidioc_g_input);
739 SET_VALID_IOCTL(ops, VIDIOC_S_INPUT, vidioc_s_input);
740 }
741 SET_VALID_IOCTL(ops, VIDIOC_ENUMAUDIO, vidioc_enumaudio);
742 SET_VALID_IOCTL(ops, VIDIOC_G_AUDIO, vidioc_g_audio);
743 SET_VALID_IOCTL(ops, VIDIOC_S_AUDIO, vidioc_s_audio);
744 SET_VALID_IOCTL(ops, VIDIOC_QUERY_DV_TIMINGS, vidioc_query_dv_timings);
745 SET_VALID_IOCTL(ops, VIDIOC_S_EDID, vidioc_s_edid);
746 }
747 if (is_tx) {
748 if (is_io_mc) {
749 set_bit(_IOC_NR(VIDIOC_ENUMOUTPUT), valid_ioctls);
750 set_bit(_IOC_NR(VIDIOC_G_OUTPUT), valid_ioctls);
751 set_bit(_IOC_NR(VIDIOC_S_OUTPUT), valid_ioctls);
752 } else {
753 SET_VALID_IOCTL(ops, VIDIOC_ENUMOUTPUT, vidioc_enum_output);
754 SET_VALID_IOCTL(ops, VIDIOC_G_OUTPUT, vidioc_g_output);
755 SET_VALID_IOCTL(ops, VIDIOC_S_OUTPUT, vidioc_s_output);
756 }
757 SET_VALID_IOCTL(ops, VIDIOC_ENUMAUDOUT, vidioc_enumaudout);
758 SET_VALID_IOCTL(ops, VIDIOC_G_AUDOUT, vidioc_g_audout);
759 SET_VALID_IOCTL(ops, VIDIOC_S_AUDOUT, vidioc_s_audout);
760 }
761 if (ops->vidioc_g_parm || ops->vidioc_g_std)
762 set_bit(_IOC_NR(VIDIOC_G_PARM), valid_ioctls);
763 SET_VALID_IOCTL(ops, VIDIOC_S_PARM, vidioc_s_parm);
764 SET_VALID_IOCTL(ops, VIDIOC_S_DV_TIMINGS, vidioc_s_dv_timings);
765 SET_VALID_IOCTL(ops, VIDIOC_G_DV_TIMINGS, vidioc_g_dv_timings);
766 SET_VALID_IOCTL(ops, VIDIOC_ENUM_DV_TIMINGS, vidioc_enum_dv_timings);
767 SET_VALID_IOCTL(ops, VIDIOC_DV_TIMINGS_CAP, vidioc_dv_timings_cap);
768 SET_VALID_IOCTL(ops, VIDIOC_G_EDID, vidioc_g_edid);
769 }
770 if (is_tx && (is_radio || is_sdr)) {
771
772 SET_VALID_IOCTL(ops, VIDIOC_G_MODULATOR, vidioc_g_modulator);
773 SET_VALID_IOCTL(ops, VIDIOC_S_MODULATOR, vidioc_s_modulator);
774 }
775 if (is_rx && !is_tch) {
776
777 SET_VALID_IOCTL(ops, VIDIOC_G_TUNER, vidioc_g_tuner);
778 SET_VALID_IOCTL(ops, VIDIOC_S_TUNER, vidioc_s_tuner);
779 SET_VALID_IOCTL(ops, VIDIOC_S_HW_FREQ_SEEK, vidioc_s_hw_freq_seek);
780 }
781
782 bitmap_andnot(vdev->valid_ioctls, valid_ioctls, vdev->valid_ioctls,
783 BASE_VIDIOC_PRIVATE);
784}
785
786static int video_register_media_controller(struct video_device *vdev)
787{
788#if defined(CONFIG_MEDIA_CONTROLLER)
789 u32 intf_type;
790 int ret;
791
792
793
794
795 if (!vdev->v4l2_dev->mdev || vdev->vfl_dir == VFL_DIR_M2M)
796 return 0;
797
798 vdev->entity.obj_type = MEDIA_ENTITY_TYPE_VIDEO_DEVICE;
799 vdev->entity.function = MEDIA_ENT_F_UNKNOWN;
800
801 switch (vdev->vfl_type) {
802 case VFL_TYPE_VIDEO:
803 intf_type = MEDIA_INTF_T_V4L_VIDEO;
804 vdev->entity.function = MEDIA_ENT_F_IO_V4L;
805 break;
806 case VFL_TYPE_VBI:
807 intf_type = MEDIA_INTF_T_V4L_VBI;
808 vdev->entity.function = MEDIA_ENT_F_IO_VBI;
809 break;
810 case VFL_TYPE_SDR:
811 intf_type = MEDIA_INTF_T_V4L_SWRADIO;
812 vdev->entity.function = MEDIA_ENT_F_IO_SWRADIO;
813 break;
814 case VFL_TYPE_TOUCH:
815 intf_type = MEDIA_INTF_T_V4L_TOUCH;
816 vdev->entity.function = MEDIA_ENT_F_IO_V4L;
817 break;
818 case VFL_TYPE_RADIO:
819 intf_type = MEDIA_INTF_T_V4L_RADIO;
820
821
822
823
824
825 break;
826 case VFL_TYPE_SUBDEV:
827 intf_type = MEDIA_INTF_T_V4L_SUBDEV;
828
829 break;
830 default:
831 return 0;
832 }
833
834 if (vdev->entity.function != MEDIA_ENT_F_UNKNOWN) {
835 vdev->entity.name = vdev->name;
836
837
838 vdev->entity.info.dev.major = VIDEO_MAJOR;
839 vdev->entity.info.dev.minor = vdev->minor;
840
841 ret = media_device_register_entity(vdev->v4l2_dev->mdev,
842 &vdev->entity);
843 if (ret < 0) {
844 pr_warn("%s: media_device_register_entity failed\n",
845 __func__);
846 return ret;
847 }
848 }
849
850 vdev->intf_devnode = media_devnode_create(vdev->v4l2_dev->mdev,
851 intf_type,
852 0, VIDEO_MAJOR,
853 vdev->minor);
854 if (!vdev->intf_devnode) {
855 media_device_unregister_entity(&vdev->entity);
856 return -ENOMEM;
857 }
858
859 if (vdev->entity.function != MEDIA_ENT_F_UNKNOWN) {
860 struct media_link *link;
861
862 link = media_create_intf_link(&vdev->entity,
863 &vdev->intf_devnode->intf,
864 MEDIA_LNK_FL_ENABLED |
865 MEDIA_LNK_FL_IMMUTABLE);
866 if (!link) {
867 media_devnode_remove(vdev->intf_devnode);
868 media_device_unregister_entity(&vdev->entity);
869 return -ENOMEM;
870 }
871 }
872
873
874
875#endif
876 return 0;
877}
878
879int __video_register_device(struct video_device *vdev,
880 enum vfl_devnode_type type,
881 int nr, int warn_if_nr_in_use,
882 struct module *owner)
883{
884 int i = 0;
885 int ret;
886 int minor_offset = 0;
887 int minor_cnt = VIDEO_NUM_DEVICES;
888 const char *name_base;
889
890
891
892 vdev->minor = -1;
893
894
895 if (WARN_ON(!vdev->release))
896 return -EINVAL;
897
898 if (WARN_ON(!vdev->v4l2_dev))
899 return -EINVAL;
900
901 if (WARN_ON(type != VFL_TYPE_SUBDEV && !vdev->device_caps))
902 return -EINVAL;
903
904
905 spin_lock_init(&vdev->fh_lock);
906 INIT_LIST_HEAD(&vdev->fh_list);
907
908
909 switch (type) {
910 case VFL_TYPE_VIDEO:
911 name_base = "video";
912 break;
913 case VFL_TYPE_VBI:
914 name_base = "vbi";
915 break;
916 case VFL_TYPE_RADIO:
917 name_base = "radio";
918 break;
919 case VFL_TYPE_SUBDEV:
920 name_base = "v4l-subdev";
921 break;
922 case VFL_TYPE_SDR:
923
924 name_base = "swradio";
925 break;
926 case VFL_TYPE_TOUCH:
927 name_base = "v4l-touch";
928 break;
929 default:
930 pr_err("%s called with unknown type: %d\n",
931 __func__, type);
932 return -EINVAL;
933 }
934
935 vdev->vfl_type = type;
936 vdev->cdev = NULL;
937 if (vdev->dev_parent == NULL)
938 vdev->dev_parent = vdev->v4l2_dev->dev;
939 if (vdev->ctrl_handler == NULL)
940 vdev->ctrl_handler = vdev->v4l2_dev->ctrl_handler;
941
942
943 if (vdev->prio == NULL)
944 vdev->prio = &vdev->v4l2_dev->prio;
945
946
947#ifdef CONFIG_VIDEO_FIXED_MINOR_RANGES
948
949
950
951
952
953 switch (type) {
954 case VFL_TYPE_VIDEO:
955 minor_offset = 0;
956 minor_cnt = 64;
957 break;
958 case VFL_TYPE_RADIO:
959 minor_offset = 64;
960 minor_cnt = 64;
961 break;
962 case VFL_TYPE_VBI:
963 minor_offset = 224;
964 minor_cnt = 32;
965 break;
966 default:
967 minor_offset = 128;
968 minor_cnt = 64;
969 break;
970 }
971#endif
972
973
974 mutex_lock(&videodev_lock);
975 nr = devnode_find(vdev, nr == -1 ? 0 : nr, minor_cnt);
976 if (nr == minor_cnt)
977 nr = devnode_find(vdev, 0, minor_cnt);
978 if (nr == minor_cnt) {
979 pr_err("could not get a free device node number\n");
980 mutex_unlock(&videodev_lock);
981 return -ENFILE;
982 }
983#ifdef CONFIG_VIDEO_FIXED_MINOR_RANGES
984
985 i = nr;
986#else
987
988
989 for (i = 0; i < VIDEO_NUM_DEVICES; i++)
990 if (video_devices[i] == NULL)
991 break;
992 if (i == VIDEO_NUM_DEVICES) {
993 mutex_unlock(&videodev_lock);
994 pr_err("could not get a free minor\n");
995 return -ENFILE;
996 }
997#endif
998 vdev->minor = i + minor_offset;
999 vdev->num = nr;
1000
1001
1002 if (WARN_ON(video_devices[vdev->minor])) {
1003 mutex_unlock(&videodev_lock);
1004 pr_err("video_device not empty!\n");
1005 return -ENFILE;
1006 }
1007 devnode_set(vdev);
1008 vdev->index = get_index(vdev);
1009 video_devices[vdev->minor] = vdev;
1010 mutex_unlock(&videodev_lock);
1011
1012 if (vdev->ioctl_ops)
1013 determine_valid_ioctls(vdev);
1014
1015
1016 vdev->cdev = cdev_alloc();
1017 if (vdev->cdev == NULL) {
1018 ret = -ENOMEM;
1019 goto cleanup;
1020 }
1021 vdev->cdev->ops = &v4l2_fops;
1022 vdev->cdev->owner = owner;
1023 ret = cdev_add(vdev->cdev, MKDEV(VIDEO_MAJOR, vdev->minor), 1);
1024 if (ret < 0) {
1025 pr_err("%s: cdev_add failed\n", __func__);
1026 kfree(vdev->cdev);
1027 vdev->cdev = NULL;
1028 goto cleanup;
1029 }
1030
1031
1032 vdev->dev.class = &video_class;
1033 vdev->dev.devt = MKDEV(VIDEO_MAJOR, vdev->minor);
1034 vdev->dev.parent = vdev->dev_parent;
1035 dev_set_name(&vdev->dev, "%s%d", name_base, vdev->num);
1036 ret = device_register(&vdev->dev);
1037 if (ret < 0) {
1038 pr_err("%s: device_register failed\n", __func__);
1039 goto cleanup;
1040 }
1041
1042
1043 vdev->dev.release = v4l2_device_release;
1044
1045 if (nr != -1 && nr != vdev->num && warn_if_nr_in_use)
1046 pr_warn("%s: requested %s%d, got %s\n", __func__,
1047 name_base, nr, video_device_node_name(vdev));
1048
1049
1050 v4l2_device_get(vdev->v4l2_dev);
1051
1052
1053 ret = video_register_media_controller(vdev);
1054
1055
1056 set_bit(V4L2_FL_REGISTERED, &vdev->flags);
1057
1058 return 0;
1059
1060cleanup:
1061 mutex_lock(&videodev_lock);
1062 if (vdev->cdev)
1063 cdev_del(vdev->cdev);
1064 video_devices[vdev->minor] = NULL;
1065 devnode_clear(vdev);
1066 mutex_unlock(&videodev_lock);
1067
1068 vdev->minor = -1;
1069 return ret;
1070}
1071EXPORT_SYMBOL(__video_register_device);
1072
1073
1074
1075
1076
1077
1078
1079
1080void video_unregister_device(struct video_device *vdev)
1081{
1082
1083 if (!vdev || !video_is_registered(vdev))
1084 return;
1085
1086 mutex_lock(&videodev_lock);
1087
1088
1089
1090 clear_bit(V4L2_FL_REGISTERED, &vdev->flags);
1091 mutex_unlock(&videodev_lock);
1092 if (test_bit(V4L2_FL_USES_V4L2_FH, &vdev->flags))
1093 v4l2_event_wake_all(vdev);
1094 device_unregister(&vdev->dev);
1095}
1096EXPORT_SYMBOL(video_unregister_device);
1097
1098
1099
1100
1101static int __init videodev_init(void)
1102{
1103 dev_t dev = MKDEV(VIDEO_MAJOR, 0);
1104 int ret;
1105
1106 pr_info("Linux video capture interface: v2.00\n");
1107 ret = register_chrdev_region(dev, VIDEO_NUM_DEVICES, VIDEO_NAME);
1108 if (ret < 0) {
1109 pr_warn("videodev: unable to get major %d\n",
1110 VIDEO_MAJOR);
1111 return ret;
1112 }
1113
1114 ret = class_register(&video_class);
1115 if (ret < 0) {
1116 unregister_chrdev_region(dev, VIDEO_NUM_DEVICES);
1117 pr_warn("video_dev: class_register failed\n");
1118 return -EIO;
1119 }
1120
1121 return 0;
1122}
1123
1124static void __exit videodev_exit(void)
1125{
1126 dev_t dev = MKDEV(VIDEO_MAJOR, 0);
1127
1128 class_unregister(&video_class);
1129 unregister_chrdev_region(dev, VIDEO_NUM_DEVICES);
1130}
1131
1132subsys_initcall(videodev_init);
1133module_exit(videodev_exit)
1134
1135MODULE_AUTHOR("Alan Cox, Mauro Carvalho Chehab <mchehab@kernel.org>, Bill Dirks, Justin Schoeman, Gerd Knorr");
1136MODULE_DESCRIPTION("Video4Linux2 core driver");
1137MODULE_LICENSE("GPL");
1138MODULE_ALIAS_CHARDEV_MAJOR(VIDEO_MAJOR);
1139