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