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