2 * Video capture interface for Linux version 2
4 * A generic video device interface for the LINUX operating system
5 * using a set of device structures/vectors for low level operations.
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.
12 * Authors: Alan Cox, <alan@redhat.com> (version 1)
13 * Mauro Carvalho Chehab <mchehab@infradead.org> (version 2)
15 * Fixes: 20000516 Claudio Matsuoka <claudio@conectiva.com>
16 * - Added procfs support
19 #define dbgarg(cmd, fmt, arg...) \
21 if (vfd->debug & V4L2_DEBUG_IOCTL_ARG) { \
22 printk(KERN_DEBUG "%s: ", vfd->name); \
23 v4l_printk_ioctl(cmd); \
24 printk(" " fmt, ## arg); \
28 #define dbgarg2(fmt, arg...) \
30 if (vfd->debug & V4L2_DEBUG_IOCTL_ARG) \
31 printk(KERN_DEBUG "%s: " fmt, vfd->name, ## arg);\
34 #include <linux/module.h>
35 #include <linux/types.h>
36 #include <linux/kernel.h>
38 #include <linux/string.h>
39 #include <linux/errno.h>
40 #include <linux/init.h>
41 #include <linux/kmod.h>
42 #include <linux/slab.h>
43 #include <linux/smp_lock.h>
44 #include <asm/uaccess.h>
45 #include <asm/system.h>
47 #define __OLD_VIDIOC_ /* To allow fixing old calls*/
48 #include <linux/videodev2.h>
50 #ifdef CONFIG_VIDEO_V4L1
51 #include <linux/videodev.h>
53 #include <media/v4l2-common.h>
54 #include <linux/video_decoder.h>
56 #define VIDEO_NUM_DEVICES 256
57 #define VIDEO_NAME "video4linux"
64 static const struct std_descr standards[] = {
65 { V4L2_STD_NTSC, "NTSC" },
66 { V4L2_STD_NTSC_M, "NTSC-M" },
67 { V4L2_STD_NTSC_M_JP, "NTSC-M-JP" },
68 { V4L2_STD_NTSC_M_KR, "NTSC-M-KR" },
69 { V4L2_STD_NTSC_443, "NTSC-443" },
70 { V4L2_STD_PAL, "PAL" },
71 { V4L2_STD_PAL_BG, "PAL-BG" },
72 { V4L2_STD_PAL_B, "PAL-B" },
73 { V4L2_STD_PAL_B1, "PAL-B1" },
74 { V4L2_STD_PAL_G, "PAL-G" },
75 { V4L2_STD_PAL_H, "PAL-H" },
76 { V4L2_STD_PAL_I, "PAL-I" },
77 { V4L2_STD_PAL_DK, "PAL-DK" },
78 { V4L2_STD_PAL_D, "PAL-D" },
79 { V4L2_STD_PAL_D1, "PAL-D1" },
80 { V4L2_STD_PAL_K, "PAL-K" },
81 { V4L2_STD_PAL_M, "PAL-M" },
82 { V4L2_STD_PAL_N, "PAL-N" },
83 { V4L2_STD_PAL_Nc, "PAL-Nc" },
84 { V4L2_STD_PAL_60, "PAL-60" },
85 { V4L2_STD_SECAM, "SECAM" },
86 { V4L2_STD_SECAM_B, "SECAM-B" },
87 { V4L2_STD_SECAM_G, "SECAM-G" },
88 { V4L2_STD_SECAM_H, "SECAM-H" },
89 { V4L2_STD_SECAM_DK, "SECAM-DK" },
90 { V4L2_STD_SECAM_D, "SECAM-D" },
91 { V4L2_STD_SECAM_K, "SECAM-K" },
92 { V4L2_STD_SECAM_K1, "SECAM-K1" },
93 { V4L2_STD_SECAM_L, "SECAM-L" },
94 { V4L2_STD_SECAM_LC, "SECAM-Lc" },
98 /* video4linux standard ID conversion to standard name
100 const char *v4l2_norm_to_name(v4l2_std_id id)
105 /* HACK: ppc32 architecture doesn't have __ucmpdi2 function to handle
106 64 bit comparations. So, on that architecture, with some gcc
107 variants, compilation fails. Currently, the max value is 30bit wide.
111 for (i = 0; standards[i].std; i++)
112 if (myid == standards[i].std)
114 return standards[i].descr;
116 EXPORT_SYMBOL(v4l2_norm_to_name);
118 /* Fill in the fields of a v4l2_standard structure according to the
119 'id' and 'transmission' parameters. Returns negative on error. */
120 int v4l2_video_std_construct(struct v4l2_standard *vs,
121 int id, const char *name)
123 u32 index = vs->index;
125 memset(vs, 0, sizeof(struct v4l2_standard));
128 if (id & V4L2_STD_525_60) {
129 vs->frameperiod.numerator = 1001;
130 vs->frameperiod.denominator = 30000;
131 vs->framelines = 525;
133 vs->frameperiod.numerator = 1;
134 vs->frameperiod.denominator = 25;
135 vs->framelines = 625;
137 strlcpy(vs->name, name, sizeof(vs->name));
140 EXPORT_SYMBOL(v4l2_video_std_construct);
142 /* ----------------------------------------------------------------- */
143 /* some arrays for pretty-printing debug messages of enum types */
145 const char *v4l2_field_names[] = {
146 [V4L2_FIELD_ANY] = "any",
147 [V4L2_FIELD_NONE] = "none",
148 [V4L2_FIELD_TOP] = "top",
149 [V4L2_FIELD_BOTTOM] = "bottom",
150 [V4L2_FIELD_INTERLACED] = "interlaced",
151 [V4L2_FIELD_SEQ_TB] = "seq-tb",
152 [V4L2_FIELD_SEQ_BT] = "seq-bt",
153 [V4L2_FIELD_ALTERNATE] = "alternate",
154 [V4L2_FIELD_INTERLACED_TB] = "interlaced-tb",
155 [V4L2_FIELD_INTERLACED_BT] = "interlaced-bt",
157 EXPORT_SYMBOL(v4l2_field_names);
159 const char *v4l2_type_names[] = {
160 [V4L2_BUF_TYPE_VIDEO_CAPTURE] = "vid-cap",
161 [V4L2_BUF_TYPE_VIDEO_OVERLAY] = "vid-overlay",
162 [V4L2_BUF_TYPE_VIDEO_OUTPUT] = "vid-out",
163 [V4L2_BUF_TYPE_VBI_CAPTURE] = "vbi-cap",
164 [V4L2_BUF_TYPE_VBI_OUTPUT] = "vbi-out",
165 [V4L2_BUF_TYPE_SLICED_VBI_CAPTURE] = "sliced-vbi-cap",
166 [V4L2_BUF_TYPE_SLICED_VBI_OUTPUT] = "sliced-vbi-out",
167 [V4L2_BUF_TYPE_VIDEO_OUTPUT_OVERLAY] = "vid-out-overlay",
169 EXPORT_SYMBOL(v4l2_type_names);
171 static const char *v4l2_memory_names[] = {
172 [V4L2_MEMORY_MMAP] = "mmap",
173 [V4L2_MEMORY_USERPTR] = "userptr",
174 [V4L2_MEMORY_OVERLAY] = "overlay",
177 #define prt_names(a, arr) ((((a) >= 0) && ((a) < ARRAY_SIZE(arr))) ? \
180 /* ------------------------------------------------------------------ */
181 /* debug help functions */
183 #ifdef CONFIG_VIDEO_V4L1_COMPAT
184 static const char *v4l1_ioctls[] = {
185 [_IOC_NR(VIDIOCGCAP)] = "VIDIOCGCAP",
186 [_IOC_NR(VIDIOCGCHAN)] = "VIDIOCGCHAN",
187 [_IOC_NR(VIDIOCSCHAN)] = "VIDIOCSCHAN",
188 [_IOC_NR(VIDIOCGTUNER)] = "VIDIOCGTUNER",
189 [_IOC_NR(VIDIOCSTUNER)] = "VIDIOCSTUNER",
190 [_IOC_NR(VIDIOCGPICT)] = "VIDIOCGPICT",
191 [_IOC_NR(VIDIOCSPICT)] = "VIDIOCSPICT",
192 [_IOC_NR(VIDIOCCAPTURE)] = "VIDIOCCAPTURE",
193 [_IOC_NR(VIDIOCGWIN)] = "VIDIOCGWIN",
194 [_IOC_NR(VIDIOCSWIN)] = "VIDIOCSWIN",
195 [_IOC_NR(VIDIOCGFBUF)] = "VIDIOCGFBUF",
196 [_IOC_NR(VIDIOCSFBUF)] = "VIDIOCSFBUF",
197 [_IOC_NR(VIDIOCKEY)] = "VIDIOCKEY",
198 [_IOC_NR(VIDIOCGFREQ)] = "VIDIOCGFREQ",
199 [_IOC_NR(VIDIOCSFREQ)] = "VIDIOCSFREQ",
200 [_IOC_NR(VIDIOCGAUDIO)] = "VIDIOCGAUDIO",
201 [_IOC_NR(VIDIOCSAUDIO)] = "VIDIOCSAUDIO",
202 [_IOC_NR(VIDIOCSYNC)] = "VIDIOCSYNC",
203 [_IOC_NR(VIDIOCMCAPTURE)] = "VIDIOCMCAPTURE",
204 [_IOC_NR(VIDIOCGMBUF)] = "VIDIOCGMBUF",
205 [_IOC_NR(VIDIOCGUNIT)] = "VIDIOCGUNIT",
206 [_IOC_NR(VIDIOCGCAPTURE)] = "VIDIOCGCAPTURE",
207 [_IOC_NR(VIDIOCSCAPTURE)] = "VIDIOCSCAPTURE",
208 [_IOC_NR(VIDIOCSPLAYMODE)] = "VIDIOCSPLAYMODE",
209 [_IOC_NR(VIDIOCSWRITEMODE)] = "VIDIOCSWRITEMODE",
210 [_IOC_NR(VIDIOCGPLAYINFO)] = "VIDIOCGPLAYINFO",
211 [_IOC_NR(VIDIOCSMICROCODE)] = "VIDIOCSMICROCODE",
212 [_IOC_NR(VIDIOCGVBIFMT)] = "VIDIOCGVBIFMT",
213 [_IOC_NR(VIDIOCSVBIFMT)] = "VIDIOCSVBIFMT"
215 #define V4L1_IOCTLS ARRAY_SIZE(v4l1_ioctls)
218 static const char *v4l2_ioctls[] = {
219 [_IOC_NR(VIDIOC_QUERYCAP)] = "VIDIOC_QUERYCAP",
220 [_IOC_NR(VIDIOC_RESERVED)] = "VIDIOC_RESERVED",
221 [_IOC_NR(VIDIOC_ENUM_FMT)] = "VIDIOC_ENUM_FMT",
222 [_IOC_NR(VIDIOC_G_FMT)] = "VIDIOC_G_FMT",
223 [_IOC_NR(VIDIOC_S_FMT)] = "VIDIOC_S_FMT",
224 [_IOC_NR(VIDIOC_REQBUFS)] = "VIDIOC_REQBUFS",
225 [_IOC_NR(VIDIOC_QUERYBUF)] = "VIDIOC_QUERYBUF",
226 [_IOC_NR(VIDIOC_G_FBUF)] = "VIDIOC_G_FBUF",
227 [_IOC_NR(VIDIOC_S_FBUF)] = "VIDIOC_S_FBUF",
228 [_IOC_NR(VIDIOC_OVERLAY)] = "VIDIOC_OVERLAY",
229 [_IOC_NR(VIDIOC_QBUF)] = "VIDIOC_QBUF",
230 [_IOC_NR(VIDIOC_DQBUF)] = "VIDIOC_DQBUF",
231 [_IOC_NR(VIDIOC_STREAMON)] = "VIDIOC_STREAMON",
232 [_IOC_NR(VIDIOC_STREAMOFF)] = "VIDIOC_STREAMOFF",
233 [_IOC_NR(VIDIOC_G_PARM)] = "VIDIOC_G_PARM",
234 [_IOC_NR(VIDIOC_S_PARM)] = "VIDIOC_S_PARM",
235 [_IOC_NR(VIDIOC_G_STD)] = "VIDIOC_G_STD",
236 [_IOC_NR(VIDIOC_S_STD)] = "VIDIOC_S_STD",
237 [_IOC_NR(VIDIOC_ENUMSTD)] = "VIDIOC_ENUMSTD",
238 [_IOC_NR(VIDIOC_ENUMINPUT)] = "VIDIOC_ENUMINPUT",
239 [_IOC_NR(VIDIOC_G_CTRL)] = "VIDIOC_G_CTRL",
240 [_IOC_NR(VIDIOC_S_CTRL)] = "VIDIOC_S_CTRL",
241 [_IOC_NR(VIDIOC_G_TUNER)] = "VIDIOC_G_TUNER",
242 [_IOC_NR(VIDIOC_S_TUNER)] = "VIDIOC_S_TUNER",
243 [_IOC_NR(VIDIOC_G_AUDIO)] = "VIDIOC_G_AUDIO",
244 [_IOC_NR(VIDIOC_S_AUDIO)] = "VIDIOC_S_AUDIO",
245 [_IOC_NR(VIDIOC_QUERYCTRL)] = "VIDIOC_QUERYCTRL",
246 [_IOC_NR(VIDIOC_QUERYMENU)] = "VIDIOC_QUERYMENU",
247 [_IOC_NR(VIDIOC_G_INPUT)] = "VIDIOC_G_INPUT",
248 [_IOC_NR(VIDIOC_S_INPUT)] = "VIDIOC_S_INPUT",
249 [_IOC_NR(VIDIOC_G_OUTPUT)] = "VIDIOC_G_OUTPUT",
250 [_IOC_NR(VIDIOC_S_OUTPUT)] = "VIDIOC_S_OUTPUT",
251 [_IOC_NR(VIDIOC_ENUMOUTPUT)] = "VIDIOC_ENUMOUTPUT",
252 [_IOC_NR(VIDIOC_G_AUDOUT)] = "VIDIOC_G_AUDOUT",
253 [_IOC_NR(VIDIOC_S_AUDOUT)] = "VIDIOC_S_AUDOUT",
254 [_IOC_NR(VIDIOC_G_MODULATOR)] = "VIDIOC_G_MODULATOR",
255 [_IOC_NR(VIDIOC_S_MODULATOR)] = "VIDIOC_S_MODULATOR",
256 [_IOC_NR(VIDIOC_G_FREQUENCY)] = "VIDIOC_G_FREQUENCY",
257 [_IOC_NR(VIDIOC_S_FREQUENCY)] = "VIDIOC_S_FREQUENCY",
258 [_IOC_NR(VIDIOC_CROPCAP)] = "VIDIOC_CROPCAP",
259 [_IOC_NR(VIDIOC_G_CROP)] = "VIDIOC_G_CROP",
260 [_IOC_NR(VIDIOC_S_CROP)] = "VIDIOC_S_CROP",
261 [_IOC_NR(VIDIOC_G_JPEGCOMP)] = "VIDIOC_G_JPEGCOMP",
262 [_IOC_NR(VIDIOC_S_JPEGCOMP)] = "VIDIOC_S_JPEGCOMP",
263 [_IOC_NR(VIDIOC_QUERYSTD)] = "VIDIOC_QUERYSTD",
264 [_IOC_NR(VIDIOC_TRY_FMT)] = "VIDIOC_TRY_FMT",
265 [_IOC_NR(VIDIOC_ENUMAUDIO)] = "VIDIOC_ENUMAUDIO",
266 [_IOC_NR(VIDIOC_ENUMAUDOUT)] = "VIDIOC_ENUMAUDOUT",
267 [_IOC_NR(VIDIOC_G_PRIORITY)] = "VIDIOC_G_PRIORITY",
268 [_IOC_NR(VIDIOC_S_PRIORITY)] = "VIDIOC_S_PRIORITY",
269 [_IOC_NR(VIDIOC_G_SLICED_VBI_CAP)] = "VIDIOC_G_SLICED_VBI_CAP",
270 [_IOC_NR(VIDIOC_LOG_STATUS)] = "VIDIOC_LOG_STATUS",
271 [_IOC_NR(VIDIOC_G_EXT_CTRLS)] = "VIDIOC_G_EXT_CTRLS",
272 [_IOC_NR(VIDIOC_S_EXT_CTRLS)] = "VIDIOC_S_EXT_CTRLS",
273 [_IOC_NR(VIDIOC_TRY_EXT_CTRLS)] = "VIDIOC_TRY_EXT_CTRLS",
275 [_IOC_NR(VIDIOC_ENUM_FRAMESIZES)] = "VIDIOC_ENUM_FRAMESIZES",
276 [_IOC_NR(VIDIOC_ENUM_FRAMEINTERVALS)] = "VIDIOC_ENUM_FRAMEINTERVALS",
277 [_IOC_NR(VIDIOC_G_ENC_INDEX)] = "VIDIOC_G_ENC_INDEX",
278 [_IOC_NR(VIDIOC_ENCODER_CMD)] = "VIDIOC_ENCODER_CMD",
279 [_IOC_NR(VIDIOC_TRY_ENCODER_CMD)] = "VIDIOC_TRY_ENCODER_CMD",
281 [_IOC_NR(VIDIOC_DBG_S_REGISTER)] = "VIDIOC_DBG_S_REGISTER",
282 [_IOC_NR(VIDIOC_DBG_G_REGISTER)] = "VIDIOC_DBG_G_REGISTER",
284 [_IOC_NR(VIDIOC_G_CHIP_IDENT)] = "VIDIOC_G_CHIP_IDENT",
285 [_IOC_NR(VIDIOC_S_HW_FREQ_SEEK)] = "VIDIOC_S_HW_FREQ_SEEK",
288 #define V4L2_IOCTLS ARRAY_SIZE(v4l2_ioctls)
290 static const char *v4l2_int_ioctls[] = {
291 #ifdef CONFIG_VIDEO_V4L1_COMPAT
292 [_IOC_NR(DECODER_GET_CAPABILITIES)] = "DECODER_GET_CAPABILITIES",
293 [_IOC_NR(DECODER_GET_STATUS)] = "DECODER_GET_STATUS",
294 [_IOC_NR(DECODER_SET_NORM)] = "DECODER_SET_NORM",
295 [_IOC_NR(DECODER_SET_INPUT)] = "DECODER_SET_INPUT",
296 [_IOC_NR(DECODER_SET_OUTPUT)] = "DECODER_SET_OUTPUT",
297 [_IOC_NR(DECODER_ENABLE_OUTPUT)] = "DECODER_ENABLE_OUTPUT",
298 [_IOC_NR(DECODER_SET_PICTURE)] = "DECODER_SET_PICTURE",
299 [_IOC_NR(DECODER_SET_GPIO)] = "DECODER_SET_GPIO",
300 [_IOC_NR(DECODER_INIT)] = "DECODER_INIT",
301 [_IOC_NR(DECODER_SET_VBI_BYPASS)] = "DECODER_SET_VBI_BYPASS",
302 [_IOC_NR(DECODER_DUMP)] = "DECODER_DUMP",
304 [_IOC_NR(AUDC_SET_RADIO)] = "AUDC_SET_RADIO",
306 [_IOC_NR(TUNER_SET_TYPE_ADDR)] = "TUNER_SET_TYPE_ADDR",
307 [_IOC_NR(TUNER_SET_STANDBY)] = "TUNER_SET_STANDBY",
308 [_IOC_NR(TUNER_SET_CONFIG)] = "TUNER_SET_CONFIG",
310 [_IOC_NR(VIDIOC_INT_S_TUNER_MODE)] = "VIDIOC_INT_S_TUNER_MODE",
311 [_IOC_NR(VIDIOC_INT_RESET)] = "VIDIOC_INT_RESET",
312 [_IOC_NR(VIDIOC_INT_AUDIO_CLOCK_FREQ)] = "VIDIOC_INT_AUDIO_CLOCK_FREQ",
313 [_IOC_NR(VIDIOC_INT_DECODE_VBI_LINE)] = "VIDIOC_INT_DECODE_VBI_LINE",
314 [_IOC_NR(VIDIOC_INT_S_VBI_DATA)] = "VIDIOC_INT_S_VBI_DATA",
315 [_IOC_NR(VIDIOC_INT_G_VBI_DATA)] = "VIDIOC_INT_G_VBI_DATA",
316 [_IOC_NR(VIDIOC_INT_I2S_CLOCK_FREQ)] = "VIDIOC_INT_I2S_CLOCK_FREQ",
317 [_IOC_NR(VIDIOC_INT_S_STANDBY)] = "VIDIOC_INT_S_STANDBY",
318 [_IOC_NR(VIDIOC_INT_S_AUDIO_ROUTING)] = "VIDIOC_INT_S_AUDIO_ROUTING",
319 [_IOC_NR(VIDIOC_INT_G_AUDIO_ROUTING)] = "VIDIOC_INT_G_AUDIO_ROUTING",
320 [_IOC_NR(VIDIOC_INT_S_VIDEO_ROUTING)] = "VIDIOC_INT_S_VIDEO_ROUTING",
321 [_IOC_NR(VIDIOC_INT_G_VIDEO_ROUTING)] = "VIDIOC_INT_G_VIDEO_ROUTING",
322 [_IOC_NR(VIDIOC_INT_S_CRYSTAL_FREQ)] = "VIDIOC_INT_S_CRYSTAL_FREQ",
323 [_IOC_NR(VIDIOC_INT_INIT)] = "VIDIOC_INT_INIT",
324 [_IOC_NR(VIDIOC_INT_G_STD_OUTPUT)] = "VIDIOC_INT_G_STD_OUTPUT",
325 [_IOC_NR(VIDIOC_INT_S_STD_OUTPUT)] = "VIDIOC_INT_S_STD_OUTPUT",
327 #define V4L2_INT_IOCTLS ARRAY_SIZE(v4l2_int_ioctls)
329 /* Common ioctl debug function. This function can be used by
330 external ioctl messages as well as internal V4L ioctl */
331 void v4l_printk_ioctl(unsigned int cmd)
335 switch (_IOC_TYPE(cmd)) {
337 if (_IOC_NR(cmd) >= V4L2_INT_IOCTLS) {
341 printk("%s", v4l2_int_ioctls[_IOC_NR(cmd)]);
343 #ifdef CONFIG_VIDEO_V4L1_COMPAT
345 if (_IOC_NR(cmd) >= V4L1_IOCTLS) {
349 printk("%s", v4l1_ioctls[_IOC_NR(cmd)]);
353 if (_IOC_NR(cmd) >= V4L2_IOCTLS) {
357 printk("%s", v4l2_ioctls[_IOC_NR(cmd)]);
363 switch (_IOC_DIR(cmd)) {
364 case _IOC_NONE: dir = "--"; break;
365 case _IOC_READ: dir = "r-"; break;
366 case _IOC_WRITE: dir = "-w"; break;
367 case _IOC_READ | _IOC_WRITE: dir = "rw"; break;
368 default: dir = "*ERR*"; break;
370 printk("%s ioctl '%c', dir=%s, #%d (0x%08x)",
371 type, _IOC_TYPE(cmd), dir, _IOC_NR(cmd), cmd);
373 EXPORT_SYMBOL(v4l_printk_ioctl);
379 static ssize_t show_index(struct device *cd,
380 struct device_attribute *attr, char *buf)
382 struct video_device *vfd = container_of(cd, struct video_device,
384 return sprintf(buf, "%i\n", vfd->index);
387 static ssize_t show_name(struct device *cd,
388 struct device_attribute *attr, char *buf)
390 struct video_device *vfd = container_of(cd, struct video_device,
392 return sprintf(buf, "%.*s\n", (int)sizeof(vfd->name), vfd->name);
395 struct video_device *video_device_alloc(void)
397 struct video_device *vfd;
399 vfd = kzalloc(sizeof(*vfd),GFP_KERNEL);
402 EXPORT_SYMBOL(video_device_alloc);
404 void video_device_release(struct video_device *vfd)
408 EXPORT_SYMBOL(video_device_release);
410 static void video_release(struct device *cd)
412 struct video_device *vfd = container_of(cd, struct video_device,
416 /* needed until all drivers are fixed */
423 static struct device_attribute video_device_attrs[] = {
424 __ATTR(name, S_IRUGO, show_name, NULL),
425 __ATTR(index, S_IRUGO, show_index, NULL),
429 static struct class video_class = {
431 .dev_attrs = video_device_attrs,
432 .dev_release = video_release,
439 static struct video_device *video_device[VIDEO_NUM_DEVICES];
440 static DEFINE_MUTEX(videodev_lock);
442 struct video_device* video_devdata(struct file *file)
444 return video_device[iminor(file->f_path.dentry->d_inode)];
446 EXPORT_SYMBOL(video_devdata);
449 * Open a video device - FIXME: Obsoleted
451 static int video_open(struct inode *inode, struct file *file)
453 unsigned int minor = iminor(inode);
455 struct video_device *vfl;
456 const struct file_operations *old_fops;
458 if(minor>=VIDEO_NUM_DEVICES)
461 mutex_lock(&videodev_lock);
462 vfl=video_device[minor];
464 mutex_unlock(&videodev_lock);
465 request_module("char-major-%d-%d", VIDEO_MAJOR, minor);
466 mutex_lock(&videodev_lock);
467 vfl=video_device[minor];
469 mutex_unlock(&videodev_lock);
474 old_fops = file->f_op;
475 file->f_op = fops_get(vfl->fops);
477 err = file->f_op->open(inode,file);
479 fops_put(file->f_op);
480 file->f_op = fops_get(old_fops);
483 mutex_unlock(&videodev_lock);
489 * helper function -- handles userspace copying for ioctl arguments
494 video_fix_command(unsigned int cmd)
497 case VIDIOC_OVERLAY_OLD:
498 cmd = VIDIOC_OVERLAY;
500 case VIDIOC_S_PARM_OLD:
503 case VIDIOC_S_CTRL_OLD:
506 case VIDIOC_G_AUDIO_OLD:
507 cmd = VIDIOC_G_AUDIO;
509 case VIDIOC_G_AUDOUT_OLD:
510 cmd = VIDIOC_G_AUDOUT;
512 case VIDIOC_CROPCAP_OLD:
513 cmd = VIDIOC_CROPCAP;
521 * Obsolete usercopy function - Should be removed soon
524 video_usercopy(struct inode *inode, struct file *file,
525 unsigned int cmd, unsigned long arg,
526 int (*func)(struct inode *inode, struct file *file,
527 unsigned int cmd, void *arg))
534 size_t ctrls_size = 0;
535 void __user *user_ptr = NULL;
538 cmd = video_fix_command(cmd);
540 is_ext_ctrl = (cmd == VIDIOC_S_EXT_CTRLS || cmd == VIDIOC_G_EXT_CTRLS ||
541 cmd == VIDIOC_TRY_EXT_CTRLS);
543 /* Copy arguments into temp kernel buffer */
544 switch (_IOC_DIR(cmd)) {
550 case (_IOC_WRITE | _IOC_READ):
551 if (_IOC_SIZE(cmd) <= sizeof(sbuf)) {
554 /* too big to allocate from stack */
555 mbuf = kmalloc(_IOC_SIZE(cmd),GFP_KERNEL);
562 if (_IOC_DIR(cmd) & _IOC_WRITE)
563 if (copy_from_user(parg, (void __user *)arg, _IOC_SIZE(cmd)))
568 struct v4l2_ext_controls *p = parg;
570 /* In case of an error, tell the caller that it wasn't
571 a specific control that caused it. */
572 p->error_idx = p->count;
573 user_ptr = (void __user *)p->controls;
575 ctrls_size = sizeof(struct v4l2_ext_control) * p->count;
576 /* Note: v4l2_ext_controls fits in sbuf[] so mbuf is still NULL. */
577 mbuf = kmalloc(ctrls_size, GFP_KERNEL);
582 if (copy_from_user(mbuf, user_ptr, ctrls_size))
589 err = func(inode, file, cmd, parg);
590 if (err == -ENOIOCTLCMD)
593 struct v4l2_ext_controls *p = parg;
595 p->controls = (void *)user_ptr;
596 if (p->count && err == 0 && copy_to_user(user_ptr, mbuf, ctrls_size))
604 /* Copy results into user buffer */
605 switch (_IOC_DIR(cmd))
608 case (_IOC_WRITE | _IOC_READ):
609 if (copy_to_user((void __user *)arg, parg, _IOC_SIZE(cmd)))
618 EXPORT_SYMBOL(video_usercopy);
621 * open/release helper functions -- handle exclusive opens
622 * Should be removed soon
624 int video_exclusive_open(struct inode *inode, struct file *file)
626 struct video_device *vfl = video_devdata(file);
629 mutex_lock(&vfl->lock);
635 mutex_unlock(&vfl->lock);
638 EXPORT_SYMBOL(video_exclusive_open);
640 int video_exclusive_release(struct inode *inode, struct file *file)
642 struct video_device *vfl = video_devdata(file);
647 EXPORT_SYMBOL(video_exclusive_release);
649 static void dbgbuf(unsigned int cmd, struct video_device *vfd,
650 struct v4l2_buffer *p)
652 struct v4l2_timecode *tc=&p->timecode;
654 dbgarg (cmd, "%02ld:%02d:%02d.%08ld index=%d, type=%s, "
655 "bytesused=%d, flags=0x%08d, "
656 "field=%0d, sequence=%d, memory=%s, offset/userptr=0x%08lx, length=%d\n",
657 (p->timestamp.tv_sec/3600),
658 (int)(p->timestamp.tv_sec/60)%60,
659 (int)(p->timestamp.tv_sec%60),
660 p->timestamp.tv_usec,
662 prt_names(p->type, v4l2_type_names),
663 p->bytesused, p->flags,
664 p->field, p->sequence,
665 prt_names(p->memory, v4l2_memory_names),
666 p->m.userptr, p->length);
667 dbgarg2("timecode=%02d:%02d:%02d type=%d, "
668 "flags=0x%08d, frames=%d, userbits=0x%08x\n",
669 tc->hours,tc->minutes,tc->seconds,
670 tc->type, tc->flags, tc->frames, *(__u32 *) tc->userbits);
673 static inline void dbgrect(struct video_device *vfd, char *s,
676 dbgarg2("%sRect start at %dx%d, size=%dx%d\n", s, r->left, r->top,
677 r->width, r->height);
680 static inline void v4l_print_pix_fmt (struct video_device *vfd,
681 struct v4l2_pix_format *fmt)
683 dbgarg2 ("width=%d, height=%d, format=%c%c%c%c, field=%s, "
684 "bytesperline=%d sizeimage=%d, colorspace=%d\n",
685 fmt->width,fmt->height,
686 (fmt->pixelformat & 0xff),
687 (fmt->pixelformat >> 8) & 0xff,
688 (fmt->pixelformat >> 16) & 0xff,
689 (fmt->pixelformat >> 24) & 0xff,
690 prt_names(fmt->field, v4l2_field_names),
691 fmt->bytesperline, fmt->sizeimage, fmt->colorspace);
694 static inline void v4l_print_ext_ctrls(unsigned int cmd,
695 struct video_device *vfd, struct v4l2_ext_controls *c, int show_vals)
699 if (!(vfd->debug & V4L2_DEBUG_IOCTL_ARG))
702 printk(KERN_CONT "class=0x%x", c->ctrl_class);
703 for (i = 0; i < c->count; i++) {
705 printk(KERN_CONT " id/val=0x%x/0x%x",
706 c->controls[i].id, c->controls[i].value);
708 printk(KERN_CONT " id=0x%x", c->controls[i].id);
710 printk(KERN_CONT "\n");
713 static inline int check_ext_ctrls(struct v4l2_ext_controls *c)
717 /* zero the reserved fields */
718 c->reserved[0] = c->reserved[1] = 0;
719 for (i = 0; i < c->count; i++) {
720 c->controls[i].reserved2[0] = 0;
721 c->controls[i].reserved2[1] = 0;
723 /* V4L2_CID_PRIVATE_BASE cannot be used as control class
724 * when using extended controls. */
725 if (c->ctrl_class == V4L2_CID_PRIVATE_BASE)
727 /* Check that all controls are from the same control class. */
728 for (i = 0; i < c->count; i++) {
729 if (V4L2_CTRL_ID2CLASS(c->controls[i].id) != c->ctrl_class) {
737 static int check_fmt (struct video_device *vfd, enum v4l2_buf_type type)
740 case V4L2_BUF_TYPE_VIDEO_CAPTURE:
741 if (vfd->vidioc_try_fmt_vid_cap)
744 case V4L2_BUF_TYPE_VIDEO_OVERLAY:
745 if (vfd->vidioc_try_fmt_vid_overlay)
748 case V4L2_BUF_TYPE_VIDEO_OUTPUT:
749 if (vfd->vidioc_try_fmt_vid_out)
752 case V4L2_BUF_TYPE_VIDEO_OUTPUT_OVERLAY:
753 if (vfd->vidioc_try_fmt_vid_out_overlay)
756 case V4L2_BUF_TYPE_VBI_CAPTURE:
757 if (vfd->vidioc_try_fmt_vbi_cap)
760 case V4L2_BUF_TYPE_VBI_OUTPUT:
761 if (vfd->vidioc_try_fmt_vbi_out)
764 case V4L2_BUF_TYPE_SLICED_VBI_CAPTURE:
765 if (vfd->vidioc_try_fmt_sliced_vbi_cap)
768 case V4L2_BUF_TYPE_SLICED_VBI_OUTPUT:
769 if (vfd->vidioc_try_fmt_sliced_vbi_out)
772 case V4L2_BUF_TYPE_PRIVATE:
773 if (vfd->vidioc_try_fmt_type_private)
780 static int __video_do_ioctl(struct inode *inode, struct file *file,
781 unsigned int cmd, void *arg)
783 struct video_device *vfd = video_devdata(file);
784 void *fh = file->private_data;
787 if ( (vfd->debug & V4L2_DEBUG_IOCTL) &&
788 !(vfd->debug & V4L2_DEBUG_IOCTL_ARG)) {
789 v4l_print_ioctl(vfd->name, cmd);
793 #ifdef CONFIG_VIDEO_V4L1_COMPAT
794 /***********************************************************
795 Handles calls to the obsoleted V4L1 API
796 Due to the nature of VIDIOCGMBUF, each driver that supports
797 V4L1 should implement its own handler for this ioctl.
798 ***********************************************************/
800 /* --- streaming capture ------------------------------------- */
801 if (cmd == VIDIOCGMBUF) {
802 struct video_mbuf *p=arg;
804 memset(p, 0, sizeof(*p));
806 if (!vfd->vidiocgmbuf)
808 ret=vfd->vidiocgmbuf(file, fh, p);
810 dbgarg (cmd, "size=%d, frames=%d, offsets=0x%08lx\n",
812 (unsigned long)p->offsets);
816 /********************************************************
817 All other V4L1 calls are handled by v4l1_compat module.
818 Those calls will be translated into V4L2 calls, and
819 __video_do_ioctl will be called again, with one or more
821 ********************************************************/
822 if (_IOC_TYPE(cmd)=='v')
823 return v4l_compat_translate_ioctl(inode,file,cmd,arg,
828 /* --- capabilities ------------------------------------------ */
829 case VIDIOC_QUERYCAP:
831 struct v4l2_capability *cap = (struct v4l2_capability*)arg;
832 memset(cap, 0, sizeof(*cap));
834 if (!vfd->vidioc_querycap)
837 ret=vfd->vidioc_querycap(file, fh, cap);
839 dbgarg (cmd, "driver=%s, card=%s, bus=%s, "
841 "capabilities=0x%08x\n",
842 cap->driver,cap->card,cap->bus_info,
848 /* --- priority ------------------------------------------ */
849 case VIDIOC_G_PRIORITY:
851 enum v4l2_priority *p=arg;
853 if (!vfd->vidioc_g_priority)
855 ret=vfd->vidioc_g_priority(file, fh, p);
857 dbgarg(cmd, "priority is %d\n", *p);
860 case VIDIOC_S_PRIORITY:
862 enum v4l2_priority *p=arg;
864 if (!vfd->vidioc_s_priority)
866 dbgarg(cmd, "setting priority to %d\n", *p);
867 ret=vfd->vidioc_s_priority(file, fh, *p);
871 /* --- capture ioctls ---------------------------------------- */
872 case VIDIOC_ENUM_FMT:
874 struct v4l2_fmtdesc *f = arg;
875 enum v4l2_buf_type type;
880 memset(f,0,sizeof(*f));
885 case V4L2_BUF_TYPE_VIDEO_CAPTURE:
886 if (vfd->vidioc_enum_fmt_vid_cap)
887 ret = vfd->vidioc_enum_fmt_vid_cap(file, fh, f);
889 case V4L2_BUF_TYPE_VIDEO_OVERLAY:
890 if (vfd->vidioc_enum_fmt_vid_overlay)
891 ret = vfd->vidioc_enum_fmt_vid_overlay(file,
895 /* V4L2_BUF_TYPE_VBI_CAPTURE should not support VIDIOC_ENUM_FMT
896 * according to the spec. The bttv and saa7134 drivers support
897 * it though, so just warn that this is deprecated and will be
898 * removed in the near future. */
899 case V4L2_BUF_TYPE_VBI_CAPTURE:
900 if (vfd->vidioc_enum_fmt_vbi_cap) {
901 printk(KERN_WARNING "vidioc_enum_fmt_vbi_cap will be removed in 2.6.28!\n");
902 ret = vfd->vidioc_enum_fmt_vbi_cap(file, fh, f);
906 case V4L2_BUF_TYPE_VIDEO_OUTPUT:
907 if (vfd->vidioc_enum_fmt_vid_out)
908 ret = vfd->vidioc_enum_fmt_vid_out(file, fh, f);
910 case V4L2_BUF_TYPE_PRIVATE:
911 if (vfd->vidioc_enum_fmt_type_private)
912 ret = vfd->vidioc_enum_fmt_type_private(file,
919 dbgarg (cmd, "index=%d, type=%d, flags=%d, "
920 "pixelformat=%c%c%c%c, description='%s'\n",
921 f->index, f->type, f->flags,
922 (f->pixelformat & 0xff),
923 (f->pixelformat >> 8) & 0xff,
924 (f->pixelformat >> 16) & 0xff,
925 (f->pixelformat >> 24) & 0xff,
931 struct v4l2_format *f = (struct v4l2_format *)arg;
933 memset(f->fmt.raw_data, 0, sizeof(f->fmt.raw_data));
935 /* FIXME: Should be one dump per type */
936 dbgarg(cmd, "type=%s\n", prt_names(f->type, v4l2_type_names));
939 case V4L2_BUF_TYPE_VIDEO_CAPTURE:
940 if (vfd->vidioc_g_fmt_vid_cap)
941 ret = vfd->vidioc_g_fmt_vid_cap(file, fh, f);
943 v4l_print_pix_fmt(vfd, &f->fmt.pix);
945 case V4L2_BUF_TYPE_VIDEO_OVERLAY:
946 if (vfd->vidioc_g_fmt_vid_overlay)
947 ret = vfd->vidioc_g_fmt_vid_overlay(file,
950 case V4L2_BUF_TYPE_VIDEO_OUTPUT:
951 if (vfd->vidioc_g_fmt_vid_out)
952 ret = vfd->vidioc_g_fmt_vid_out(file, fh, f);
954 v4l_print_pix_fmt(vfd, &f->fmt.pix);
956 case V4L2_BUF_TYPE_VIDEO_OUTPUT_OVERLAY:
957 if (vfd->vidioc_g_fmt_vid_out_overlay)
958 ret = vfd->vidioc_g_fmt_vid_out_overlay(file,
961 case V4L2_BUF_TYPE_VBI_CAPTURE:
962 if (vfd->vidioc_g_fmt_vbi_cap)
963 ret = vfd->vidioc_g_fmt_vbi_cap(file, fh, f);
965 case V4L2_BUF_TYPE_VBI_OUTPUT:
966 if (vfd->vidioc_g_fmt_vbi_out)
967 ret = vfd->vidioc_g_fmt_vbi_out(file, fh, f);
969 case V4L2_BUF_TYPE_SLICED_VBI_CAPTURE:
970 if (vfd->vidioc_g_fmt_sliced_vbi_cap)
971 ret = vfd->vidioc_g_fmt_sliced_vbi_cap(file,
974 case V4L2_BUF_TYPE_SLICED_VBI_OUTPUT:
975 if (vfd->vidioc_g_fmt_sliced_vbi_out)
976 ret = vfd->vidioc_g_fmt_sliced_vbi_out(file,
979 case V4L2_BUF_TYPE_PRIVATE:
980 if (vfd->vidioc_g_fmt_type_private)
981 ret = vfd->vidioc_g_fmt_type_private(file,
990 struct v4l2_format *f = (struct v4l2_format *)arg;
992 /* FIXME: Should be one dump per type */
993 dbgarg(cmd, "type=%s\n", prt_names(f->type, v4l2_type_names));
996 case V4L2_BUF_TYPE_VIDEO_CAPTURE:
997 v4l_print_pix_fmt(vfd, &f->fmt.pix);
998 if (vfd->vidioc_s_fmt_vid_cap)
999 ret = vfd->vidioc_s_fmt_vid_cap(file, fh, f);
1001 case V4L2_BUF_TYPE_VIDEO_OVERLAY:
1002 if (vfd->vidioc_s_fmt_vid_overlay)
1003 ret = vfd->vidioc_s_fmt_vid_overlay(file,
1006 case V4L2_BUF_TYPE_VIDEO_OUTPUT:
1007 v4l_print_pix_fmt(vfd, &f->fmt.pix);
1008 if (vfd->vidioc_s_fmt_vid_out)
1009 ret = vfd->vidioc_s_fmt_vid_out(file, fh, f);
1011 case V4L2_BUF_TYPE_VIDEO_OUTPUT_OVERLAY:
1012 if (vfd->vidioc_s_fmt_vid_out_overlay)
1013 ret = vfd->vidioc_s_fmt_vid_out_overlay(file,
1016 case V4L2_BUF_TYPE_VBI_CAPTURE:
1017 if (vfd->vidioc_s_fmt_vbi_cap)
1018 ret = vfd->vidioc_s_fmt_vbi_cap(file, fh, f);
1020 case V4L2_BUF_TYPE_VBI_OUTPUT:
1021 if (vfd->vidioc_s_fmt_vbi_out)
1022 ret = vfd->vidioc_s_fmt_vbi_out(file, fh, f);
1024 case V4L2_BUF_TYPE_SLICED_VBI_CAPTURE:
1025 if (vfd->vidioc_s_fmt_sliced_vbi_cap)
1026 ret = vfd->vidioc_s_fmt_sliced_vbi_cap(file,
1029 case V4L2_BUF_TYPE_SLICED_VBI_OUTPUT:
1030 if (vfd->vidioc_s_fmt_sliced_vbi_out)
1031 ret = vfd->vidioc_s_fmt_sliced_vbi_out(file,
1034 case V4L2_BUF_TYPE_PRIVATE:
1035 if (vfd->vidioc_s_fmt_type_private)
1036 ret = vfd->vidioc_s_fmt_type_private(file,
1042 case VIDIOC_TRY_FMT:
1044 struct v4l2_format *f = (struct v4l2_format *)arg;
1046 /* FIXME: Should be one dump per type */
1047 dbgarg (cmd, "type=%s\n", prt_names(f->type,
1050 case V4L2_BUF_TYPE_VIDEO_CAPTURE:
1051 if (vfd->vidioc_try_fmt_vid_cap)
1052 ret = vfd->vidioc_try_fmt_vid_cap(file, fh, f);
1054 v4l_print_pix_fmt(vfd, &f->fmt.pix);
1056 case V4L2_BUF_TYPE_VIDEO_OVERLAY:
1057 if (vfd->vidioc_try_fmt_vid_overlay)
1058 ret = vfd->vidioc_try_fmt_vid_overlay(file,
1061 case V4L2_BUF_TYPE_VIDEO_OUTPUT:
1062 if (vfd->vidioc_try_fmt_vid_out)
1063 ret = vfd->vidioc_try_fmt_vid_out(file, fh, f);
1065 v4l_print_pix_fmt(vfd, &f->fmt.pix);
1067 case V4L2_BUF_TYPE_VIDEO_OUTPUT_OVERLAY:
1068 if (vfd->vidioc_try_fmt_vid_out_overlay)
1069 ret = vfd->vidioc_try_fmt_vid_out_overlay(file,
1072 case V4L2_BUF_TYPE_VBI_CAPTURE:
1073 if (vfd->vidioc_try_fmt_vbi_cap)
1074 ret = vfd->vidioc_try_fmt_vbi_cap(file, fh, f);
1076 case V4L2_BUF_TYPE_VBI_OUTPUT:
1077 if (vfd->vidioc_try_fmt_vbi_out)
1078 ret = vfd->vidioc_try_fmt_vbi_out(file, fh, f);
1080 case V4L2_BUF_TYPE_SLICED_VBI_CAPTURE:
1081 if (vfd->vidioc_try_fmt_sliced_vbi_cap)
1082 ret = vfd->vidioc_try_fmt_sliced_vbi_cap(file,
1085 case V4L2_BUF_TYPE_SLICED_VBI_OUTPUT:
1086 if (vfd->vidioc_try_fmt_sliced_vbi_out)
1087 ret = vfd->vidioc_try_fmt_sliced_vbi_out(file,
1090 case V4L2_BUF_TYPE_PRIVATE:
1091 if (vfd->vidioc_try_fmt_type_private)
1092 ret = vfd->vidioc_try_fmt_type_private(file,
1099 /* FIXME: Those buf reqs could be handled here,
1100 with some changes on videobuf to allow its header to be included at
1101 videodev2.h or being merged at videodev2.
1103 case VIDIOC_REQBUFS:
1105 struct v4l2_requestbuffers *p=arg;
1107 if (!vfd->vidioc_reqbufs)
1109 ret = check_fmt (vfd, p->type);
1113 ret=vfd->vidioc_reqbufs(file, fh, p);
1114 dbgarg (cmd, "count=%d, type=%s, memory=%s\n",
1116 prt_names(p->type, v4l2_type_names),
1117 prt_names(p->memory, v4l2_memory_names));
1120 case VIDIOC_QUERYBUF:
1122 struct v4l2_buffer *p=arg;
1124 if (!vfd->vidioc_querybuf)
1126 ret = check_fmt (vfd, p->type);
1130 ret=vfd->vidioc_querybuf(file, fh, p);
1137 struct v4l2_buffer *p=arg;
1139 if (!vfd->vidioc_qbuf)
1141 ret = check_fmt (vfd, p->type);
1145 ret=vfd->vidioc_qbuf(file, fh, p);
1152 struct v4l2_buffer *p=arg;
1153 if (!vfd->vidioc_dqbuf)
1155 ret = check_fmt (vfd, p->type);
1159 ret=vfd->vidioc_dqbuf(file, fh, p);
1164 case VIDIOC_OVERLAY:
1168 if (!vfd->vidioc_overlay)
1170 dbgarg (cmd, "value=%d\n",*i);
1171 ret=vfd->vidioc_overlay(file, fh, *i);
1176 struct v4l2_framebuffer *p = arg;
1178 if (!vfd->vidioc_g_fbuf)
1180 ret = vfd->vidioc_g_fbuf(file, fh, arg);
1182 dbgarg(cmd, "capability=0x%x, flags=%d, base=0x%08lx\n",
1183 p->capability, p->flags,
1184 (unsigned long)p->base);
1185 v4l_print_pix_fmt(vfd, &p->fmt);
1191 struct v4l2_framebuffer *p = arg;
1193 if (!vfd->vidioc_s_fbuf)
1195 dbgarg(cmd, "capability=0x%x, flags=%d, base=0x%08lx\n",
1196 p->capability, p->flags, (unsigned long)p->base);
1197 v4l_print_pix_fmt(vfd, &p->fmt);
1198 ret = vfd->vidioc_s_fbuf(file, fh, arg);
1201 case VIDIOC_STREAMON:
1203 enum v4l2_buf_type i = *(int *)arg;
1204 if (!vfd->vidioc_streamon)
1206 dbgarg(cmd, "type=%s\n", prt_names(i, v4l2_type_names));
1207 ret=vfd->vidioc_streamon(file, fh,i);
1210 case VIDIOC_STREAMOFF:
1212 enum v4l2_buf_type i = *(int *)arg;
1214 if (!vfd->vidioc_streamoff)
1216 dbgarg(cmd, "type=%s\n", prt_names(i, v4l2_type_names));
1217 ret=vfd->vidioc_streamoff(file, fh, i);
1220 /* ---------- tv norms ---------- */
1221 case VIDIOC_ENUMSTD:
1223 struct v4l2_standard *p = arg;
1224 v4l2_std_id id = vfd->tvnorms, curr_id = 0;
1225 unsigned int index = p->index, i, j = 0;
1226 const char *descr = "";
1228 /* Return norm array in a canonical way */
1229 for (i = 0; i <= index && id; i++) {
1230 /* last std value in the standards array is 0, so this
1231 while always ends there since (id & 0) == 0. */
1232 while ((id & standards[j].std) != standards[j].std)
1234 curr_id = standards[j].std;
1235 descr = standards[j].descr;
1239 if (curr_id != V4L2_STD_PAL &&
1240 curr_id != V4L2_STD_SECAM &&
1241 curr_id != V4L2_STD_NTSC)
1247 v4l2_video_std_construct(p, curr_id, descr);
1250 dbgarg(cmd, "index=%d, id=0x%Lx, name=%s, fps=%d/%d, "
1251 "framelines=%d\n", p->index,
1252 (unsigned long long)p->id, p->name,
1253 p->frameperiod.numerator,
1254 p->frameperiod.denominator,
1262 v4l2_std_id *id = arg;
1265 /* Calls the specific handler */
1266 if (vfd->vidioc_g_std)
1267 ret = vfd->vidioc_g_std(file, fh, id);
1269 *id = vfd->current_norm;
1272 dbgarg(cmd, "std=0x%08Lx\n", (long long unsigned)*id);
1277 v4l2_std_id *id = arg,norm;
1279 dbgarg(cmd, "std=%08Lx\n", (long long unsigned)*id);
1281 norm = (*id) & vfd->tvnorms;
1282 if ( vfd->tvnorms && !norm) /* Check if std is supported */
1285 /* Calls the specific handler */
1286 if (vfd->vidioc_s_std)
1287 ret=vfd->vidioc_s_std(file, fh, &norm);
1291 /* Updates standard information */
1293 vfd->current_norm=norm;
1297 case VIDIOC_QUERYSTD:
1301 if (!vfd->vidioc_querystd)
1303 ret=vfd->vidioc_querystd(file, fh, arg);
1305 dbgarg (cmd, "detected std=%08Lx\n",
1306 (unsigned long long)*p);
1309 /* ------ input switching ---------- */
1310 /* FIXME: Inputs can be handled inside videodev2 */
1311 case VIDIOC_ENUMINPUT:
1313 struct v4l2_input *p=arg;
1316 if (!vfd->vidioc_enum_input)
1318 memset(p, 0, sizeof(*p));
1321 ret=vfd->vidioc_enum_input(file, fh, p);
1323 dbgarg (cmd, "index=%d, name=%s, type=%d, "
1325 "tuner=%d, std=%08Lx, status=%d\n",
1326 p->index,p->name,p->type,p->audioset,
1328 (unsigned long long)p->std,
1332 case VIDIOC_G_INPUT:
1334 unsigned int *i = arg;
1336 if (!vfd->vidioc_g_input)
1338 ret=vfd->vidioc_g_input(file, fh, i);
1340 dbgarg (cmd, "value=%d\n",*i);
1343 case VIDIOC_S_INPUT:
1345 unsigned int *i = arg;
1347 if (!vfd->vidioc_s_input)
1349 dbgarg (cmd, "value=%d\n",*i);
1350 ret=vfd->vidioc_s_input(file, fh, *i);
1354 /* ------ output switching ---------- */
1355 case VIDIOC_ENUMOUTPUT:
1357 struct v4l2_output *p = arg;
1360 if (!vfd->vidioc_enum_output)
1362 memset(p, 0, sizeof(*p));
1365 ret = vfd->vidioc_enum_output(file, fh, p);
1367 dbgarg(cmd, "index=%d, name=%s, type=%d, "
1369 "modulator=%d, std=0x%08Lx\n",
1370 p->index, p->name, p->type, p->audioset,
1371 p->modulator, (unsigned long long)p->std);
1374 case VIDIOC_G_OUTPUT:
1376 unsigned int *i = arg;
1378 if (!vfd->vidioc_g_output)
1380 ret=vfd->vidioc_g_output(file, fh, i);
1382 dbgarg (cmd, "value=%d\n",*i);
1385 case VIDIOC_S_OUTPUT:
1387 unsigned int *i = arg;
1389 if (!vfd->vidioc_s_output)
1391 dbgarg (cmd, "value=%d\n",*i);
1392 ret=vfd->vidioc_s_output(file, fh, *i);
1396 /* --- controls ---------------------------------------------- */
1397 case VIDIOC_QUERYCTRL:
1399 struct v4l2_queryctrl *p = arg;
1401 if (!vfd->vidioc_queryctrl)
1403 ret = vfd->vidioc_queryctrl(file, fh, p);
1405 dbgarg(cmd, "id=0x%x, type=%d, name=%s, min/max=%d/%d, "
1406 "step=%d, default=%d, flags=0x%08x\n",
1407 p->id, p->type, p->name,
1408 p->minimum, p->maximum,
1409 p->step, p->default_value, p->flags);
1411 dbgarg(cmd, "id=0x%x\n", p->id);
1416 struct v4l2_control *p = arg;
1418 if (vfd->vidioc_g_ctrl)
1419 ret = vfd->vidioc_g_ctrl(file, fh, p);
1420 else if (vfd->vidioc_g_ext_ctrls) {
1421 struct v4l2_ext_controls ctrls;
1422 struct v4l2_ext_control ctrl;
1424 ctrls.ctrl_class = V4L2_CTRL_ID2CLASS(p->id);
1426 ctrls.controls = &ctrl;
1428 ctrl.value = p->value;
1429 if (check_ext_ctrls(&ctrls)) {
1430 ret = vfd->vidioc_g_ext_ctrls(file, fh, &ctrls);
1432 p->value = ctrl.value;
1437 dbgarg(cmd, "id=0x%x, value=%d\n", p->id, p->value);
1439 dbgarg(cmd, "id=0x%x\n", p->id);
1444 struct v4l2_control *p = arg;
1445 struct v4l2_ext_controls ctrls;
1446 struct v4l2_ext_control ctrl;
1448 if (!vfd->vidioc_s_ctrl && !vfd->vidioc_s_ext_ctrls)
1451 dbgarg(cmd, "id=0x%x, value=%d\n", p->id, p->value);
1453 if (vfd->vidioc_s_ctrl) {
1454 ret = vfd->vidioc_s_ctrl(file, fh, p);
1457 if (!vfd->vidioc_s_ext_ctrls)
1460 ctrls.ctrl_class = V4L2_CTRL_ID2CLASS(p->id);
1462 ctrls.controls = &ctrl;
1464 ctrl.value = p->value;
1465 if (check_ext_ctrls(&ctrls))
1466 ret = vfd->vidioc_s_ext_ctrls(file, fh, &ctrls);
1469 case VIDIOC_G_EXT_CTRLS:
1471 struct v4l2_ext_controls *p = arg;
1473 p->error_idx = p->count;
1474 if (!vfd->vidioc_g_ext_ctrls)
1476 if (check_ext_ctrls(p))
1477 ret = vfd->vidioc_g_ext_ctrls(file, fh, p);
1478 v4l_print_ext_ctrls(cmd, vfd, p, !ret);
1481 case VIDIOC_S_EXT_CTRLS:
1483 struct v4l2_ext_controls *p = arg;
1485 p->error_idx = p->count;
1486 if (!vfd->vidioc_s_ext_ctrls)
1488 v4l_print_ext_ctrls(cmd, vfd, p, 1);
1489 if (check_ext_ctrls(p))
1490 ret = vfd->vidioc_s_ext_ctrls(file, fh, p);
1493 case VIDIOC_TRY_EXT_CTRLS:
1495 struct v4l2_ext_controls *p = arg;
1497 p->error_idx = p->count;
1498 if (!vfd->vidioc_try_ext_ctrls)
1500 v4l_print_ext_ctrls(cmd, vfd, p, 1);
1501 if (check_ext_ctrls(p))
1502 ret = vfd->vidioc_try_ext_ctrls(file, fh, p);
1505 case VIDIOC_QUERYMENU:
1507 struct v4l2_querymenu *p = arg;
1509 if (!vfd->vidioc_querymenu)
1511 ret = vfd->vidioc_querymenu(file, fh, p);
1513 dbgarg(cmd, "id=0x%x, index=%d, name=%s\n",
1514 p->id, p->index, p->name);
1516 dbgarg(cmd, "id=0x%x, index=%d\n",
1520 /* --- audio ---------------------------------------------- */
1521 case VIDIOC_ENUMAUDIO:
1523 struct v4l2_audio *p = arg;
1525 if (!vfd->vidioc_enumaudio)
1527 ret = vfd->vidioc_enumaudio(file, fh, p);
1529 dbgarg(cmd, "index=%d, name=%s, capability=0x%x, "
1530 "mode=0x%x\n", p->index, p->name,
1531 p->capability, p->mode);
1533 dbgarg(cmd, "index=%d\n", p->index);
1536 case VIDIOC_G_AUDIO:
1538 struct v4l2_audio *p = arg;
1539 __u32 index = p->index;
1541 if (!vfd->vidioc_g_audio)
1544 memset(p, 0, sizeof(*p));
1546 ret = vfd->vidioc_g_audio(file, fh, p);
1548 dbgarg(cmd, "index=%d, name=%s, capability=0x%x, "
1549 "mode=0x%x\n", p->index,
1550 p->name, p->capability, p->mode);
1552 dbgarg(cmd, "index=%d\n", p->index);
1555 case VIDIOC_S_AUDIO:
1557 struct v4l2_audio *p = arg;
1559 if (!vfd->vidioc_s_audio)
1561 dbgarg(cmd, "index=%d, name=%s, capability=0x%x, "
1562 "mode=0x%x\n", p->index, p->name,
1563 p->capability, p->mode);
1564 ret = vfd->vidioc_s_audio(file, fh, p);
1567 case VIDIOC_ENUMAUDOUT:
1569 struct v4l2_audioout *p=arg;
1571 if (!vfd->vidioc_enumaudout)
1573 dbgarg(cmd, "Enum for index=%d\n", p->index);
1574 ret=vfd->vidioc_enumaudout(file, fh, p);
1576 dbgarg2("index=%d, name=%s, capability=%d, "
1577 "mode=%d\n", p->index, p->name,
1578 p->capability,p->mode);
1581 case VIDIOC_G_AUDOUT:
1583 struct v4l2_audioout *p=arg;
1585 if (!vfd->vidioc_g_audout)
1587 dbgarg(cmd, "Enum for index=%d\n", p->index);
1588 ret=vfd->vidioc_g_audout(file, fh, p);
1590 dbgarg2("index=%d, name=%s, capability=%d, "
1591 "mode=%d\n", p->index, p->name,
1592 p->capability,p->mode);
1595 case VIDIOC_S_AUDOUT:
1597 struct v4l2_audioout *p=arg;
1599 if (!vfd->vidioc_s_audout)
1601 dbgarg(cmd, "index=%d, name=%s, capability=%d, "
1602 "mode=%d\n", p->index, p->name,
1603 p->capability,p->mode);
1605 ret=vfd->vidioc_s_audout(file, fh, p);
1608 case VIDIOC_G_MODULATOR:
1610 struct v4l2_modulator *p=arg;
1611 if (!vfd->vidioc_g_modulator)
1613 ret=vfd->vidioc_g_modulator(file, fh, p);
1615 dbgarg(cmd, "index=%d, name=%s, "
1616 "capability=%d, rangelow=%d,"
1617 " rangehigh=%d, txsubchans=%d\n",
1618 p->index, p->name,p->capability,
1619 p->rangelow, p->rangehigh,
1623 case VIDIOC_S_MODULATOR:
1625 struct v4l2_modulator *p=arg;
1626 if (!vfd->vidioc_s_modulator)
1628 dbgarg(cmd, "index=%d, name=%s, capability=%d, "
1629 "rangelow=%d, rangehigh=%d, txsubchans=%d\n",
1630 p->index, p->name,p->capability,p->rangelow,
1631 p->rangehigh,p->txsubchans);
1632 ret=vfd->vidioc_s_modulator(file, fh, p);
1637 struct v4l2_crop *p=arg;
1638 if (!vfd->vidioc_g_crop)
1640 dbgarg(cmd, "type=%s\n", prt_names(p->type, v4l2_type_names));
1641 ret=vfd->vidioc_g_crop(file, fh, p);
1643 dbgrect(vfd, "", &p->c);
1649 struct v4l2_crop *p=arg;
1650 if (!vfd->vidioc_s_crop)
1652 dbgarg(cmd, "type=%s\n", prt_names(p->type, v4l2_type_names));
1653 dbgrect(vfd, "", &p->c);
1654 ret=vfd->vidioc_s_crop(file, fh, p);
1657 case VIDIOC_CROPCAP:
1659 struct v4l2_cropcap *p = arg;
1661 /*FIXME: Should also show v4l2_fract pixelaspect */
1662 if (!vfd->vidioc_cropcap)
1664 dbgarg(cmd, "type=%s\n", prt_names(p->type, v4l2_type_names));
1665 ret = vfd->vidioc_cropcap(file, fh, p);
1667 dbgrect(vfd, "bounds ", &p->bounds);
1668 dbgrect(vfd, "defrect ", &p->defrect);
1672 case VIDIOC_G_JPEGCOMP:
1674 struct v4l2_jpegcompression *p=arg;
1675 if (!vfd->vidioc_g_jpegcomp)
1677 ret=vfd->vidioc_g_jpegcomp(file, fh, p);
1679 dbgarg (cmd, "quality=%d, APPn=%d, "
1680 "APP_len=%d, COM_len=%d, "
1681 "jpeg_markers=%d\n",
1682 p->quality,p->APPn,p->APP_len,
1683 p->COM_len,p->jpeg_markers);
1686 case VIDIOC_S_JPEGCOMP:
1688 struct v4l2_jpegcompression *p=arg;
1689 if (!vfd->vidioc_g_jpegcomp)
1691 dbgarg (cmd, "quality=%d, APPn=%d, APP_len=%d, "
1692 "COM_len=%d, jpeg_markers=%d\n",
1693 p->quality,p->APPn,p->APP_len,
1694 p->COM_len,p->jpeg_markers);
1695 ret=vfd->vidioc_s_jpegcomp(file, fh, p);
1698 case VIDIOC_G_ENC_INDEX:
1700 struct v4l2_enc_idx *p=arg;
1702 if (!vfd->vidioc_g_enc_index)
1704 ret=vfd->vidioc_g_enc_index(file, fh, p);
1706 dbgarg (cmd, "entries=%d, entries_cap=%d\n",
1707 p->entries,p->entries_cap);
1710 case VIDIOC_ENCODER_CMD:
1712 struct v4l2_encoder_cmd *p = arg;
1714 if (!vfd->vidioc_encoder_cmd)
1716 memset(&p->raw, 0, sizeof(p->raw));
1717 ret = vfd->vidioc_encoder_cmd(file, fh, p);
1719 dbgarg(cmd, "cmd=%d, flags=%x\n", p->cmd, p->flags);
1722 case VIDIOC_TRY_ENCODER_CMD:
1724 struct v4l2_encoder_cmd *p = arg;
1726 if (!vfd->vidioc_try_encoder_cmd)
1728 memset(&p->raw, 0, sizeof(p->raw));
1729 ret = vfd->vidioc_try_encoder_cmd(file, fh, p);
1731 dbgarg(cmd, "cmd=%d, flags=%x\n", p->cmd, p->flags);
1736 struct v4l2_streamparm *p=arg;
1739 memset(p,0,sizeof(*p));
1742 if (vfd->vidioc_g_parm) {
1743 ret=vfd->vidioc_g_parm(file, fh, p);
1745 struct v4l2_standard s;
1747 if (p->type != V4L2_BUF_TYPE_VIDEO_CAPTURE)
1750 v4l2_video_std_construct(&s, vfd->current_norm,
1751 v4l2_norm_to_name(vfd->current_norm));
1753 p->parm.capture.timeperframe = s.frameperiod;
1757 dbgarg (cmd, "type=%d\n", p->type);
1762 struct v4l2_streamparm *p=arg;
1763 if (!vfd->vidioc_s_parm)
1765 dbgarg (cmd, "type=%d\n", p->type);
1766 ret=vfd->vidioc_s_parm(file, fh, p);
1769 case VIDIOC_G_TUNER:
1771 struct v4l2_tuner *p = arg;
1772 __u32 index = p->index;
1774 if (!vfd->vidioc_g_tuner)
1777 memset(p, 0, sizeof(*p));
1780 ret = vfd->vidioc_g_tuner(file, fh, p);
1782 dbgarg(cmd, "index=%d, name=%s, type=%d, "
1783 "capability=0x%x, rangelow=%d, "
1784 "rangehigh=%d, signal=%d, afc=%d, "
1785 "rxsubchans=0x%x, audmode=%d\n",
1786 p->index, p->name, p->type,
1787 p->capability, p->rangelow,
1788 p->rangehigh, p->signal, p->afc,
1789 p->rxsubchans, p->audmode);
1792 case VIDIOC_S_TUNER:
1794 struct v4l2_tuner *p = arg;
1796 if (!vfd->vidioc_s_tuner)
1798 dbgarg(cmd, "index=%d, name=%s, type=%d, "
1799 "capability=0x%x, rangelow=%d, "
1800 "rangehigh=%d, signal=%d, afc=%d, "
1801 "rxsubchans=0x%x, audmode=%d\n",
1802 p->index, p->name, p->type,
1803 p->capability, p->rangelow,
1804 p->rangehigh, p->signal, p->afc,
1805 p->rxsubchans, p->audmode);
1806 ret = vfd->vidioc_s_tuner(file, fh, p);
1809 case VIDIOC_G_FREQUENCY:
1811 struct v4l2_frequency *p = arg;
1813 if (!vfd->vidioc_g_frequency)
1816 memset(p->reserved, 0, sizeof(p->reserved));
1818 ret = vfd->vidioc_g_frequency(file, fh, p);
1820 dbgarg(cmd, "tuner=%d, type=%d, frequency=%d\n",
1821 p->tuner, p->type, p->frequency);
1824 case VIDIOC_S_FREQUENCY:
1826 struct v4l2_frequency *p=arg;
1827 if (!vfd->vidioc_s_frequency)
1829 dbgarg (cmd, "tuner=%d, type=%d, frequency=%d\n",
1830 p->tuner,p->type,p->frequency);
1831 ret=vfd->vidioc_s_frequency(file, fh, p);
1834 case VIDIOC_G_SLICED_VBI_CAP:
1836 struct v4l2_sliced_vbi_cap *p = arg;
1837 __u32 type = p->type;
1839 if (!vfd->vidioc_g_sliced_vbi_cap)
1841 memset(p, 0, sizeof(*p));
1843 dbgarg(cmd, "type=%s\n", prt_names(p->type, v4l2_type_names));
1844 ret = vfd->vidioc_g_sliced_vbi_cap(file, fh, p);
1846 dbgarg2("service_set=%d\n", p->service_set);
1849 case VIDIOC_LOG_STATUS:
1851 if (!vfd->vidioc_log_status)
1853 ret=vfd->vidioc_log_status(file, fh);
1856 #ifdef CONFIG_VIDEO_ADV_DEBUG
1857 case VIDIOC_DBG_G_REGISTER:
1859 struct v4l2_register *p=arg;
1860 if (!capable(CAP_SYS_ADMIN))
1862 else if (vfd->vidioc_g_register)
1863 ret=vfd->vidioc_g_register(file, fh, p);
1866 case VIDIOC_DBG_S_REGISTER:
1868 struct v4l2_register *p=arg;
1869 if (!capable(CAP_SYS_ADMIN))
1871 else if (vfd->vidioc_s_register)
1872 ret=vfd->vidioc_s_register(file, fh, p);
1876 case VIDIOC_G_CHIP_IDENT:
1878 struct v4l2_chip_ident *p=arg;
1879 if (!vfd->vidioc_g_chip_ident)
1881 ret=vfd->vidioc_g_chip_ident(file, fh, p);
1883 dbgarg (cmd, "chip_ident=%u, revision=0x%x\n", p->ident, p->revision);
1888 if (!vfd->vidioc_default)
1890 ret = vfd->vidioc_default(file, fh, cmd, arg);
1893 case VIDIOC_S_HW_FREQ_SEEK:
1895 struct v4l2_hw_freq_seek *p = arg;
1896 if (!vfd->vidioc_s_hw_freq_seek)
1899 "tuner=%d, type=%d, seek_upward=%d, wrap_around=%d\n",
1900 p->tuner, p->type, p->seek_upward, p->wrap_around);
1901 ret = vfd->vidioc_s_hw_freq_seek(file, fh, p);
1906 if (vfd->debug & V4L2_DEBUG_IOCTL_ARG) {
1908 v4l_print_ioctl(vfd->name, cmd);
1909 printk(KERN_CONT " error %d\n", ret);
1916 int video_ioctl2 (struct inode *inode, struct file *file,
1917 unsigned int cmd, unsigned long arg)
1924 size_t ctrls_size = 0;
1925 void __user *user_ptr = NULL;
1927 #ifdef __OLD_VIDIOC_
1928 cmd = video_fix_command(cmd);
1930 is_ext_ctrl = (cmd == VIDIOC_S_EXT_CTRLS || cmd == VIDIOC_G_EXT_CTRLS ||
1931 cmd == VIDIOC_TRY_EXT_CTRLS);
1933 /* Copy arguments into temp kernel buffer */
1934 switch (_IOC_DIR(cmd)) {
1940 case (_IOC_WRITE | _IOC_READ):
1941 if (_IOC_SIZE(cmd) <= sizeof(sbuf)) {
1944 /* too big to allocate from stack */
1945 mbuf = kmalloc(_IOC_SIZE(cmd),GFP_KERNEL);
1952 if (_IOC_DIR(cmd) & _IOC_WRITE)
1953 if (copy_from_user(parg, (void __user *)arg, _IOC_SIZE(cmd)))
1959 struct v4l2_ext_controls *p = parg;
1961 /* In case of an error, tell the caller that it wasn't
1962 a specific control that caused it. */
1963 p->error_idx = p->count;
1964 user_ptr = (void __user *)p->controls;
1966 ctrls_size = sizeof(struct v4l2_ext_control) * p->count;
1967 /* Note: v4l2_ext_controls fits in sbuf[] so mbuf is still NULL. */
1968 mbuf = kmalloc(ctrls_size, GFP_KERNEL);
1973 if (copy_from_user(mbuf, user_ptr, ctrls_size))
1980 err = __video_do_ioctl(inode, file, cmd, parg);
1981 if (err == -ENOIOCTLCMD)
1984 struct v4l2_ext_controls *p = parg;
1986 p->controls = (void *)user_ptr;
1987 if (p->count && err == 0 && copy_to_user(user_ptr, mbuf, ctrls_size))
1995 /* Copy results into user buffer */
1996 switch (_IOC_DIR(cmd))
1999 case (_IOC_WRITE | _IOC_READ):
2000 if (copy_to_user((void __user *)arg, parg, _IOC_SIZE(cmd)))
2009 EXPORT_SYMBOL(video_ioctl2);
2013 unsigned int used[VIDEO_NUM_DEVICES];
2016 static int __fill_index_info(struct device *cd, void *data)
2018 struct index_info *info = data;
2019 struct video_device *vfd = container_of(cd, struct video_device,
2022 if (info->dev == vfd->dev)
2023 info->used[vfd->index] = 1;
2029 * assign_index - assign stream number based on parent device
2030 * @vdev: video_device to assign index number to, vdev->dev should be assigned
2031 * @num: -1 if auto assign, requested number otherwise
2034 * returns -ENFILE if num is already in use, a free index number if
2037 static int get_index(struct video_device *vdev, int num)
2039 struct index_info *info;
2043 if (num >= VIDEO_NUM_DEVICES)
2046 info = kzalloc(sizeof(*info), GFP_KERNEL);
2050 info->dev = vdev->dev;
2052 ret = class_for_each_device(&video_class, info,
2059 if (!info->used[num])
2067 for (i = 0; i < VIDEO_NUM_DEVICES; i++) {
2079 static const struct file_operations video_fops;
2081 int video_register_device(struct video_device *vfd, int type, int nr)
2083 return video_register_device_index(vfd, type, nr, -1);
2085 EXPORT_SYMBOL(video_register_device);
2088 * video_register_device - register video4linux devices
2089 * @vfd: video device structure we want to register
2090 * @type: type of device to register
2091 * @nr: which device number (0 == /dev/video0, 1 == /dev/video1, ...
2094 * The registration code assigns minor numbers based on the type
2095 * requested. -ENFILE is returned in all the device slots for this
2096 * category are full. If not then the minor field is set and the
2097 * driver initialize function is called (if non %NULL).
2099 * Zero is returned on success.
2103 * %VFL_TYPE_GRABBER - A frame grabber
2105 * %VFL_TYPE_VTX - A teletext device
2107 * %VFL_TYPE_VBI - Vertical blank data (undecoded)
2109 * %VFL_TYPE_RADIO - A radio card
2112 int video_register_device_index(struct video_device *vfd, int type, int nr,
2123 case VFL_TYPE_GRABBER:
2124 base=MINOR_VFL_TYPE_GRABBER_MIN;
2125 end=MINOR_VFL_TYPE_GRABBER_MAX+1;
2126 name_base = "video";
2129 base=MINOR_VFL_TYPE_VTX_MIN;
2130 end=MINOR_VFL_TYPE_VTX_MAX+1;
2134 base=MINOR_VFL_TYPE_VBI_MIN;
2135 end=MINOR_VFL_TYPE_VBI_MAX+1;
2138 case VFL_TYPE_RADIO:
2139 base=MINOR_VFL_TYPE_RADIO_MIN;
2140 end=MINOR_VFL_TYPE_RADIO_MAX+1;
2141 name_base = "radio";
2144 printk(KERN_ERR "%s called with unknown type: %d\n",
2149 /* pick a minor number */
2150 mutex_lock(&videodev_lock);
2151 if (nr >= 0 && nr < end-base) {
2152 /* use the one the driver asked for */
2154 if (NULL != video_device[i]) {
2155 mutex_unlock(&videodev_lock);
2159 /* use first free */
2160 for(i=base;i<end;i++)
2161 if (NULL == video_device[i])
2164 mutex_unlock(&videodev_lock);
2168 video_device[i]=vfd;
2171 ret = get_index(vfd, index);
2173 printk(KERN_ERR "%s: get_index failed\n",
2180 mutex_unlock(&videodev_lock);
2181 mutex_init(&vfd->lock);
2184 memset(&vfd->class_dev, 0x00, sizeof(vfd->class_dev));
2186 vfd->class_dev.parent = vfd->dev;
2187 vfd->class_dev.class = &video_class;
2188 vfd->class_dev.devt = MKDEV(VIDEO_MAJOR, vfd->minor);
2189 sprintf(vfd->class_dev.bus_id, "%s%d", name_base, i - base);
2190 ret = device_register(&vfd->class_dev);
2192 printk(KERN_ERR "%s: device_register failed\n",
2198 /* needed until all drivers are fixed */
2200 printk(KERN_WARNING "videodev: \"%s\" has no release callback. "
2201 "Please fix your driver for proper sysfs support, see "
2202 "http://lwn.net/Articles/36850/\n", vfd->name);
2207 mutex_lock(&videodev_lock);
2208 video_device[vfd->minor] = NULL;
2210 mutex_unlock(&videodev_lock);
2213 EXPORT_SYMBOL(video_register_device_index);
2216 * video_unregister_device - unregister a video4linux device
2217 * @vfd: the device to unregister
2219 * This unregisters the passed device and deassigns the minor
2220 * number. Future open calls will be met with errors.
2223 void video_unregister_device(struct video_device *vfd)
2225 mutex_lock(&videodev_lock);
2226 if(video_device[vfd->minor]!=vfd)
2227 panic("videodev: bad unregister");
2229 video_device[vfd->minor]=NULL;
2230 device_unregister(&vfd->class_dev);
2231 mutex_unlock(&videodev_lock);
2233 EXPORT_SYMBOL(video_unregister_device);
2236 * Video fs operations
2238 static const struct file_operations video_fops=
2240 .owner = THIS_MODULE,
2241 .llseek = no_llseek,
2246 * Initialise video for linux
2249 static int __init videodev_init(void)
2253 printk(KERN_INFO "Linux video capture interface: v2.00\n");
2254 if (register_chrdev(VIDEO_MAJOR, VIDEO_NAME, &video_fops)) {
2255 printk(KERN_WARNING "video_dev: unable to get major %d\n", VIDEO_MAJOR);
2259 ret = class_register(&video_class);
2261 unregister_chrdev(VIDEO_MAJOR, VIDEO_NAME);
2262 printk(KERN_WARNING "video_dev: class_register failed\n");
2269 static void __exit videodev_exit(void)
2271 class_unregister(&video_class);
2272 unregister_chrdev(VIDEO_MAJOR, VIDEO_NAME);
2275 module_init(videodev_init)
2276 module_exit(videodev_exit)
2278 MODULE_AUTHOR("Alan Cox, Mauro Carvalho Chehab <mchehab@infradead.org>");
2279 MODULE_DESCRIPTION("Device registrar for Video4Linux drivers v2");
2280 MODULE_LICENSE("GPL");