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