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