projects / deliverable / linux.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
blame | history | raw | HEAD
drm/exynos: mixer: enable video overlay plane only when VP is available
[deliverable/linux.git] / drivers / media / v4l2-core / v4l2-dev.c
1 /*
2 * Video capture interface for Linux version 2
3 *
4 * A generic video device interface for the LINUX operating system
5 * using a set of device structures/vectors for low level operations.
6 *
7 * This program is free software; you can redistribute it and/or
8 * modify it under the terms of the GNU General Public License
9 * as published by the Free Software Foundation; either version
10 * 2 of the License, or (at your option) any later version.
11 *
12 * Authors: Alan Cox, <alan@lxorguk.ukuu.org.uk> (version 1)
13 * Mauro Carvalho Chehab <mchehab@infradead.org> (version 2)
14 *
15 * Fixes: 20000516 Claudio Matsuoka <claudio@conectiva.com>
16 * - Added procfs support
17 */
18
19 #include <linux/module.h>
20 #include <linux/types.h>
21 #include <linux/kernel.h>
22 #include <linux/mm.h>
23 #include <linux/string.h>
24 #include <linux/errno.h>
25 #include <linux/init.h>
26 #include <linux/kmod.h>
27 #include <linux/slab.h>
28 #include <asm/uaccess.h>
29
30 #include <media/v4l2-common.h>
31 #include <media/v4l2-device.h>
32 #include <media/v4l2-ioctl.h>
33
34 #define VIDEO_NUM_DEVICES 256
35 #define VIDEO_NAME "video4linux"
36
37 /*
38 * sysfs stuff
39 */
40
41 static 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 }
48 static DEVICE_ATTR_RO(index);
49
50 static 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
58 static 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 }
72 static DEVICE_ATTR_RW(dev_debug);
73
74 static 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 }
81 static DEVICE_ATTR_RO(name);
82
83 static struct attribute *video_device_attrs[] = {
84 &dev_attr_name.attr,
85 &dev_attr_dev_debug.attr,
86 &dev_attr_index.attr,
87 NULL,
88 };
89 ATTRIBUTE_GROUPS(video_device);
90
91 /*
92 * Active devices
93 */
94 static struct video_device *video_device[VIDEO_NUM_DEVICES];
95 static DEFINE_MUTEX(videodev_lock);
96 static DECLARE_BITMAP(devnode_nums[VFL_TYPE_MAX], VIDEO_NUM_DEVICES);
97
98 /* Device node utility functions */
99
100 /* Note: these utility functions all assume that vfl_type is in the range
101 [0, VFL_TYPE_MAX-1]. */
102
103 #ifdef CONFIG_VIDEO_FIXED_MINOR_RANGES
104 /* Return the bitmap corresponding to vfl_type. */
105 static inline unsigned long *devnode_bits(int vfl_type)
106 {
107 /* Any types not assigned to fixed minor ranges must be mapped to
108 one single bitmap for the purposes of finding a free node number
109 since all those unassigned types use the same minor range. */
110 int idx = (vfl_type > VFL_TYPE_RADIO) ? VFL_TYPE_MAX - 1 : vfl_type;
111
112 return devnode_nums[idx];
113 }
114 #else
115 /* Return the bitmap corresponding to vfl_type. */
116 static inline unsigned long *devnode_bits(int vfl_type)
117 {
118 return devnode_nums[vfl_type];
119 }
120 #endif
121
122 /* Mark device node number vdev->num as used */
123 static inline void devnode_set(struct video_device *vdev)
124 {
125 set_bit(vdev->num, devnode_bits(vdev->vfl_type));
126 }
127
128 /* Mark device node number vdev->num as unused */
129 static inline void devnode_clear(struct video_device *vdev)
130 {
131 clear_bit(vdev->num, devnode_bits(vdev->vfl_type));
132 }
133
134 /* Try to find a free device node number in the range [from, to> */
135 static 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
140 struct video_device *video_device_alloc(void)
141 {
142 return kzalloc(sizeof(struct video_device), GFP_KERNEL);
143 }
144 EXPORT_SYMBOL(video_device_alloc);
145
146 void video_device_release(struct video_device *vdev)
147 {
148 kfree(vdev);
149 }
150 EXPORT_SYMBOL(video_device_release);
151
152 void video_device_release_empty(struct video_device *vdev)
153 {
154 /* Do nothing */
155 /* Only valid when the video_device struct is a static. */
156 }
157 EXPORT_SYMBOL(video_device_release_empty);
158
159 static inline void video_get(struct video_device *vdev)
160 {
161 get_device(&vdev->dev);
162 }
163
164 static inline void video_put(struct video_device *vdev)
165 {
166 put_device(&vdev->dev);
167 }
168
169 /* Called when the last user of the video device exits. */
170 static 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 /* should not happen */
178 mutex_unlock(&videodev_lock);
179 return;
180 }
181
182 /* Free up this device for reuse */
183 video_device[vdev->minor] = NULL;
184
185 /* Delete the cdev on this minor as well */
186 cdev_del(vdev->cdev);
187 /* Just in case some driver tries to access this from
188 the release() callback. */
189 vdev->cdev = NULL;
190
191 /* Mark device node number as free */
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 /* Do not call v4l2_device_put if there is no release callback set.
203 * Drivers that have no v4l2_device release callback might free the
204 * v4l2_dev instance in the video_device release callback below, so we
205 * must perform this check here.
206 *
207 * TODO: In the long run all drivers that use v4l2_device should use the
208 * v4l2_device release callback. This check will then be unnecessary.
209 */
210 if (v4l2_dev->release == NULL)
211 v4l2_dev = NULL;
212
213 /* Release video_device and perform other
214 cleanups as needed. */
215 vdev->release(vdev);
216
217 /* Decrease v4l2_device refcount */
218 if (v4l2_dev)
219 v4l2_device_put(v4l2_dev);
220 }
221
222 static struct class video_class = {
223 .name = VIDEO_NAME,
224 .dev_groups = video_device_groups,
225 };
226
227 struct video_device *video_devdata(struct file *file)
228 {
229 return video_device[iminor(file_inode(file))];
230 }
231 EXPORT_SYMBOL(video_devdata);
232
233
234 /* Priority handling */
235
236 static 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
243 void v4l2_prio_init(struct v4l2_prio_state *global)
244 {
245 memset(global, 0, sizeof(*global));
246 }
247 EXPORT_SYMBOL(v4l2_prio_init);
248
249 int 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 }
263 EXPORT_SYMBOL(v4l2_prio_change);
264
265 void v4l2_prio_open(struct v4l2_prio_state *global, enum v4l2_priority *local)
266 {
267 v4l2_prio_change(global, local, V4L2_PRIORITY_DEFAULT);
268 }
269 EXPORT_SYMBOL(v4l2_prio_open);
270
271 void 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 }
276 EXPORT_SYMBOL(v4l2_prio_close);
277
278 enum 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 }
288 EXPORT_SYMBOL(v4l2_prio_max);
289
290 int v4l2_prio_check(struct v4l2_prio_state *global, enum v4l2_priority local)
291 {
292 return (local < v4l2_prio_max(global)) ? -EBUSY : 0;
293 }
294 EXPORT_SYMBOL(v4l2_prio_check);
295
296
297 static 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
314 static 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
331 static 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
346 static 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
369 static 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
388 static 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 /* Override for the open function */
404 static int v4l2_open(struct inode *inode, struct file *filp)
405 {
406 struct video_device *vdev;
407 int ret = 0;
408
409 /* Check if the video device is available */
410 mutex_lock(&videodev_lock);
411 vdev = video_devdata(filp);
412 /* return ENODEV if the video device has already been removed. */
413 if (vdev == NULL || !video_is_registered(vdev)) {
414 mutex_unlock(&videodev_lock);
415 return -ENODEV;
416 }
417 /* and increase the device refcount */
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 /* decrease the refcount in case of an error */
431 if (ret)
432 video_put(vdev);
433 return ret;
434 }
435
436 /* Override for the release function */
437 static 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 /* decrease the refcount unconditionally since the release()
449 return value is ignored. */
450 video_put(vdev);
451 return ret;
452 }
453
454 static 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 * get_index - assign stream index number based on v4l2_dev
472 * @vdev: video_device to assign index number to, vdev->v4l2_dev should be assigned
473 *
474 * Note that when this is called the new device has not yet been registered
475 * in the video_device array, but it was able to obtain a minor number.
476 *
477 * This means that we can always obtain a free stream index number since
478 * the worst case scenario is that there are VIDEO_NUM_DEVICES - 1 slots in
479 * use of the video_device array.
480 *
481 * Returns a free index number.
482 */
483 static int get_index(struct video_device *vdev)
484 {
485 /* This can be static since this function is called with the global
486 videodev_lock held. */
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 /* This determines which ioctls are actually implemented in the driver.
507 It's a one-time thing which simplifies video_ioctl2 as it can just do
508 a bit test.
509
510 Note that drivers can override this by setting bits to 1 in
511 vdev->valid_ioctls. If an ioctl is marked as 1 when this function is
512 called, then that ioctl will actually be marked as unimplemented.
513
514 It does that by first setting up the local valid_ioctls bitmap, and
515 at the end do a:
516
517 vdev->valid_ioctls = valid_ioctls & ~(vdev->valid_ioctls)
518 */
519 static 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 /* vfl_type and vfl_dir independent ioctls */
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 /* Note: the control handler can also be passed through the filehandle,
539 and that can't be tested here. If the bit for these control ioctls
540 is set, then the ioctl is valid. But if it is 0, then it can still
541 be valid if the filehandle passed the control handler. */
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 /* yes, really vidioc_subscribe_event */
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 /* video specific ioctls */
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 /* vbi specific ioctls */
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 && is_rx) {
641 /* SDR receiver specific ioctls */
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 } else if (is_sdr && is_tx) {
651 /* SDR transmitter specific ioctls */
652 if (ops->vidioc_enum_fmt_sdr_out)
653 set_bit(_IOC_NR(VIDIOC_ENUM_FMT), valid_ioctls);
654 if (ops->vidioc_g_fmt_sdr_out)
655 set_bit(_IOC_NR(VIDIOC_G_FMT), valid_ioctls);
656 if (ops->vidioc_s_fmt_sdr_out)
657 set_bit(_IOC_NR(VIDIOC_S_FMT), valid_ioctls);
658 if (ops->vidioc_try_fmt_sdr_out)
659 set_bit(_IOC_NR(VIDIOC_TRY_FMT), valid_ioctls);
660 }
661
662 if (is_vid || is_vbi || is_sdr) {
663 /* ioctls valid for video, vbi or sdr */
664 SET_VALID_IOCTL(ops, VIDIOC_REQBUFS, vidioc_reqbufs);
665 SET_VALID_IOCTL(ops, VIDIOC_QUERYBUF, vidioc_querybuf);
666 SET_VALID_IOCTL(ops, VIDIOC_QBUF, vidioc_qbuf);
667 SET_VALID_IOCTL(ops, VIDIOC_EXPBUF, vidioc_expbuf);
668 SET_VALID_IOCTL(ops, VIDIOC_DQBUF, vidioc_dqbuf);
669 SET_VALID_IOCTL(ops, VIDIOC_CREATE_BUFS, vidioc_create_bufs);
670 SET_VALID_IOCTL(ops, VIDIOC_PREPARE_BUF, vidioc_prepare_buf);
671 SET_VALID_IOCTL(ops, VIDIOC_STREAMON, vidioc_streamon);
672 SET_VALID_IOCTL(ops, VIDIOC_STREAMOFF, vidioc_streamoff);
673 }
674
675 if (is_vid || is_vbi) {
676 /* ioctls valid for video or vbi */
677 if (ops->vidioc_s_std)
678 set_bit(_IOC_NR(VIDIOC_ENUMSTD), valid_ioctls);
679 SET_VALID_IOCTL(ops, VIDIOC_S_STD, vidioc_s_std);
680 SET_VALID_IOCTL(ops, VIDIOC_G_STD, vidioc_g_std);
681 if (is_rx) {
682 SET_VALID_IOCTL(ops, VIDIOC_QUERYSTD, vidioc_querystd);
683 SET_VALID_IOCTL(ops, VIDIOC_ENUMINPUT, vidioc_enum_input);
684 SET_VALID_IOCTL(ops, VIDIOC_G_INPUT, vidioc_g_input);
685 SET_VALID_IOCTL(ops, VIDIOC_S_INPUT, vidioc_s_input);
686 SET_VALID_IOCTL(ops, VIDIOC_ENUMAUDIO, vidioc_enumaudio);
687 SET_VALID_IOCTL(ops, VIDIOC_G_AUDIO, vidioc_g_audio);
688 SET_VALID_IOCTL(ops, VIDIOC_S_AUDIO, vidioc_s_audio);
689 SET_VALID_IOCTL(ops, VIDIOC_QUERY_DV_TIMINGS, vidioc_query_dv_timings);
690 SET_VALID_IOCTL(ops, VIDIOC_S_EDID, vidioc_s_edid);
691 }
692 if (is_tx) {
693 SET_VALID_IOCTL(ops, VIDIOC_ENUMOUTPUT, vidioc_enum_output);
694 SET_VALID_IOCTL(ops, VIDIOC_G_OUTPUT, vidioc_g_output);
695 SET_VALID_IOCTL(ops, VIDIOC_S_OUTPUT, vidioc_s_output);
696 SET_VALID_IOCTL(ops, VIDIOC_ENUMAUDOUT, vidioc_enumaudout);
697 SET_VALID_IOCTL(ops, VIDIOC_G_AUDOUT, vidioc_g_audout);
698 SET_VALID_IOCTL(ops, VIDIOC_S_AUDOUT, vidioc_s_audout);
699 }
700 if (ops->vidioc_g_parm || (vdev->vfl_type == VFL_TYPE_GRABBER &&
701 ops->vidioc_g_std))
702 set_bit(_IOC_NR(VIDIOC_G_PARM), valid_ioctls);
703 SET_VALID_IOCTL(ops, VIDIOC_S_PARM, vidioc_s_parm);
704 SET_VALID_IOCTL(ops, VIDIOC_S_DV_TIMINGS, vidioc_s_dv_timings);
705 SET_VALID_IOCTL(ops, VIDIOC_G_DV_TIMINGS, vidioc_g_dv_timings);
706 SET_VALID_IOCTL(ops, VIDIOC_ENUM_DV_TIMINGS, vidioc_enum_dv_timings);
707 SET_VALID_IOCTL(ops, VIDIOC_DV_TIMINGS_CAP, vidioc_dv_timings_cap);
708 SET_VALID_IOCTL(ops, VIDIOC_G_EDID, vidioc_g_edid);
709 }
710 if (is_tx && (is_radio || is_sdr)) {
711 /* radio transmitter only ioctls */
712 SET_VALID_IOCTL(ops, VIDIOC_G_MODULATOR, vidioc_g_modulator);
713 SET_VALID_IOCTL(ops, VIDIOC_S_MODULATOR, vidioc_s_modulator);
714 }
715 if (is_rx) {
716 /* receiver only ioctls */
717 SET_VALID_IOCTL(ops, VIDIOC_G_TUNER, vidioc_g_tuner);
718 SET_VALID_IOCTL(ops, VIDIOC_S_TUNER, vidioc_s_tuner);
719 SET_VALID_IOCTL(ops, VIDIOC_S_HW_FREQ_SEEK, vidioc_s_hw_freq_seek);
720 }
721
722 bitmap_andnot(vdev->valid_ioctls, valid_ioctls, vdev->valid_ioctls,
723 BASE_VIDIOC_PRIVATE);
724 }
725
726 /**
727 * __video_register_device - register video4linux devices
728 * @vdev: video device structure we want to register
729 * @type: type of device to register
730 * @nr: which device node number (0 == /dev/video0, 1 == /dev/video1, ...
731 * -1 == first free)
732 * @warn_if_nr_in_use: warn if the desired device node number
733 * was already in use and another number was chosen instead.
734 * @owner: module that owns the video device node
735 *
736 * The registration code assigns minor numbers and device node numbers
737 * based on the requested type and registers the new device node with
738 * the kernel.
739 *
740 * This function assumes that struct video_device was zeroed when it
741 * was allocated and does not contain any stale date.
742 *
743 * An error is returned if no free minor or device node number could be
744 * found, or if the registration of the device node failed.
745 *
746 * Zero is returned on success.
747 *
748 * Valid types are
749 *
750 * %VFL_TYPE_GRABBER - A frame grabber
751 *
752 * %VFL_TYPE_VBI - Vertical blank data (undecoded)
753 *
754 * %VFL_TYPE_RADIO - A radio card
755 *
756 * %VFL_TYPE_SUBDEV - A subdevice
757 *
758 * %VFL_TYPE_SDR - Software Defined Radio
759 */
760 int __video_register_device(struct video_device *vdev, int type, int nr,
761 int warn_if_nr_in_use, struct module *owner)
762 {
763 int i = 0;
764 int ret;
765 int minor_offset = 0;
766 int minor_cnt = VIDEO_NUM_DEVICES;
767 const char *name_base;
768
769 /* A minor value of -1 marks this video device as never
770 having been registered */
771 vdev->minor = -1;
772
773 /* the release callback MUST be present */
774 if (WARN_ON(!vdev->release))
775 return -EINVAL;
776 /* the v4l2_dev pointer MUST be present */
777 if (WARN_ON(!vdev->v4l2_dev))
778 return -EINVAL;
779
780 /* v4l2_fh support */
781 spin_lock_init(&vdev->fh_lock);
782 INIT_LIST_HEAD(&vdev->fh_list);
783
784 /* Part 1: check device type */
785 switch (type) {
786 case VFL_TYPE_GRABBER:
787 name_base = "video";
788 break;
789 case VFL_TYPE_VBI:
790 name_base = "vbi";
791 break;
792 case VFL_TYPE_RADIO:
793 name_base = "radio";
794 break;
795 case VFL_TYPE_SUBDEV:
796 name_base = "v4l-subdev";
797 break;
798 case VFL_TYPE_SDR:
799 /* Use device name 'swradio' because 'sdr' was already taken. */
800 name_base = "swradio";
801 break;
802 default:
803 printk(KERN_ERR "%s called with unknown type: %d\n",
804 __func__, type);
805 return -EINVAL;
806 }
807
808 vdev->vfl_type = type;
809 vdev->cdev = NULL;
810 if (vdev->dev_parent == NULL)
811 vdev->dev_parent = vdev->v4l2_dev->dev;
812 if (vdev->ctrl_handler == NULL)
813 vdev->ctrl_handler = vdev->v4l2_dev->ctrl_handler;
814 /* If the prio state pointer is NULL, then use the v4l2_device
815 prio state. */
816 if (vdev->prio == NULL)
817 vdev->prio = &vdev->v4l2_dev->prio;
818
819 /* Part 2: find a free minor, device node number and device index. */
820 #ifdef CONFIG_VIDEO_FIXED_MINOR_RANGES
821 /* Keep the ranges for the first four types for historical
822 * reasons.
823 * Newer devices (not yet in place) should use the range
824 * of 128-191 and just pick the first free minor there
825 * (new style). */
826 switch (type) {
827 case VFL_TYPE_GRABBER:
828 minor_offset = 0;
829 minor_cnt = 64;
830 break;
831 case VFL_TYPE_RADIO:
832 minor_offset = 64;
833 minor_cnt = 64;
834 break;
835 case VFL_TYPE_VBI:
836 minor_offset = 224;
837 minor_cnt = 32;
838 break;
839 default:
840 minor_offset = 128;
841 minor_cnt = 64;
842 break;
843 }
844 #endif
845
846 /* Pick a device node number */
847 mutex_lock(&videodev_lock);
848 nr = devnode_find(vdev, nr == -1 ? 0 : nr, minor_cnt);
849 if (nr == minor_cnt)
850 nr = devnode_find(vdev, 0, minor_cnt);
851 if (nr == minor_cnt) {
852 printk(KERN_ERR "could not get a free device node number\n");
853 mutex_unlock(&videodev_lock);
854 return -ENFILE;
855 }
856 #ifdef CONFIG_VIDEO_FIXED_MINOR_RANGES
857 /* 1-on-1 mapping of device node number to minor number */
858 i = nr;
859 #else
860 /* The device node number and minor numbers are independent, so
861 we just find the first free minor number. */
862 for (i = 0; i < VIDEO_NUM_DEVICES; i++)
863 if (video_device[i] == NULL)
864 break;
865 if (i == VIDEO_NUM_DEVICES) {
866 mutex_unlock(&videodev_lock);
867 printk(KERN_ERR "could not get a free minor\n");
868 return -ENFILE;
869 }
870 #endif
871 vdev->minor = i + minor_offset;
872 vdev->num = nr;
873 devnode_set(vdev);
874
875 /* Should not happen since we thought this minor was free */
876 WARN_ON(video_device[vdev->minor] != NULL);
877 vdev->index = get_index(vdev);
878 video_device[vdev->minor] = vdev;
879 mutex_unlock(&videodev_lock);
880
881 if (vdev->ioctl_ops)
882 determine_valid_ioctls(vdev);
883
884 /* Part 3: Initialize the character device */
885 vdev->cdev = cdev_alloc();
886 if (vdev->cdev == NULL) {
887 ret = -ENOMEM;
888 goto cleanup;
889 }
890 vdev->cdev->ops = &v4l2_fops;
891 vdev->cdev->owner = owner;
892 ret = cdev_add(vdev->cdev, MKDEV(VIDEO_MAJOR, vdev->minor), 1);
893 if (ret < 0) {
894 printk(KERN_ERR "%s: cdev_add failed\n", __func__);
895 kfree(vdev->cdev);
896 vdev->cdev = NULL;
897 goto cleanup;
898 }
899
900 /* Part 4: register the device with sysfs */
901 vdev->dev.class = &video_class;
902 vdev->dev.devt = MKDEV(VIDEO_MAJOR, vdev->minor);
903 vdev->dev.parent = vdev->dev_parent;
904 dev_set_name(&vdev->dev, "%s%d", name_base, vdev->num);
905 ret = device_register(&vdev->dev);
906 if (ret < 0) {
907 printk(KERN_ERR "%s: device_register failed\n", __func__);
908 goto cleanup;
909 }
910 /* Register the release callback that will be called when the last
911 reference to the device goes away. */
912 vdev->dev.release = v4l2_device_release;
913
914 if (nr != -1 && nr != vdev->num && warn_if_nr_in_use)
915 printk(KERN_WARNING "%s: requested %s%d, got %s\n", __func__,
916 name_base, nr, video_device_node_name(vdev));
917
918 /* Increase v4l2_device refcount */
919 v4l2_device_get(vdev->v4l2_dev);
920
921 #if defined(CONFIG_MEDIA_CONTROLLER)
922 /* Part 5: Register the entity. */
923 if (vdev->v4l2_dev->mdev &&
924 vdev->vfl_type != VFL_TYPE_SUBDEV) {
925 vdev->entity.type = MEDIA_ENT_T_DEVNODE_V4L;
926 vdev->entity.name = vdev->name;
927 vdev->entity.info.dev.major = VIDEO_MAJOR;
928 vdev->entity.info.dev.minor = vdev->minor;
929 ret = media_device_register_entity(vdev->v4l2_dev->mdev,
930 &vdev->entity);
931 if (ret < 0)
932 printk(KERN_WARNING
933 "%s: media_device_register_entity failed\n",
934 __func__);
935 }
936 #endif
937 /* Part 6: Activate this minor. The char device can now be used. */
938 set_bit(V4L2_FL_REGISTERED, &vdev->flags);
939
940 return 0;
941
942 cleanup:
943 mutex_lock(&videodev_lock);
944 if (vdev->cdev)
945 cdev_del(vdev->cdev);
946 video_device[vdev->minor] = NULL;
947 devnode_clear(vdev);
948 mutex_unlock(&videodev_lock);
949 /* Mark this video device as never having been registered. */
950 vdev->minor = -1;
951 return ret;
952 }
953 EXPORT_SYMBOL(__video_register_device);
954
955 /**
956 * video_unregister_device - unregister a video4linux device
957 * @vdev: the device to unregister
958 *
959 * This unregisters the passed device. Future open calls will
960 * be met with errors.
961 */
962 void video_unregister_device(struct video_device *vdev)
963 {
964 /* Check if vdev was ever registered at all */
965 if (!vdev || !video_is_registered(vdev))
966 return;
967
968 mutex_lock(&videodev_lock);
969 /* This must be in a critical section to prevent a race with v4l2_open.
970 * Once this bit has been cleared video_get may never be called again.
971 */
972 clear_bit(V4L2_FL_REGISTERED, &vdev->flags);
973 mutex_unlock(&videodev_lock);
974 device_unregister(&vdev->dev);
975 }
976 EXPORT_SYMBOL(video_unregister_device);
977
978 /*
979 * Initialise video for linux
980 */
981 static int __init videodev_init(void)
982 {
983 dev_t dev = MKDEV(VIDEO_MAJOR, 0);
984 int ret;
985
986 printk(KERN_INFO "Linux video capture interface: v2.00\n");
987 ret = register_chrdev_region(dev, VIDEO_NUM_DEVICES, VIDEO_NAME);
988 if (ret < 0) {
989 printk(KERN_WARNING "videodev: unable to get major %d\n",
990 VIDEO_MAJOR);
991 return ret;
992 }
993
994 ret = class_register(&video_class);
995 if (ret < 0) {
996 unregister_chrdev_region(dev, VIDEO_NUM_DEVICES);
997 printk(KERN_WARNING "video_dev: class_register failed\n");
998 return -EIO;
999 }
1000
1001 return 0;
1002 }
1003
1004 static void __exit videodev_exit(void)
1005 {
1006 dev_t dev = MKDEV(VIDEO_MAJOR, 0);
1007
1008 class_unregister(&video_class);
1009 unregister_chrdev_region(dev, VIDEO_NUM_DEVICES);
1010 }
1011
1012 subsys_initcall(videodev_init);
1013 module_exit(videodev_exit)
1014
1015 MODULE_AUTHOR("Alan Cox, Mauro Carvalho Chehab <mchehab@infradead.org>");
1016 MODULE_DESCRIPTION("Device registrar for Video4Linux drivers v2");
1017 MODULE_LICENSE("GPL");
1018 MODULE_ALIAS_CHARDEV_MAJOR(VIDEO_MAJOR);
Linux kernel - Deliverables
This page took 0.159361 seconds and 5 git commands to generate.