blob: 21ffd030611eb9c500ab0bdf658c5cac0d0f33d8 [file] [log] [blame]
Hans Verkuil27a5e6d2008-07-20 08:43:17 -03001/*
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 *
Alan Coxd9b01442008-10-27 15:13:47 -030012 * Authors: Alan Cox, <alan@lxorguk.ukuu.org.uk> (version 1)
Hans Verkuil27a5e6d2008-07-20 08:43:17 -030013 * 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>
Hans Verkuil27a5e6d2008-07-20 08:43:17 -030028#include <asm/uaccess.h>
29#include <asm/system.h>
30
31#include <media/v4l2-common.h>
Hans Verkuil9bea3512008-12-23 07:35:17 -030032#include <media/v4l2-device.h>
Hans Verkuilbec43662008-12-30 06:58:20 -030033#include <media/v4l2-ioctl.h>
Hans Verkuil27a5e6d2008-07-20 08:43:17 -030034
35#define VIDEO_NUM_DEVICES 256
36#define VIDEO_NAME "video4linux"
37
38/*
39 * sysfs stuff
40 */
41
42static ssize_t show_index(struct device *cd,
43 struct device_attribute *attr, char *buf)
44{
Hans Verkuildc93a702008-12-19 21:28:27 -030045 struct video_device *vdev = to_video_device(cd);
Hans Verkuilbfa8a272008-08-23 07:48:38 -030046
Hans Verkuildc93a702008-12-19 21:28:27 -030047 return sprintf(buf, "%i\n", vdev->index);
Hans Verkuil27a5e6d2008-07-20 08:43:17 -030048}
49
50static ssize_t show_name(struct device *cd,
51 struct device_attribute *attr, char *buf)
52{
Hans Verkuildc93a702008-12-19 21:28:27 -030053 struct video_device *vdev = to_video_device(cd);
Hans Verkuilbfa8a272008-08-23 07:48:38 -030054
Hans Verkuildc93a702008-12-19 21:28:27 -030055 return sprintf(buf, "%.*s\n", (int)sizeof(vdev->name), vdev->name);
Hans Verkuil27a5e6d2008-07-20 08:43:17 -030056}
57
58static struct device_attribute video_device_attrs[] = {
59 __ATTR(name, S_IRUGO, show_name, NULL),
60 __ATTR(index, S_IRUGO, show_index, NULL),
61 __ATTR_NULL
62};
63
Hans Verkuil7f8ecfa2008-08-29 17:31:35 -030064/*
65 * Active devices
66 */
67static struct video_device *video_device[VIDEO_NUM_DEVICES];
68static DEFINE_MUTEX(videodev_lock);
Hans Verkuil22e22122009-09-06 07:13:14 -030069static DECLARE_BITMAP(devnode_nums[VFL_TYPE_MAX], VIDEO_NUM_DEVICES);
Hans Verkuil7f8ecfa2008-08-29 17:31:35 -030070
Hans Verkuil5062cb72009-09-07 03:40:24 -030071/* Device node utility functions */
72
73/* Note: these utility functions all assume that vfl_type is in the range
74 [0, VFL_TYPE_MAX-1]. */
75
76#ifdef CONFIG_VIDEO_FIXED_MINOR_RANGES
77/* Return the bitmap corresponding to vfl_type. */
78static inline unsigned long *devnode_bits(int vfl_type)
79{
80 /* Any types not assigned to fixed minor ranges must be mapped to
81 one single bitmap for the purposes of finding a free node number
82 since all those unassigned types use the same minor range. */
83 int idx = (vfl_type > VFL_TYPE_VTX) ? VFL_TYPE_MAX - 1 : vfl_type;
84
85 return devnode_nums[idx];
86}
87#else
88/* Return the bitmap corresponding to vfl_type. */
89static inline unsigned long *devnode_bits(int vfl_type)
90{
91 return devnode_nums[vfl_type];
92}
93#endif
94
95/* Mark device node number vdev->num as used */
96static inline void devnode_set(struct video_device *vdev)
97{
98 set_bit(vdev->num, devnode_bits(vdev->vfl_type));
99}
100
101/* Mark device node number vdev->num as unused */
102static inline void devnode_clear(struct video_device *vdev)
103{
104 clear_bit(vdev->num, devnode_bits(vdev->vfl_type));
105}
106
107/* Try to find a free device node number in the range [from, to> */
108static inline int devnode_find(struct video_device *vdev, int from, int to)
109{
110 return find_next_zero_bit(devnode_bits(vdev->vfl_type), to, from);
111}
112
Hans Verkuil27a5e6d2008-07-20 08:43:17 -0300113struct video_device *video_device_alloc(void)
114{
Hans Verkuilbfa8a272008-08-23 07:48:38 -0300115 return kzalloc(sizeof(struct video_device), GFP_KERNEL);
Hans Verkuil27a5e6d2008-07-20 08:43:17 -0300116}
117EXPORT_SYMBOL(video_device_alloc);
118
Hans Verkuildc93a702008-12-19 21:28:27 -0300119void video_device_release(struct video_device *vdev)
Hans Verkuil27a5e6d2008-07-20 08:43:17 -0300120{
Hans Verkuildc93a702008-12-19 21:28:27 -0300121 kfree(vdev);
Hans Verkuil27a5e6d2008-07-20 08:43:17 -0300122}
123EXPORT_SYMBOL(video_device_release);
124
Hans Verkuildc93a702008-12-19 21:28:27 -0300125void video_device_release_empty(struct video_device *vdev)
Hans Verkuilf9e86b52008-08-23 05:47:41 -0300126{
127 /* Do nothing */
128 /* Only valid when the video_device struct is a static. */
129}
130EXPORT_SYMBOL(video_device_release_empty);
131
Hans Verkuildc93a702008-12-19 21:28:27 -0300132static inline void video_get(struct video_device *vdev)
Hans Verkuil7f8ecfa2008-08-29 17:31:35 -0300133{
Hans Verkuildc93a702008-12-19 21:28:27 -0300134 get_device(&vdev->dev);
135}
136
137static inline void video_put(struct video_device *vdev)
138{
139 put_device(&vdev->dev);
140}
141
142/* Called when the last user of the video device exits. */
143static void v4l2_device_release(struct device *cd)
144{
145 struct video_device *vdev = to_video_device(cd);
Hans Verkuil7f8ecfa2008-08-29 17:31:35 -0300146
147 mutex_lock(&videodev_lock);
Hans Verkuildc93a702008-12-19 21:28:27 -0300148 if (video_device[vdev->minor] != vdev) {
Hans Verkuil6ea9a182008-08-30 09:40:47 -0300149 mutex_unlock(&videodev_lock);
Hans Verkuildc93a702008-12-19 21:28:27 -0300150 /* should not happen */
151 WARN_ON(1);
Hans Verkuil6ea9a182008-08-30 09:40:47 -0300152 return;
153 }
Hans Verkuil7f8ecfa2008-08-29 17:31:35 -0300154
155 /* Free up this device for reuse */
Hans Verkuildc93a702008-12-19 21:28:27 -0300156 video_device[vdev->minor] = NULL;
157
158 /* Delete the cdev on this minor as well */
159 cdev_del(vdev->cdev);
160 /* Just in case some driver tries to access this from
161 the release() callback. */
162 vdev->cdev = NULL;
163
Hans Verkuil22e22122009-09-06 07:13:14 -0300164 /* Mark device node number as free */
Hans Verkuil5062cb72009-09-07 03:40:24 -0300165 devnode_clear(vdev);
Hans Verkuildc93a702008-12-19 21:28:27 -0300166
Hans Verkuil7f8ecfa2008-08-29 17:31:35 -0300167 mutex_unlock(&videodev_lock);
168
Hans Verkuil7f8ecfa2008-08-29 17:31:35 -0300169 /* Release video_device and perform other
170 cleanups as needed. */
Hans Verkuildc93a702008-12-19 21:28:27 -0300171 vdev->release(vdev);
Hans Verkuil27a5e6d2008-07-20 08:43:17 -0300172}
173
174static struct class video_class = {
175 .name = VIDEO_NAME,
176 .dev_attrs = video_device_attrs,
Hans Verkuil27a5e6d2008-07-20 08:43:17 -0300177};
178
Hans Verkuil27a5e6d2008-07-20 08:43:17 -0300179struct video_device *video_devdata(struct file *file)
180{
181 return video_device[iminor(file->f_path.dentry->d_inode)];
182}
183EXPORT_SYMBOL(video_devdata);
184
Hans Verkuildc93a702008-12-19 21:28:27 -0300185static ssize_t v4l2_read(struct file *filp, char __user *buf,
186 size_t sz, loff_t *off)
187{
188 struct video_device *vdev = video_devdata(filp);
189
190 if (!vdev->fops->read)
191 return -EINVAL;
Laurent Pinchart957b4aa2009-11-27 13:57:22 -0300192 if (!video_is_registered(vdev))
Hans Verkuildc93a702008-12-19 21:28:27 -0300193 return -EIO;
194 return vdev->fops->read(filp, buf, sz, off);
195}
196
197static ssize_t v4l2_write(struct file *filp, const char __user *buf,
198 size_t sz, loff_t *off)
199{
200 struct video_device *vdev = video_devdata(filp);
201
202 if (!vdev->fops->write)
203 return -EINVAL;
Laurent Pinchart957b4aa2009-11-27 13:57:22 -0300204 if (!video_is_registered(vdev))
Hans Verkuildc93a702008-12-19 21:28:27 -0300205 return -EIO;
206 return vdev->fops->write(filp, buf, sz, off);
207}
208
209static unsigned int v4l2_poll(struct file *filp, struct poll_table_struct *poll)
210{
211 struct video_device *vdev = video_devdata(filp);
212
Laurent Pinchart957b4aa2009-11-27 13:57:22 -0300213 if (!vdev->fops->poll || !video_is_registered(vdev))
Hans Verkuildc93a702008-12-19 21:28:27 -0300214 return DEFAULT_POLLMASK;
215 return vdev->fops->poll(filp, poll);
216}
217
218static int v4l2_ioctl(struct inode *inode, struct file *filp,
219 unsigned int cmd, unsigned long arg)
220{
221 struct video_device *vdev = video_devdata(filp);
222
223 if (!vdev->fops->ioctl)
224 return -ENOTTY;
225 /* Allow ioctl to continue even if the device was unregistered.
226 Things like dequeueing buffers might still be useful. */
Hans Verkuilbec43662008-12-30 06:58:20 -0300227 return vdev->fops->ioctl(filp, cmd, arg);
Hans Verkuildc93a702008-12-19 21:28:27 -0300228}
229
230static long v4l2_unlocked_ioctl(struct file *filp,
231 unsigned int cmd, unsigned long arg)
232{
233 struct video_device *vdev = video_devdata(filp);
234
235 if (!vdev->fops->unlocked_ioctl)
236 return -ENOTTY;
237 /* Allow ioctl to continue even if the device was unregistered.
238 Things like dequeueing buffers might still be useful. */
239 return vdev->fops->unlocked_ioctl(filp, cmd, arg);
240}
241
Daniel Glöcknerc01f1a52009-03-26 11:31:08 -0300242#ifdef CONFIG_MMU
243#define v4l2_get_unmapped_area NULL
244#else
245static unsigned long v4l2_get_unmapped_area(struct file *filp,
246 unsigned long addr, unsigned long len, unsigned long pgoff,
247 unsigned long flags)
248{
249 struct video_device *vdev = video_devdata(filp);
250
251 if (!vdev->fops->get_unmapped_area)
252 return -ENOSYS;
Laurent Pinchart957b4aa2009-11-27 13:57:22 -0300253 if (!video_is_registered(vdev))
Daniel Glöcknerc01f1a52009-03-26 11:31:08 -0300254 return -ENODEV;
255 return vdev->fops->get_unmapped_area(filp, addr, len, pgoff, flags);
256}
257#endif
258
Hans Verkuildc93a702008-12-19 21:28:27 -0300259static int v4l2_mmap(struct file *filp, struct vm_area_struct *vm)
260{
261 struct video_device *vdev = video_devdata(filp);
262
Laurent Pinchart957b4aa2009-11-27 13:57:22 -0300263 if (!vdev->fops->mmap || !video_is_registered(vdev))
Hans Verkuildc93a702008-12-19 21:28:27 -0300264 return -ENODEV;
265 return vdev->fops->mmap(filp, vm);
266}
267
268/* Override for the open function */
269static int v4l2_open(struct inode *inode, struct file *filp)
270{
271 struct video_device *vdev;
Hans Verkuil65d9ff92009-03-29 20:19:38 -0300272 int ret = 0;
Hans Verkuildc93a702008-12-19 21:28:27 -0300273
274 /* Check if the video device is available */
275 mutex_lock(&videodev_lock);
276 vdev = video_devdata(filp);
277 /* return ENODEV if the video device has been removed
278 already or if it is not registered anymore. */
Laurent Pinchart957b4aa2009-11-27 13:57:22 -0300279 if (vdev == NULL || !video_is_registered(vdev)) {
Hans Verkuildc93a702008-12-19 21:28:27 -0300280 mutex_unlock(&videodev_lock);
281 return -ENODEV;
282 }
283 /* and increase the device refcount */
284 video_get(vdev);
285 mutex_unlock(&videodev_lock);
Hans Verkuil65d9ff92009-03-29 20:19:38 -0300286 if (vdev->fops->open)
287 ret = vdev->fops->open(filp);
288
Hans Verkuildc93a702008-12-19 21:28:27 -0300289 /* decrease the refcount in case of an error */
290 if (ret)
291 video_put(vdev);
292 return ret;
293}
294
295/* Override for the release function */
296static int v4l2_release(struct inode *inode, struct file *filp)
297{
298 struct video_device *vdev = video_devdata(filp);
Hans Verkuil65d9ff92009-03-29 20:19:38 -0300299 int ret = 0;
300
301 if (vdev->fops->release)
302 vdev->fops->release(filp);
Hans Verkuildc93a702008-12-19 21:28:27 -0300303
304 /* decrease the refcount unconditionally since the release()
305 return value is ignored. */
306 video_put(vdev);
307 return ret;
308}
309
310static const struct file_operations v4l2_unlocked_fops = {
311 .owner = THIS_MODULE,
312 .read = v4l2_read,
313 .write = v4l2_write,
314 .open = v4l2_open,
Daniel Glöcknerc01f1a52009-03-26 11:31:08 -0300315 .get_unmapped_area = v4l2_get_unmapped_area,
Hans Verkuildc93a702008-12-19 21:28:27 -0300316 .mmap = v4l2_mmap,
317 .unlocked_ioctl = v4l2_unlocked_ioctl,
318#ifdef CONFIG_COMPAT
Hans Verkuil9bb7cde2008-12-30 06:42:40 -0300319 .compat_ioctl = v4l2_compat_ioctl32,
Hans Verkuildc93a702008-12-19 21:28:27 -0300320#endif
321 .release = v4l2_release,
322 .poll = v4l2_poll,
323 .llseek = no_llseek,
324};
325
326static const struct file_operations v4l2_fops = {
327 .owner = THIS_MODULE,
328 .read = v4l2_read,
329 .write = v4l2_write,
330 .open = v4l2_open,
Daniel Glöcknerc01f1a52009-03-26 11:31:08 -0300331 .get_unmapped_area = v4l2_get_unmapped_area,
Hans Verkuildc93a702008-12-19 21:28:27 -0300332 .mmap = v4l2_mmap,
333 .ioctl = v4l2_ioctl,
334#ifdef CONFIG_COMPAT
Hans Verkuil9bb7cde2008-12-30 06:42:40 -0300335 .compat_ioctl = v4l2_compat_ioctl32,
Hans Verkuildc93a702008-12-19 21:28:27 -0300336#endif
337 .release = v4l2_release,
338 .poll = v4l2_poll,
339 .llseek = no_llseek,
340};
341
Hans Verkuil27a5e6d2008-07-20 08:43:17 -0300342/**
Hans Verkuil7ae0cd92009-06-19 11:32:56 -0300343 * get_index - assign stream index number based on parent device
Hans Verkuildc93a702008-12-19 21:28:27 -0300344 * @vdev: video_device to assign index number to, vdev->parent should be assigned
Hans Verkuil27a5e6d2008-07-20 08:43:17 -0300345 *
Hans Verkuildc93a702008-12-19 21:28:27 -0300346 * Note that when this is called the new device has not yet been registered
Hans Verkuil7ae0cd92009-06-19 11:32:56 -0300347 * in the video_device array, but it was able to obtain a minor number.
Hans Verkuil27a5e6d2008-07-20 08:43:17 -0300348 *
Hans Verkuil7ae0cd92009-06-19 11:32:56 -0300349 * This means that we can always obtain a free stream index number since
350 * the worst case scenario is that there are VIDEO_NUM_DEVICES - 1 slots in
351 * use of the video_device array.
352 *
353 * Returns a free index number.
Hans Verkuil27a5e6d2008-07-20 08:43:17 -0300354 */
Hans Verkuil7ae0cd92009-06-19 11:32:56 -0300355static int get_index(struct video_device *vdev)
Hans Verkuil27a5e6d2008-07-20 08:43:17 -0300356{
Hans Verkuil775a05d2009-02-14 11:31:01 -0300357 /* This can be static since this function is called with the global
358 videodev_lock held. */
359 static DECLARE_BITMAP(used, VIDEO_NUM_DEVICES);
Hans Verkuil27a5e6d2008-07-20 08:43:17 -0300360 int i;
361
Hans Verkuil7ae0cd92009-06-19 11:32:56 -0300362 /* Some drivers do not set the parent. In that case always return 0. */
Hans Verkuil806e5b72008-12-19 09:10:56 -0300363 if (vdev->parent == NULL)
Hans Verkuil7ae0cd92009-06-19 11:32:56 -0300364 return 0;
Hans Verkuil775a05d2009-02-14 11:31:01 -0300365
366 bitmap_zero(used, VIDEO_NUM_DEVICES);
Hans Verkuil806e5b72008-12-19 09:10:56 -0300367
Hans Verkuil27a5e6d2008-07-20 08:43:17 -0300368 for (i = 0; i < VIDEO_NUM_DEVICES; i++) {
369 if (video_device[i] != NULL &&
Hans Verkuil5e85e732008-07-20 06:31:39 -0300370 video_device[i]->parent == vdev->parent) {
Hans Verkuil775a05d2009-02-14 11:31:01 -0300371 set_bit(video_device[i]->index, used);
Hans Verkuil27a5e6d2008-07-20 08:43:17 -0300372 }
373 }
374
Hans Verkuil7ae0cd92009-06-19 11:32:56 -0300375 return find_first_zero_bit(used, VIDEO_NUM_DEVICES);
Hans Verkuil27a5e6d2008-07-20 08:43:17 -0300376}
377
Hans Verkuil27a5e6d2008-07-20 08:43:17 -0300378/**
Hans Verkuil7ae0cd92009-06-19 11:32:56 -0300379 * video_register_device - register video4linux devices
Hans Verkuildc93a702008-12-19 21:28:27 -0300380 * @vdev: video device structure we want to register
Hans Verkuil27a5e6d2008-07-20 08:43:17 -0300381 * @type: type of device to register
Hans Verkuil22e22122009-09-06 07:13:14 -0300382 * @nr: which device node number (0 == /dev/video0, 1 == /dev/video1, ...
Hans Verkuil27a5e6d2008-07-20 08:43:17 -0300383 * -1 == first free)
Hans Verkuil6b5270d2009-09-06 07:54:00 -0300384 * @warn_if_nr_in_use: warn if the desired device node number
385 * was already in use and another number was chosen instead.
Hans Verkuil27a5e6d2008-07-20 08:43:17 -0300386 *
Hans Verkuil22e22122009-09-06 07:13:14 -0300387 * The registration code assigns minor numbers and device node numbers
388 * based on the requested type and registers the new device node with
389 * the kernel.
390 * An error is returned if no free minor or device node number could be
391 * found, or if the registration of the device node failed.
Hans Verkuil27a5e6d2008-07-20 08:43:17 -0300392 *
393 * Zero is returned on success.
394 *
395 * Valid types are
396 *
397 * %VFL_TYPE_GRABBER - A frame grabber
398 *
399 * %VFL_TYPE_VTX - A teletext device
400 *
401 * %VFL_TYPE_VBI - Vertical blank data (undecoded)
402 *
403 * %VFL_TYPE_RADIO - A radio card
404 */
Hans Verkuil6b5270d2009-09-06 07:54:00 -0300405static int __video_register_device(struct video_device *vdev, int type, int nr,
406 int warn_if_nr_in_use)
Hans Verkuil27a5e6d2008-07-20 08:43:17 -0300407{
408 int i = 0;
Hans Verkuil27a5e6d2008-07-20 08:43:17 -0300409 int ret;
Hans Verkuildd896012008-10-04 08:36:54 -0300410 int minor_offset = 0;
411 int minor_cnt = VIDEO_NUM_DEVICES;
412 const char *name_base;
Anatolij Gustschin1bb64192010-07-01 14:21:39 -0300413 void *priv = vdev->dev.p;
Hans Verkuildc93a702008-12-19 21:28:27 -0300414
415 /* A minor value of -1 marks this video device as never
416 having been registered */
Trent Piepho428c8d12009-03-03 18:51:52 -0300417 vdev->minor = -1;
Hans Verkuil27a5e6d2008-07-20 08:43:17 -0300418
Hans Verkuild6e74972008-08-23 06:27:59 -0300419 /* the release callback MUST be present */
Trent Piepho428c8d12009-03-03 18:51:52 -0300420 WARN_ON(!vdev->release);
421 if (!vdev->release)
Henrik Kretzschmaree7aa9f2008-08-22 16:41:03 -0300422 return -EINVAL;
423
Sakari Ailus1babcb42010-03-23 09:25:26 -0300424 /* v4l2_fh support */
425 spin_lock_init(&vdev->fh_lock);
426 INIT_LIST_HEAD(&vdev->fh_list);
427
Hans Verkuildc93a702008-12-19 21:28:27 -0300428 /* Part 1: check device type */
Hans Verkuil27a5e6d2008-07-20 08:43:17 -0300429 switch (type) {
430 case VFL_TYPE_GRABBER:
Hans Verkuil27a5e6d2008-07-20 08:43:17 -0300431 name_base = "video";
432 break;
433 case VFL_TYPE_VTX:
Hans Verkuil27a5e6d2008-07-20 08:43:17 -0300434 name_base = "vtx";
435 break;
436 case VFL_TYPE_VBI:
Hans Verkuil27a5e6d2008-07-20 08:43:17 -0300437 name_base = "vbi";
438 break;
439 case VFL_TYPE_RADIO:
Hans Verkuil27a5e6d2008-07-20 08:43:17 -0300440 name_base = "radio";
441 break;
442 default:
443 printk(KERN_ERR "%s called with unknown type: %d\n",
444 __func__, type);
Henrik Kretzschmar46f2c212008-09-03 16:47:39 -0300445 return -EINVAL;
Hans Verkuil27a5e6d2008-07-20 08:43:17 -0300446 }
447
Hans Verkuildc93a702008-12-19 21:28:27 -0300448 vdev->vfl_type = type;
449 vdev->cdev = NULL;
Hans Verkuil11bbc1c2010-05-16 09:24:06 -0300450 if (vdev->v4l2_dev) {
451 if (vdev->v4l2_dev->dev)
452 vdev->parent = vdev->v4l2_dev->dev;
453 if (vdev->ctrl_handler == NULL)
454 vdev->ctrl_handler = vdev->v4l2_dev->ctrl_handler;
455 }
Hans Verkuildd896012008-10-04 08:36:54 -0300456
Hans Verkuil22e22122009-09-06 07:13:14 -0300457 /* Part 2: find a free minor, device node number and device index. */
Hans Verkuildd896012008-10-04 08:36:54 -0300458#ifdef CONFIG_VIDEO_FIXED_MINOR_RANGES
459 /* Keep the ranges for the first four types for historical
460 * reasons.
461 * Newer devices (not yet in place) should use the range
462 * of 128-191 and just pick the first free minor there
463 * (new style). */
464 switch (type) {
465 case VFL_TYPE_GRABBER:
466 minor_offset = 0;
467 minor_cnt = 64;
468 break;
469 case VFL_TYPE_RADIO:
470 minor_offset = 64;
471 minor_cnt = 64;
472 break;
473 case VFL_TYPE_VTX:
474 minor_offset = 192;
475 minor_cnt = 32;
476 break;
477 case VFL_TYPE_VBI:
478 minor_offset = 224;
479 minor_cnt = 32;
480 break;
481 default:
482 minor_offset = 128;
483 minor_cnt = 64;
484 break;
485 }
486#endif
487
Hans Verkuil22e22122009-09-06 07:13:14 -0300488 /* Pick a device node number */
Hans Verkuil27a5e6d2008-07-20 08:43:17 -0300489 mutex_lock(&videodev_lock);
Hans Verkuil5062cb72009-09-07 03:40:24 -0300490 nr = devnode_find(vdev, nr == -1 ? 0 : nr, minor_cnt);
Hans Verkuildd896012008-10-04 08:36:54 -0300491 if (nr == minor_cnt)
Hans Verkuil5062cb72009-09-07 03:40:24 -0300492 nr = devnode_find(vdev, 0, minor_cnt);
Hans Verkuildd896012008-10-04 08:36:54 -0300493 if (nr == minor_cnt) {
Hans Verkuil22e22122009-09-06 07:13:14 -0300494 printk(KERN_ERR "could not get a free device node number\n");
Hans Verkuildd896012008-10-04 08:36:54 -0300495 mutex_unlock(&videodev_lock);
496 return -ENFILE;
Hans Verkuil27a5e6d2008-07-20 08:43:17 -0300497 }
Hans Verkuildd896012008-10-04 08:36:54 -0300498#ifdef CONFIG_VIDEO_FIXED_MINOR_RANGES
Hans Verkuil22e22122009-09-06 07:13:14 -0300499 /* 1-on-1 mapping of device node number to minor number */
Hans Verkuildd896012008-10-04 08:36:54 -0300500 i = nr;
501#else
Hans Verkuil22e22122009-09-06 07:13:14 -0300502 /* The device node number and minor numbers are independent, so
503 we just find the first free minor number. */
Hans Verkuildd896012008-10-04 08:36:54 -0300504 for (i = 0; i < VIDEO_NUM_DEVICES; i++)
505 if (video_device[i] == NULL)
506 break;
507 if (i == VIDEO_NUM_DEVICES) {
508 mutex_unlock(&videodev_lock);
509 printk(KERN_ERR "could not get a free minor\n");
510 return -ENFILE;
511 }
512#endif
Hans Verkuildc93a702008-12-19 21:28:27 -0300513 vdev->minor = i + minor_offset;
514 vdev->num = nr;
Hans Verkuil5062cb72009-09-07 03:40:24 -0300515 devnode_set(vdev);
516
Hans Verkuildc93a702008-12-19 21:28:27 -0300517 /* Should not happen since we thought this minor was free */
518 WARN_ON(video_device[vdev->minor] != NULL);
Hans Verkuil7ae0cd92009-06-19 11:32:56 -0300519 vdev->index = get_index(vdev);
Hans Verkuil27a5e6d2008-07-20 08:43:17 -0300520 mutex_unlock(&videodev_lock);
521
Hans Verkuildc93a702008-12-19 21:28:27 -0300522 /* Part 3: Initialize the character device */
523 vdev->cdev = cdev_alloc();
524 if (vdev->cdev == NULL) {
525 ret = -ENOMEM;
526 goto cleanup;
527 }
528 if (vdev->fops->unlocked_ioctl)
529 vdev->cdev->ops = &v4l2_unlocked_fops;
530 else
531 vdev->cdev->ops = &v4l2_fops;
532 vdev->cdev->owner = vdev->fops->owner;
533 ret = cdev_add(vdev->cdev, MKDEV(VIDEO_MAJOR, vdev->minor), 1);
Hans Verkuil7f8ecfa2008-08-29 17:31:35 -0300534 if (ret < 0) {
535 printk(KERN_ERR "%s: cdev_add failed\n", __func__);
Hans Verkuildc93a702008-12-19 21:28:27 -0300536 kfree(vdev->cdev);
537 vdev->cdev = NULL;
538 goto cleanup;
Hans Verkuil7f8ecfa2008-08-29 17:31:35 -0300539 }
Hans Verkuildc93a702008-12-19 21:28:27 -0300540
541 /* Part 4: register the device with sysfs */
542 memset(&vdev->dev, 0, sizeof(vdev->dev));
Anatolij Gustschin1bb64192010-07-01 14:21:39 -0300543 /* The memset above cleared the device's device_private, so
Hans Verkuil9d95af92008-08-24 11:18:47 -0300544 put back the copy we made earlier. */
Anatolij Gustschin1bb64192010-07-01 14:21:39 -0300545 vdev->dev.p = priv;
Hans Verkuildc93a702008-12-19 21:28:27 -0300546 vdev->dev.class = &video_class;
547 vdev->dev.devt = MKDEV(VIDEO_MAJOR, vdev->minor);
548 if (vdev->parent)
549 vdev->dev.parent = vdev->parent;
Hans Verkuil22e22122009-09-06 07:13:14 -0300550 dev_set_name(&vdev->dev, "%s%d", name_base, vdev->num);
Hans Verkuildc93a702008-12-19 21:28:27 -0300551 ret = device_register(&vdev->dev);
Hans Verkuil27a5e6d2008-07-20 08:43:17 -0300552 if (ret < 0) {
553 printk(KERN_ERR "%s: device_register failed\n", __func__);
Hans Verkuildc93a702008-12-19 21:28:27 -0300554 goto cleanup;
Hans Verkuil27a5e6d2008-07-20 08:43:17 -0300555 }
Hans Verkuildc93a702008-12-19 21:28:27 -0300556 /* Register the release callback that will be called when the last
557 reference to the device goes away. */
558 vdev->dev.release = v4l2_device_release;
559
Hans Verkuil6b5270d2009-09-06 07:54:00 -0300560 if (nr != -1 && nr != vdev->num && warn_if_nr_in_use)
Laurent Pincharteac8ea52009-11-27 13:56:50 -0300561 printk(KERN_WARNING "%s: requested %s%d, got %s\n", __func__,
562 name_base, nr, video_device_node_name(vdev));
Hans Verkuil6b5270d2009-09-06 07:54:00 -0300563
Hans Verkuildc93a702008-12-19 21:28:27 -0300564 /* Part 5: Activate this minor. The char device can now be used. */
Laurent Pinchart957b4aa2009-11-27 13:57:22 -0300565 set_bit(V4L2_FL_REGISTERED, &vdev->flags);
Hans Verkuildc93a702008-12-19 21:28:27 -0300566 mutex_lock(&videodev_lock);
567 video_device[vdev->minor] = vdev;
568 mutex_unlock(&videodev_lock);
Hans Verkuil27a5e6d2008-07-20 08:43:17 -0300569 return 0;
570
Hans Verkuildc93a702008-12-19 21:28:27 -0300571cleanup:
Hans Verkuil27a5e6d2008-07-20 08:43:17 -0300572 mutex_lock(&videodev_lock);
Hans Verkuildc93a702008-12-19 21:28:27 -0300573 if (vdev->cdev)
574 cdev_del(vdev->cdev);
Hans Verkuil5062cb72009-09-07 03:40:24 -0300575 devnode_clear(vdev);
Hans Verkuil27a5e6d2008-07-20 08:43:17 -0300576 mutex_unlock(&videodev_lock);
Hans Verkuildc93a702008-12-19 21:28:27 -0300577 /* Mark this video device as never having been registered. */
578 vdev->minor = -1;
Hans Verkuil27a5e6d2008-07-20 08:43:17 -0300579 return ret;
580}
Hans Verkuil6b5270d2009-09-06 07:54:00 -0300581
582int video_register_device(struct video_device *vdev, int type, int nr)
583{
584 return __video_register_device(vdev, type, nr, 1);
585}
Hans Verkuil7ae0cd92009-06-19 11:32:56 -0300586EXPORT_SYMBOL(video_register_device);
Hans Verkuil27a5e6d2008-07-20 08:43:17 -0300587
Hans Verkuil6b5270d2009-09-06 07:54:00 -0300588int video_register_device_no_warn(struct video_device *vdev, int type, int nr)
589{
590 return __video_register_device(vdev, type, nr, 0);
591}
592EXPORT_SYMBOL(video_register_device_no_warn);
593
Hans Verkuil27a5e6d2008-07-20 08:43:17 -0300594/**
595 * video_unregister_device - unregister a video4linux device
Hans Verkuildc93a702008-12-19 21:28:27 -0300596 * @vdev: the device to unregister
Hans Verkuil27a5e6d2008-07-20 08:43:17 -0300597 *
Hans Verkuildc93a702008-12-19 21:28:27 -0300598 * This unregisters the passed device. Future open calls will
599 * be met with errors.
Hans Verkuil27a5e6d2008-07-20 08:43:17 -0300600 */
Hans Verkuildc93a702008-12-19 21:28:27 -0300601void video_unregister_device(struct video_device *vdev)
Hans Verkuil27a5e6d2008-07-20 08:43:17 -0300602{
Hans Verkuildc93a702008-12-19 21:28:27 -0300603 /* Check if vdev was ever registered at all */
Laurent Pinchart957b4aa2009-11-27 13:57:22 -0300604 if (!vdev || !video_is_registered(vdev))
Hans Verkuildc93a702008-12-19 21:28:27 -0300605 return;
606
Laurent Pinchart957b4aa2009-11-27 13:57:22 -0300607 clear_bit(V4L2_FL_REGISTERED, &vdev->flags);
Hans Verkuildc93a702008-12-19 21:28:27 -0300608 device_unregister(&vdev->dev);
Hans Verkuil27a5e6d2008-07-20 08:43:17 -0300609}
610EXPORT_SYMBOL(video_unregister_device);
611
612/*
Hans Verkuil27a5e6d2008-07-20 08:43:17 -0300613 * Initialise video for linux
614 */
Hans Verkuil27a5e6d2008-07-20 08:43:17 -0300615static int __init videodev_init(void)
616{
Hans Verkuil7f8ecfa2008-08-29 17:31:35 -0300617 dev_t dev = MKDEV(VIDEO_MAJOR, 0);
Hans Verkuil27a5e6d2008-07-20 08:43:17 -0300618 int ret;
619
620 printk(KERN_INFO "Linux video capture interface: v2.00\n");
Hans Verkuil7f8ecfa2008-08-29 17:31:35 -0300621 ret = register_chrdev_region(dev, VIDEO_NUM_DEVICES, VIDEO_NAME);
622 if (ret < 0) {
623 printk(KERN_WARNING "videodev: unable to get major %d\n",
624 VIDEO_MAJOR);
625 return ret;
Hans Verkuil27a5e6d2008-07-20 08:43:17 -0300626 }
627
628 ret = class_register(&video_class);
629 if (ret < 0) {
Hans Verkuil7f8ecfa2008-08-29 17:31:35 -0300630 unregister_chrdev_region(dev, VIDEO_NUM_DEVICES);
Hans Verkuil27a5e6d2008-07-20 08:43:17 -0300631 printk(KERN_WARNING "video_dev: class_register failed\n");
632 return -EIO;
633 }
634
635 return 0;
636}
637
638static void __exit videodev_exit(void)
639{
Hans Verkuil7f8ecfa2008-08-29 17:31:35 -0300640 dev_t dev = MKDEV(VIDEO_MAJOR, 0);
641
Hans Verkuil27a5e6d2008-07-20 08:43:17 -0300642 class_unregister(&video_class);
Hans Verkuil7f8ecfa2008-08-29 17:31:35 -0300643 unregister_chrdev_region(dev, VIDEO_NUM_DEVICES);
Hans Verkuil27a5e6d2008-07-20 08:43:17 -0300644}
645
646module_init(videodev_init)
647module_exit(videodev_exit)
648
649MODULE_AUTHOR("Alan Cox, Mauro Carvalho Chehab <mchehab@infradead.org>");
650MODULE_DESCRIPTION("Device registrar for Video4Linux drivers v2");
651MODULE_LICENSE("GPL");
Scott James Remnantcbb72b02009-03-02 15:40:57 -0300652MODULE_ALIAS_CHARDEV_MAJOR(VIDEO_MAJOR);
Hans Verkuil27a5e6d2008-07-20 08:43:17 -0300653
654
655/*
656 * Local variables:
657 * c-basic-offset: 8
658 * End:
659 */