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...) \
20 if (vfd->debug & V4L2_DEBUG_IOCTL_ARG) { \
21 printk(KERN_DEBUG "%s: ", vfd->name); \
22 v4l_printk_ioctl(cmd); \
23 printk(" " fmt, ## arg); \
26 #define dbgarg2(fmt, arg...) \
27 if (vfd->debug & V4L2_DEBUG_IOCTL_ARG) \
28 printk(KERN_DEBUG "%s: " fmt, vfd->name, ## arg);
30 #include <linux/module.h>
31 #include <linux/types.h>
32 #include <linux/kernel.h>
34 #include <linux/string.h>
35 #include <linux/errno.h>
36 #include <linux/init.h>
37 #include <linux/kmod.h>
38 #include <linux/slab.h>
39 #include <linux/smp_lock.h>
40 #include <asm/uaccess.h>
41 #include <asm/system.h>
43 #define __OLD_VIDIOC_ /* To allow fixing old calls*/
44 #include <linux/videodev2.h>
46 #ifdef CONFIG_VIDEO_V4L1
47 #include <linux/videodev.h>
49 #include <media/v4l2-common.h>
50 #include <linux/video_decoder.h>
52 #define VIDEO_NUM_DEVICES 256
53 #define VIDEO_NAME "video4linux"
60 static const struct std_descr standards[] = {
61 { V4L2_STD_NTSC, "NTSC" },
62 { V4L2_STD_NTSC_M, "NTSC-M" },
63 { V4L2_STD_NTSC_M_JP, "NTSC-M-JP" },
64 { V4L2_STD_NTSC_M_KR, "NTSC-M-KR" },
65 { V4L2_STD_NTSC_443, "NTSC-443" },
66 { V4L2_STD_PAL, "PAL" },
67 { V4L2_STD_PAL_BG, "PAL-BG" },
68 { V4L2_STD_PAL_B, "PAL-B" },
69 { V4L2_STD_PAL_B1, "PAL-B1" },
70 { V4L2_STD_PAL_G, "PAL-G" },
71 { V4L2_STD_PAL_H, "PAL-H" },
72 { V4L2_STD_PAL_I, "PAL-I" },
73 { V4L2_STD_PAL_DK, "PAL-DK" },
74 { V4L2_STD_PAL_D, "PAL-D" },
75 { V4L2_STD_PAL_D1, "PAL-D1" },
76 { V4L2_STD_PAL_K, "PAL-K" },
77 { V4L2_STD_PAL_M, "PAL-M" },
78 { V4L2_STD_PAL_N, "PAL-N" },
79 { V4L2_STD_PAL_Nc, "PAL-Nc" },
80 { V4L2_STD_PAL_60, "PAL-60" },
81 { V4L2_STD_SECAM, "SECAM" },
82 { V4L2_STD_SECAM_B, "SECAM-B" },
83 { V4L2_STD_SECAM_G, "SECAM-G" },
84 { V4L2_STD_SECAM_H, "SECAM-H" },
85 { V4L2_STD_SECAM_DK, "SECAM-DK" },
86 { V4L2_STD_SECAM_D, "SECAM-D" },
87 { V4L2_STD_SECAM_K, "SECAM-K" },
88 { V4L2_STD_SECAM_K1, "SECAM-K1" },
89 { V4L2_STD_SECAM_L, "SECAM-L" },
90 { V4L2_STD_SECAM_LC, "SECAM-Lc" },
94 /* video4linux standard ID conversion to standard name
96 const char *v4l2_norm_to_name(v4l2_std_id id)
101 /* HACK: ppc32 architecture doesn't have __ucmpdi2 function to handle
102 64 bit comparations. So, on that architecture, with some gcc
103 variants, compilation fails. Currently, the max value is 30bit wide.
107 for (i = 0; standards[i].std; i++)
108 if (myid == standards[i].std)
110 return standards[i].descr;
112 EXPORT_SYMBOL(v4l2_norm_to_name);
114 /* Fill in the fields of a v4l2_standard structure according to the
115 'id' and 'transmission' parameters. Returns negative on error. */
116 int v4l2_video_std_construct(struct v4l2_standard *vs,
117 int id, const char *name)
119 u32 index = vs->index;
121 memset(vs, 0, sizeof(struct v4l2_standard));
124 if (id & V4L2_STD_525_60) {
125 vs->frameperiod.numerator = 1001;
126 vs->frameperiod.denominator = 30000;
127 vs->framelines = 525;
129 vs->frameperiod.numerator = 1;
130 vs->frameperiod.denominator = 25;
131 vs->framelines = 625;
133 strlcpy(vs->name, name, sizeof(vs->name));
136 EXPORT_SYMBOL(v4l2_video_std_construct);
138 /* ----------------------------------------------------------------- */
139 /* some arrays for pretty-printing debug messages of enum types */
141 char *v4l2_field_names[] = {
142 [V4L2_FIELD_ANY] = "any",
143 [V4L2_FIELD_NONE] = "none",
144 [V4L2_FIELD_TOP] = "top",
145 [V4L2_FIELD_BOTTOM] = "bottom",
146 [V4L2_FIELD_INTERLACED] = "interlaced",
147 [V4L2_FIELD_SEQ_TB] = "seq-tb",
148 [V4L2_FIELD_SEQ_BT] = "seq-bt",
149 [V4L2_FIELD_ALTERNATE] = "alternate",
150 [V4L2_FIELD_INTERLACED_TB] = "interlaced-tb",
151 [V4L2_FIELD_INTERLACED_BT] = "interlaced-bt",
153 EXPORT_SYMBOL(v4l2_field_names);
155 char *v4l2_type_names[] = {
156 [V4L2_BUF_TYPE_VIDEO_CAPTURE] = "video-cap",
157 [V4L2_BUF_TYPE_VIDEO_OVERLAY] = "video-over",
158 [V4L2_BUF_TYPE_VIDEO_OUTPUT] = "video-out",
159 [V4L2_BUF_TYPE_VBI_CAPTURE] = "vbi-cap",
160 [V4L2_BUF_TYPE_VBI_OUTPUT] = "vbi-out",
161 [V4L2_BUF_TYPE_SLICED_VBI_CAPTURE] = "sliced-vbi-cap",
162 [V4L2_BUF_TYPE_SLICED_VBI_OUTPUT] = "sliced-vbi-out",
163 [V4L2_BUF_TYPE_VIDEO_OUTPUT_OVERLAY] = "video-out-over",
165 EXPORT_SYMBOL(v4l2_type_names);
167 static char *v4l2_memory_names[] = {
168 [V4L2_MEMORY_MMAP] = "mmap",
169 [V4L2_MEMORY_USERPTR] = "userptr",
170 [V4L2_MEMORY_OVERLAY] = "overlay",
173 #define prt_names(a, arr) ((((a) >= 0) && ((a) < ARRAY_SIZE(arr))) ? \
176 /* ------------------------------------------------------------------ */
177 /* debug help functions */
179 #ifdef CONFIG_VIDEO_V4L1_COMPAT
180 static const char *v4l1_ioctls[] = {
181 [_IOC_NR(VIDIOCGCAP)] = "VIDIOCGCAP",
182 [_IOC_NR(VIDIOCGCHAN)] = "VIDIOCGCHAN",
183 [_IOC_NR(VIDIOCSCHAN)] = "VIDIOCSCHAN",
184 [_IOC_NR(VIDIOCGTUNER)] = "VIDIOCGTUNER",
185 [_IOC_NR(VIDIOCSTUNER)] = "VIDIOCSTUNER",
186 [_IOC_NR(VIDIOCGPICT)] = "VIDIOCGPICT",
187 [_IOC_NR(VIDIOCSPICT)] = "VIDIOCSPICT",
188 [_IOC_NR(VIDIOCCAPTURE)] = "VIDIOCCAPTURE",
189 [_IOC_NR(VIDIOCGWIN)] = "VIDIOCGWIN",
190 [_IOC_NR(VIDIOCSWIN)] = "VIDIOCSWIN",
191 [_IOC_NR(VIDIOCGFBUF)] = "VIDIOCGFBUF",
192 [_IOC_NR(VIDIOCSFBUF)] = "VIDIOCSFBUF",
193 [_IOC_NR(VIDIOCKEY)] = "VIDIOCKEY",
194 [_IOC_NR(VIDIOCGFREQ)] = "VIDIOCGFREQ",
195 [_IOC_NR(VIDIOCSFREQ)] = "VIDIOCSFREQ",
196 [_IOC_NR(VIDIOCGAUDIO)] = "VIDIOCGAUDIO",
197 [_IOC_NR(VIDIOCSAUDIO)] = "VIDIOCSAUDIO",
198 [_IOC_NR(VIDIOCSYNC)] = "VIDIOCSYNC",
199 [_IOC_NR(VIDIOCMCAPTURE)] = "VIDIOCMCAPTURE",
200 [_IOC_NR(VIDIOCGMBUF)] = "VIDIOCGMBUF",
201 [_IOC_NR(VIDIOCGUNIT)] = "VIDIOCGUNIT",
202 [_IOC_NR(VIDIOCGCAPTURE)] = "VIDIOCGCAPTURE",
203 [_IOC_NR(VIDIOCSCAPTURE)] = "VIDIOCSCAPTURE",
204 [_IOC_NR(VIDIOCSPLAYMODE)] = "VIDIOCSPLAYMODE",
205 [_IOC_NR(VIDIOCSWRITEMODE)] = "VIDIOCSWRITEMODE",
206 [_IOC_NR(VIDIOCGPLAYINFO)] = "VIDIOCGPLAYINFO",
207 [_IOC_NR(VIDIOCSMICROCODE)] = "VIDIOCSMICROCODE",
208 [_IOC_NR(VIDIOCGVBIFMT)] = "VIDIOCGVBIFMT",
209 [_IOC_NR(VIDIOCSVBIFMT)] = "VIDIOCSVBIFMT"
211 #define V4L1_IOCTLS ARRAY_SIZE(v4l1_ioctls)
214 static const char *v4l2_ioctls[] = {
215 [_IOC_NR(VIDIOC_QUERYCAP)] = "VIDIOC_QUERYCAP",
216 [_IOC_NR(VIDIOC_RESERVED)] = "VIDIOC_RESERVED",
217 [_IOC_NR(VIDIOC_ENUM_FMT)] = "VIDIOC_ENUM_FMT",
218 [_IOC_NR(VIDIOC_G_FMT)] = "VIDIOC_G_FMT",
219 [_IOC_NR(VIDIOC_S_FMT)] = "VIDIOC_S_FMT",
220 [_IOC_NR(VIDIOC_REQBUFS)] = "VIDIOC_REQBUFS",
221 [_IOC_NR(VIDIOC_QUERYBUF)] = "VIDIOC_QUERYBUF",
222 [_IOC_NR(VIDIOC_G_FBUF)] = "VIDIOC_G_FBUF",
223 [_IOC_NR(VIDIOC_S_FBUF)] = "VIDIOC_S_FBUF",
224 [_IOC_NR(VIDIOC_OVERLAY)] = "VIDIOC_OVERLAY",
225 [_IOC_NR(VIDIOC_QBUF)] = "VIDIOC_QBUF",
226 [_IOC_NR(VIDIOC_DQBUF)] = "VIDIOC_DQBUF",
227 [_IOC_NR(VIDIOC_STREAMON)] = "VIDIOC_STREAMON",
228 [_IOC_NR(VIDIOC_STREAMOFF)] = "VIDIOC_STREAMOFF",
229 [_IOC_NR(VIDIOC_G_PARM)] = "VIDIOC_G_PARM",
230 [_IOC_NR(VIDIOC_S_PARM)] = "VIDIOC_S_PARM",
231 [_IOC_NR(VIDIOC_G_STD)] = "VIDIOC_G_STD",
232 [_IOC_NR(VIDIOC_S_STD)] = "VIDIOC_S_STD",
233 [_IOC_NR(VIDIOC_ENUMSTD)] = "VIDIOC_ENUMSTD",
234 [_IOC_NR(VIDIOC_ENUMINPUT)] = "VIDIOC_ENUMINPUT",
235 [_IOC_NR(VIDIOC_G_CTRL)] = "VIDIOC_G_CTRL",
236 [_IOC_NR(VIDIOC_S_CTRL)] = "VIDIOC_S_CTRL",
237 [_IOC_NR(VIDIOC_G_TUNER)] = "VIDIOC_G_TUNER",
238 [_IOC_NR(VIDIOC_S_TUNER)] = "VIDIOC_S_TUNER",
239 [_IOC_NR(VIDIOC_G_AUDIO)] = "VIDIOC_G_AUDIO",
240 [_IOC_NR(VIDIOC_S_AUDIO)] = "VIDIOC_S_AUDIO",
241 [_IOC_NR(VIDIOC_QUERYCTRL)] = "VIDIOC_QUERYCTRL",
242 [_IOC_NR(VIDIOC_QUERYMENU)] = "VIDIOC_QUERYMENU",
243 [_IOC_NR(VIDIOC_G_INPUT)] = "VIDIOC_G_INPUT",
244 [_IOC_NR(VIDIOC_S_INPUT)] = "VIDIOC_S_INPUT",
245 [_IOC_NR(VIDIOC_G_OUTPUT)] = "VIDIOC_G_OUTPUT",
246 [_IOC_NR(VIDIOC_S_OUTPUT)] = "VIDIOC_S_OUTPUT",
247 [_IOC_NR(VIDIOC_ENUMOUTPUT)] = "VIDIOC_ENUMOUTPUT",
248 [_IOC_NR(VIDIOC_G_AUDOUT)] = "VIDIOC_G_AUDOUT",
249 [_IOC_NR(VIDIOC_S_AUDOUT)] = "VIDIOC_S_AUDOUT",
250 [_IOC_NR(VIDIOC_G_MODULATOR)] = "VIDIOC_G_MODULATOR",
251 [_IOC_NR(VIDIOC_S_MODULATOR)] = "VIDIOC_S_MODULATOR",
252 [_IOC_NR(VIDIOC_G_FREQUENCY)] = "VIDIOC_G_FREQUENCY",
253 [_IOC_NR(VIDIOC_S_FREQUENCY)] = "VIDIOC_S_FREQUENCY",
254 [_IOC_NR(VIDIOC_CROPCAP)] = "VIDIOC_CROPCAP",
255 [_IOC_NR(VIDIOC_G_CROP)] = "VIDIOC_G_CROP",
256 [_IOC_NR(VIDIOC_S_CROP)] = "VIDIOC_S_CROP",
257 [_IOC_NR(VIDIOC_G_JPEGCOMP)] = "VIDIOC_G_JPEGCOMP",
258 [_IOC_NR(VIDIOC_S_JPEGCOMP)] = "VIDIOC_S_JPEGCOMP",
259 [_IOC_NR(VIDIOC_QUERYSTD)] = "VIDIOC_QUERYSTD",
260 [_IOC_NR(VIDIOC_TRY_FMT)] = "VIDIOC_TRY_FMT",
261 [_IOC_NR(VIDIOC_ENUMAUDIO)] = "VIDIOC_ENUMAUDIO",
262 [_IOC_NR(VIDIOC_ENUMAUDOUT)] = "VIDIOC_ENUMAUDOUT",
263 [_IOC_NR(VIDIOC_G_PRIORITY)] = "VIDIOC_G_PRIORITY",
264 [_IOC_NR(VIDIOC_S_PRIORITY)] = "VIDIOC_S_PRIORITY",
265 [_IOC_NR(VIDIOC_G_SLICED_VBI_CAP)] = "VIDIOC_G_SLICED_VBI_CAP",
266 [_IOC_NR(VIDIOC_LOG_STATUS)] = "VIDIOC_LOG_STATUS",
267 [_IOC_NR(VIDIOC_G_EXT_CTRLS)] = "VIDIOC_G_EXT_CTRLS",
268 [_IOC_NR(VIDIOC_S_EXT_CTRLS)] = "VIDIOC_S_EXT_CTRLS",
269 [_IOC_NR(VIDIOC_TRY_EXT_CTRLS)] = "VIDIOC_TRY_EXT_CTRLS",
271 [_IOC_NR(VIDIOC_ENUM_FRAMESIZES)] = "VIDIOC_ENUM_FRAMESIZES",
272 [_IOC_NR(VIDIOC_ENUM_FRAMEINTERVALS)] = "VIDIOC_ENUM_FRAMEINTERVALS",
273 [_IOC_NR(VIDIOC_G_ENC_INDEX)] = "VIDIOC_G_ENC_INDEX",
274 [_IOC_NR(VIDIOC_ENCODER_CMD)] = "VIDIOC_ENCODER_CMD",
275 [_IOC_NR(VIDIOC_TRY_ENCODER_CMD)] = "VIDIOC_TRY_ENCODER_CMD",
277 [_IOC_NR(VIDIOC_DBG_S_REGISTER)] = "VIDIOC_DBG_S_REGISTER",
278 [_IOC_NR(VIDIOC_DBG_G_REGISTER)] = "VIDIOC_DBG_G_REGISTER",
280 [_IOC_NR(VIDIOC_G_CHIP_IDENT)] = "VIDIOC_G_CHIP_IDENT",
281 [_IOC_NR(VIDIOC_S_HW_FREQ_SEEK)] = "VIDIOC_S_HW_FREQ_SEEK",
284 #define V4L2_IOCTLS ARRAY_SIZE(v4l2_ioctls)
286 static const char *v4l2_int_ioctls[] = {
287 #ifdef CONFIG_VIDEO_V4L1_COMPAT
288 [_IOC_NR(DECODER_GET_CAPABILITIES)] = "DECODER_GET_CAPABILITIES",
289 [_IOC_NR(DECODER_GET_STATUS)] = "DECODER_GET_STATUS",
290 [_IOC_NR(DECODER_SET_NORM)] = "DECODER_SET_NORM",
291 [_IOC_NR(DECODER_SET_INPUT)] = "DECODER_SET_INPUT",
292 [_IOC_NR(DECODER_SET_OUTPUT)] = "DECODER_SET_OUTPUT",
293 [_IOC_NR(DECODER_ENABLE_OUTPUT)] = "DECODER_ENABLE_OUTPUT",
294 [_IOC_NR(DECODER_SET_PICTURE)] = "DECODER_SET_PICTURE",
295 [_IOC_NR(DECODER_SET_GPIO)] = "DECODER_SET_GPIO",
296 [_IOC_NR(DECODER_INIT)] = "DECODER_INIT",
297 [_IOC_NR(DECODER_SET_VBI_BYPASS)] = "DECODER_SET_VBI_BYPASS",
298 [_IOC_NR(DECODER_DUMP)] = "DECODER_DUMP",
300 [_IOC_NR(AUDC_SET_RADIO)] = "AUDC_SET_RADIO",
302 [_IOC_NR(TUNER_SET_TYPE_ADDR)] = "TUNER_SET_TYPE_ADDR",
303 [_IOC_NR(TUNER_SET_STANDBY)] = "TUNER_SET_STANDBY",
304 [_IOC_NR(TUNER_SET_CONFIG)] = "TUNER_SET_CONFIG",
306 [_IOC_NR(VIDIOC_INT_S_TUNER_MODE)] = "VIDIOC_INT_S_TUNER_MODE",
307 [_IOC_NR(VIDIOC_INT_RESET)] = "VIDIOC_INT_RESET",
308 [_IOC_NR(VIDIOC_INT_AUDIO_CLOCK_FREQ)] = "VIDIOC_INT_AUDIO_CLOCK_FREQ",
309 [_IOC_NR(VIDIOC_INT_DECODE_VBI_LINE)] = "VIDIOC_INT_DECODE_VBI_LINE",
310 [_IOC_NR(VIDIOC_INT_S_VBI_DATA)] = "VIDIOC_INT_S_VBI_DATA",
311 [_IOC_NR(VIDIOC_INT_G_VBI_DATA)] = "VIDIOC_INT_G_VBI_DATA",
312 [_IOC_NR(VIDIOC_INT_I2S_CLOCK_FREQ)] = "VIDIOC_INT_I2S_CLOCK_FREQ",
313 [_IOC_NR(VIDIOC_INT_S_STANDBY)] = "VIDIOC_INT_S_STANDBY",
314 [_IOC_NR(VIDIOC_INT_S_AUDIO_ROUTING)] = "VIDIOC_INT_S_AUDIO_ROUTING",
315 [_IOC_NR(VIDIOC_INT_G_AUDIO_ROUTING)] = "VIDIOC_INT_G_AUDIO_ROUTING",
316 [_IOC_NR(VIDIOC_INT_S_VIDEO_ROUTING)] = "VIDIOC_INT_S_VIDEO_ROUTING",
317 [_IOC_NR(VIDIOC_INT_G_VIDEO_ROUTING)] = "VIDIOC_INT_G_VIDEO_ROUTING",
318 [_IOC_NR(VIDIOC_INT_S_CRYSTAL_FREQ)] = "VIDIOC_INT_S_CRYSTAL_FREQ",
319 [_IOC_NR(VIDIOC_INT_INIT)] = "VIDIOC_INT_INIT",
320 [_IOC_NR(VIDIOC_INT_G_STD_OUTPUT)] = "VIDIOC_INT_G_STD_OUTPUT",
321 [_IOC_NR(VIDIOC_INT_S_STD_OUTPUT)] = "VIDIOC_INT_S_STD_OUTPUT",
323 #define V4L2_INT_IOCTLS ARRAY_SIZE(v4l2_int_ioctls)
325 /* Common ioctl debug function. This function can be used by
326 external ioctl messages as well as internal V4L ioctl */
327 void v4l_printk_ioctl(unsigned int cmd)
331 switch (_IOC_TYPE(cmd)) {
333 if (_IOC_NR(cmd) >= V4L2_INT_IOCTLS) {
337 printk("%s", v4l2_int_ioctls[_IOC_NR(cmd)]);
339 #ifdef CONFIG_VIDEO_V4L1_COMPAT
341 if (_IOC_NR(cmd) >= V4L1_IOCTLS) {
345 printk("%s", v4l1_ioctls[_IOC_NR(cmd)]);
349 if (_IOC_NR(cmd) >= V4L2_IOCTLS) {
353 printk("%s", v4l2_ioctls[_IOC_NR(cmd)]);
359 switch (_IOC_DIR(cmd)) {
360 case _IOC_NONE: dir = "--"; break;
361 case _IOC_READ: dir = "r-"; break;
362 case _IOC_WRITE: dir = "-w"; break;
363 case _IOC_READ | _IOC_WRITE: dir = "rw"; break;
364 default: dir = "*ERR*"; break;
366 printk("%s ioctl '%c', dir=%s, #%d (0x%08x)",
367 type, _IOC_TYPE(cmd), dir, _IOC_NR(cmd), cmd);
369 EXPORT_SYMBOL(v4l_printk_ioctl);
375 static ssize_t show_name(struct device *cd,
376 struct device_attribute *attr, char *buf)
378 struct video_device *vfd = container_of(cd, struct video_device,
380 return sprintf(buf, "%.*s\n", (int)sizeof(vfd->name), vfd->name);
383 struct video_device *video_device_alloc(void)
385 struct video_device *vfd;
387 vfd = kzalloc(sizeof(*vfd),GFP_KERNEL);
390 EXPORT_SYMBOL(video_device_alloc);
392 void video_device_release(struct video_device *vfd)
396 EXPORT_SYMBOL(video_device_release);
398 static void video_release(struct device *cd)
400 struct video_device *vfd = container_of(cd, struct video_device,
404 /* needed until all drivers are fixed */
411 static struct device_attribute video_device_attrs[] = {
412 __ATTR(name, S_IRUGO, show_name, NULL),
416 static struct class video_class = {
418 .dev_attrs = video_device_attrs,
419 .dev_release = video_release,
426 static struct video_device *video_device[VIDEO_NUM_DEVICES];
427 static DEFINE_MUTEX(videodev_lock);
429 struct video_device* video_devdata(struct file *file)
431 return video_device[iminor(file->f_path.dentry->d_inode)];
433 EXPORT_SYMBOL(video_devdata);
436 * Open a video device - FIXME: Obsoleted
438 static int video_open(struct inode *inode, struct file *file)
440 unsigned int minor = iminor(inode);
442 struct video_device *vfl;
443 const struct file_operations *old_fops;
445 if(minor>=VIDEO_NUM_DEVICES)
448 mutex_lock(&videodev_lock);
449 vfl=video_device[minor];
451 mutex_unlock(&videodev_lock);
452 request_module("char-major-%d-%d", VIDEO_MAJOR, minor);
453 mutex_lock(&videodev_lock);
454 vfl=video_device[minor];
456 mutex_unlock(&videodev_lock);
461 old_fops = file->f_op;
462 file->f_op = fops_get(vfl->fops);
464 err = file->f_op->open(inode,file);
466 fops_put(file->f_op);
467 file->f_op = fops_get(old_fops);
470 mutex_unlock(&videodev_lock);
476 * helper function -- handles userspace copying for ioctl arguments
481 video_fix_command(unsigned int cmd)
484 case VIDIOC_OVERLAY_OLD:
485 cmd = VIDIOC_OVERLAY;
487 case VIDIOC_S_PARM_OLD:
490 case VIDIOC_S_CTRL_OLD:
493 case VIDIOC_G_AUDIO_OLD:
494 cmd = VIDIOC_G_AUDIO;
496 case VIDIOC_G_AUDOUT_OLD:
497 cmd = VIDIOC_G_AUDOUT;
499 case VIDIOC_CROPCAP_OLD:
500 cmd = VIDIOC_CROPCAP;
508 * Obsolete usercopy function - Should be removed soon
511 video_usercopy(struct inode *inode, struct file *file,
512 unsigned int cmd, unsigned long arg,
513 int (*func)(struct inode *inode, struct file *file,
514 unsigned int cmd, void *arg))
521 size_t ctrls_size = 0;
522 void __user *user_ptr = NULL;
525 cmd = video_fix_command(cmd);
527 is_ext_ctrl = (cmd == VIDIOC_S_EXT_CTRLS || cmd == VIDIOC_G_EXT_CTRLS ||
528 cmd == VIDIOC_TRY_EXT_CTRLS);
530 /* Copy arguments into temp kernel buffer */
531 switch (_IOC_DIR(cmd)) {
537 case (_IOC_WRITE | _IOC_READ):
538 if (_IOC_SIZE(cmd) <= sizeof(sbuf)) {
541 /* too big to allocate from stack */
542 mbuf = kmalloc(_IOC_SIZE(cmd),GFP_KERNEL);
549 if (_IOC_DIR(cmd) & _IOC_WRITE)
550 if (copy_from_user(parg, (void __user *)arg, _IOC_SIZE(cmd)))
555 struct v4l2_ext_controls *p = parg;
557 /* In case of an error, tell the caller that it wasn't
558 a specific control that caused it. */
559 p->error_idx = p->count;
560 user_ptr = (void __user *)p->controls;
562 ctrls_size = sizeof(struct v4l2_ext_control) * p->count;
563 /* Note: v4l2_ext_controls fits in sbuf[] so mbuf is still NULL. */
564 mbuf = kmalloc(ctrls_size, GFP_KERNEL);
569 if (copy_from_user(mbuf, user_ptr, ctrls_size))
576 err = func(inode, file, cmd, parg);
577 if (err == -ENOIOCTLCMD)
580 struct v4l2_ext_controls *p = parg;
582 p->controls = (void *)user_ptr;
583 if (p->count && err == 0 && copy_to_user(user_ptr, mbuf, ctrls_size))
591 /* Copy results into user buffer */
592 switch (_IOC_DIR(cmd))
595 case (_IOC_WRITE | _IOC_READ):
596 if (copy_to_user((void __user *)arg, parg, _IOC_SIZE(cmd)))
605 EXPORT_SYMBOL(video_usercopy);
608 * open/release helper functions -- handle exclusive opens
609 * Should be removed soon
611 int video_exclusive_open(struct inode *inode, struct file *file)
613 struct video_device *vfl = video_devdata(file);
616 mutex_lock(&vfl->lock);
622 mutex_unlock(&vfl->lock);
625 EXPORT_SYMBOL(video_exclusive_open);
627 int video_exclusive_release(struct inode *inode, struct file *file)
629 struct video_device *vfl = video_devdata(file);
634 EXPORT_SYMBOL(video_exclusive_release);
636 static void dbgbuf(unsigned int cmd, struct video_device *vfd,
637 struct v4l2_buffer *p)
639 struct v4l2_timecode *tc=&p->timecode;
641 dbgarg (cmd, "%02ld:%02d:%02d.%08ld index=%d, type=%s, "
642 "bytesused=%d, flags=0x%08d, "
643 "field=%0d, sequence=%d, memory=%s, offset/userptr=0x%08lx, length=%d\n",
644 (p->timestamp.tv_sec/3600),
645 (int)(p->timestamp.tv_sec/60)%60,
646 (int)(p->timestamp.tv_sec%60),
647 p->timestamp.tv_usec,
649 prt_names(p->type, v4l2_type_names),
650 p->bytesused, p->flags,
651 p->field, p->sequence,
652 prt_names(p->memory, v4l2_memory_names),
653 p->m.userptr, p->length);
654 dbgarg2 ("timecode= %02d:%02d:%02d type=%d, "
655 "flags=0x%08d, frames=%d, userbits=0x%08x\n",
656 tc->hours,tc->minutes,tc->seconds,
657 tc->type, tc->flags, tc->frames, *(__u32 *) tc->userbits);
660 static inline void dbgrect(struct video_device *vfd, char *s,
663 dbgarg2 ("%sRect start at %dx%d, size= %dx%d\n", s, r->left, r->top,
664 r->width, r->height);
667 static inline void v4l_print_pix_fmt (struct video_device *vfd,
668 struct v4l2_pix_format *fmt)
670 dbgarg2 ("width=%d, height=%d, format=%c%c%c%c, field=%s, "
671 "bytesperline=%d sizeimage=%d, colorspace=%d\n",
672 fmt->width,fmt->height,
673 (fmt->pixelformat & 0xff),
674 (fmt->pixelformat >> 8) & 0xff,
675 (fmt->pixelformat >> 16) & 0xff,
676 (fmt->pixelformat >> 24) & 0xff,
677 prt_names(fmt->field, v4l2_field_names),
678 fmt->bytesperline, fmt->sizeimage, fmt->colorspace);
682 static int check_fmt (struct video_device *vfd, enum v4l2_buf_type type)
685 case V4L2_BUF_TYPE_VIDEO_CAPTURE:
686 if (vfd->vidioc_try_fmt_cap)
689 case V4L2_BUF_TYPE_VIDEO_OVERLAY:
690 if (vfd->vidioc_try_fmt_overlay)
693 case V4L2_BUF_TYPE_VBI_CAPTURE:
694 if (vfd->vidioc_try_fmt_vbi)
697 case V4L2_BUF_TYPE_SLICED_VBI_OUTPUT:
698 if (vfd->vidioc_try_fmt_vbi_output)
701 case V4L2_BUF_TYPE_SLICED_VBI_CAPTURE:
702 if (vfd->vidioc_try_fmt_vbi_capture)
705 case V4L2_BUF_TYPE_VIDEO_OUTPUT:
706 if (vfd->vidioc_try_fmt_video_output)
709 case V4L2_BUF_TYPE_VBI_OUTPUT:
710 if (vfd->vidioc_try_fmt_vbi_output)
713 case V4L2_BUF_TYPE_VIDEO_OUTPUT_OVERLAY:
714 if (vfd->vidioc_try_fmt_output_overlay)
717 case V4L2_BUF_TYPE_PRIVATE:
718 if (vfd->vidioc_try_fmt_type_private)
725 static int __video_do_ioctl(struct inode *inode, struct file *file,
726 unsigned int cmd, void *arg)
728 struct video_device *vfd = video_devdata(file);
729 void *fh = file->private_data;
732 if ( (vfd->debug & V4L2_DEBUG_IOCTL) &&
733 !(vfd->debug & V4L2_DEBUG_IOCTL_ARG)) {
734 v4l_print_ioctl(vfd->name, cmd);
738 #ifdef CONFIG_VIDEO_V4L1_COMPAT
739 /***********************************************************
740 Handles calls to the obsoleted V4L1 API
741 Due to the nature of VIDIOCGMBUF, each driver that supports
742 V4L1 should implement its own handler for this ioctl.
743 ***********************************************************/
745 /* --- streaming capture ------------------------------------- */
746 if (cmd == VIDIOCGMBUF) {
747 struct video_mbuf *p=arg;
749 memset(p, 0, sizeof(*p));
751 if (!vfd->vidiocgmbuf)
753 ret=vfd->vidiocgmbuf(file, fh, p);
755 dbgarg (cmd, "size=%d, frames=%d, offsets=0x%08lx\n",
757 (unsigned long)p->offsets);
761 /********************************************************
762 All other V4L1 calls are handled by v4l1_compat module.
763 Those calls will be translated into V4L2 calls, and
764 __video_do_ioctl will be called again, with one or more
766 ********************************************************/
767 if (_IOC_TYPE(cmd)=='v')
768 return v4l_compat_translate_ioctl(inode,file,cmd,arg,
773 /* --- capabilities ------------------------------------------ */
774 case VIDIOC_QUERYCAP:
776 struct v4l2_capability *cap = (struct v4l2_capability*)arg;
777 memset(cap, 0, sizeof(*cap));
779 if (!vfd->vidioc_querycap)
782 ret=vfd->vidioc_querycap(file, fh, cap);
784 dbgarg (cmd, "driver=%s, card=%s, bus=%s, "
786 "capabilities=0x%08x\n",
787 cap->driver,cap->card,cap->bus_info,
793 /* --- priority ------------------------------------------ */
794 case VIDIOC_G_PRIORITY:
796 enum v4l2_priority *p=arg;
798 if (!vfd->vidioc_g_priority)
800 ret=vfd->vidioc_g_priority(file, fh, p);
802 dbgarg(cmd, "priority is %d\n", *p);
805 case VIDIOC_S_PRIORITY:
807 enum v4l2_priority *p=arg;
809 if (!vfd->vidioc_s_priority)
811 dbgarg(cmd, "setting priority to %d\n", *p);
812 ret=vfd->vidioc_s_priority(file, fh, *p);
816 /* --- capture ioctls ---------------------------------------- */
817 case VIDIOC_ENUM_FMT:
819 struct v4l2_fmtdesc *f = arg;
820 enum v4l2_buf_type type;
825 memset(f,0,sizeof(*f));
830 case V4L2_BUF_TYPE_VIDEO_CAPTURE:
831 if (vfd->vidioc_enum_fmt_cap)
832 ret=vfd->vidioc_enum_fmt_cap(file, fh, f);
834 case V4L2_BUF_TYPE_VIDEO_OVERLAY:
835 if (vfd->vidioc_enum_fmt_overlay)
836 ret=vfd->vidioc_enum_fmt_overlay(file, fh, f);
838 case V4L2_BUF_TYPE_VBI_CAPTURE:
839 if (vfd->vidioc_enum_fmt_vbi)
840 ret=vfd->vidioc_enum_fmt_vbi(file, fh, f);
842 case V4L2_BUF_TYPE_SLICED_VBI_OUTPUT:
843 if (vfd->vidioc_enum_fmt_vbi_output)
844 ret=vfd->vidioc_enum_fmt_vbi_output(file,
847 case V4L2_BUF_TYPE_SLICED_VBI_CAPTURE:
848 if (vfd->vidioc_enum_fmt_vbi_capture)
849 ret=vfd->vidioc_enum_fmt_vbi_capture(file,
852 case V4L2_BUF_TYPE_VIDEO_OUTPUT:
853 if (vfd->vidioc_enum_fmt_video_output)
854 ret=vfd->vidioc_enum_fmt_video_output(file,
857 case V4L2_BUF_TYPE_VBI_OUTPUT:
858 if (vfd->vidioc_enum_fmt_vbi_output)
859 ret=vfd->vidioc_enum_fmt_vbi_output(file,
862 case V4L2_BUF_TYPE_VIDEO_OUTPUT_OVERLAY:
863 if (vfd->vidioc_enum_fmt_output_overlay)
864 ret=vfd->vidioc_enum_fmt_output_overlay(file, fh, f);
866 case V4L2_BUF_TYPE_PRIVATE:
867 if (vfd->vidioc_enum_fmt_type_private)
868 ret=vfd->vidioc_enum_fmt_type_private(file,
873 dbgarg (cmd, "index=%d, type=%d, flags=%d, "
874 "pixelformat=%c%c%c%c, description='%s'\n",
875 f->index, f->type, f->flags,
876 (f->pixelformat & 0xff),
877 (f->pixelformat >> 8) & 0xff,
878 (f->pixelformat >> 16) & 0xff,
879 (f->pixelformat >> 24) & 0xff,
885 struct v4l2_format *f = (struct v4l2_format *)arg;
887 memset(f->fmt.raw_data, 0, sizeof(f->fmt.raw_data));
889 /* FIXME: Should be one dump per type */
890 dbgarg(cmd, "type=%s\n", prt_names(f->type, v4l2_type_names));
893 case V4L2_BUF_TYPE_VIDEO_CAPTURE:
894 if (vfd->vidioc_g_fmt_cap)
895 ret=vfd->vidioc_g_fmt_cap(file, fh, f);
897 v4l_print_pix_fmt(vfd,&f->fmt.pix);
899 case V4L2_BUF_TYPE_VIDEO_OVERLAY:
900 if (vfd->vidioc_g_fmt_overlay)
901 ret=vfd->vidioc_g_fmt_overlay(file, fh, f);
903 case V4L2_BUF_TYPE_VBI_CAPTURE:
904 if (vfd->vidioc_g_fmt_vbi)
905 ret=vfd->vidioc_g_fmt_vbi(file, fh, f);
907 case V4L2_BUF_TYPE_SLICED_VBI_OUTPUT:
908 if (vfd->vidioc_g_fmt_vbi_output)
909 ret=vfd->vidioc_g_fmt_vbi_output(file, fh, f);
911 case V4L2_BUF_TYPE_SLICED_VBI_CAPTURE:
912 if (vfd->vidioc_g_fmt_vbi_capture)
913 ret=vfd->vidioc_g_fmt_vbi_capture(file, fh, f);
915 case V4L2_BUF_TYPE_VIDEO_OUTPUT:
916 if (vfd->vidioc_g_fmt_video_output)
917 ret=vfd->vidioc_g_fmt_video_output(file,
920 case V4L2_BUF_TYPE_VIDEO_OUTPUT_OVERLAY:
921 if (vfd->vidioc_g_fmt_output_overlay)
922 ret=vfd->vidioc_g_fmt_output_overlay(file, fh, f);
924 case V4L2_BUF_TYPE_VBI_OUTPUT:
925 if (vfd->vidioc_g_fmt_vbi_output)
926 ret=vfd->vidioc_g_fmt_vbi_output(file, fh, f);
928 case V4L2_BUF_TYPE_PRIVATE:
929 if (vfd->vidioc_g_fmt_type_private)
930 ret=vfd->vidioc_g_fmt_type_private(file,
939 struct v4l2_format *f = (struct v4l2_format *)arg;
941 /* FIXME: Should be one dump per type */
942 dbgarg (cmd, "type=%s\n", prt_names(f->type,
946 case V4L2_BUF_TYPE_VIDEO_CAPTURE:
947 v4l_print_pix_fmt(vfd,&f->fmt.pix);
948 if (vfd->vidioc_s_fmt_cap)
949 ret=vfd->vidioc_s_fmt_cap(file, fh, f);
951 case V4L2_BUF_TYPE_VIDEO_OVERLAY:
952 if (vfd->vidioc_s_fmt_overlay)
953 ret=vfd->vidioc_s_fmt_overlay(file, fh, f);
955 case V4L2_BUF_TYPE_VBI_CAPTURE:
956 if (vfd->vidioc_s_fmt_vbi)
957 ret=vfd->vidioc_s_fmt_vbi(file, fh, f);
959 case V4L2_BUF_TYPE_SLICED_VBI_OUTPUT:
960 if (vfd->vidioc_s_fmt_vbi_output)
961 ret=vfd->vidioc_s_fmt_vbi_output(file, fh, f);
963 case V4L2_BUF_TYPE_SLICED_VBI_CAPTURE:
964 if (vfd->vidioc_s_fmt_vbi_capture)
965 ret=vfd->vidioc_s_fmt_vbi_capture(file, fh, f);
967 case V4L2_BUF_TYPE_VIDEO_OUTPUT:
968 if (vfd->vidioc_s_fmt_video_output)
969 ret=vfd->vidioc_s_fmt_video_output(file,
972 case V4L2_BUF_TYPE_VIDEO_OUTPUT_OVERLAY:
973 if (vfd->vidioc_s_fmt_output_overlay)
974 ret=vfd->vidioc_s_fmt_output_overlay(file, fh, f);
976 case V4L2_BUF_TYPE_VBI_OUTPUT:
977 if (vfd->vidioc_s_fmt_vbi_output)
978 ret=vfd->vidioc_s_fmt_vbi_output(file,
981 case V4L2_BUF_TYPE_PRIVATE:
982 if (vfd->vidioc_s_fmt_type_private)
983 ret=vfd->vidioc_s_fmt_type_private(file,
991 struct v4l2_format *f = (struct v4l2_format *)arg;
993 /* FIXME: Should be one dump per type */
994 dbgarg (cmd, "type=%s\n", prt_names(f->type,
997 case V4L2_BUF_TYPE_VIDEO_CAPTURE:
998 if (vfd->vidioc_try_fmt_cap)
999 ret=vfd->vidioc_try_fmt_cap(file, fh, f);
1001 v4l_print_pix_fmt(vfd,&f->fmt.pix);
1003 case V4L2_BUF_TYPE_VIDEO_OVERLAY:
1004 if (vfd->vidioc_try_fmt_overlay)
1005 ret=vfd->vidioc_try_fmt_overlay(file, fh, f);
1007 case V4L2_BUF_TYPE_VBI_CAPTURE:
1008 if (vfd->vidioc_try_fmt_vbi)
1009 ret=vfd->vidioc_try_fmt_vbi(file, fh, f);
1011 case V4L2_BUF_TYPE_SLICED_VBI_OUTPUT:
1012 if (vfd->vidioc_try_fmt_vbi_output)
1013 ret=vfd->vidioc_try_fmt_vbi_output(file,
1016 case V4L2_BUF_TYPE_SLICED_VBI_CAPTURE:
1017 if (vfd->vidioc_try_fmt_vbi_capture)
1018 ret=vfd->vidioc_try_fmt_vbi_capture(file,
1021 case V4L2_BUF_TYPE_VIDEO_OUTPUT:
1022 if (vfd->vidioc_try_fmt_video_output)
1023 ret=vfd->vidioc_try_fmt_video_output(file,
1026 case V4L2_BUF_TYPE_VIDEO_OUTPUT_OVERLAY:
1027 if (vfd->vidioc_try_fmt_output_overlay)
1028 ret=vfd->vidioc_try_fmt_output_overlay(file, fh, f);
1030 case V4L2_BUF_TYPE_VBI_OUTPUT:
1031 if (vfd->vidioc_try_fmt_vbi_output)
1032 ret=vfd->vidioc_try_fmt_vbi_output(file,
1035 case V4L2_BUF_TYPE_PRIVATE:
1036 if (vfd->vidioc_try_fmt_type_private)
1037 ret=vfd->vidioc_try_fmt_type_private(file,
1044 /* FIXME: Those buf reqs could be handled here,
1045 with some changes on videobuf to allow its header to be included at
1046 videodev2.h or being merged at videodev2.
1048 case VIDIOC_REQBUFS:
1050 struct v4l2_requestbuffers *p=arg;
1052 if (!vfd->vidioc_reqbufs)
1054 ret = check_fmt (vfd, p->type);
1058 ret=vfd->vidioc_reqbufs(file, fh, p);
1059 dbgarg (cmd, "count=%d, type=%s, memory=%s\n",
1061 prt_names(p->type, v4l2_type_names),
1062 prt_names(p->memory, v4l2_memory_names));
1065 case VIDIOC_QUERYBUF:
1067 struct v4l2_buffer *p=arg;
1069 if (!vfd->vidioc_querybuf)
1071 ret = check_fmt (vfd, p->type);
1075 ret=vfd->vidioc_querybuf(file, fh, p);
1082 struct v4l2_buffer *p=arg;
1084 if (!vfd->vidioc_qbuf)
1086 ret = check_fmt (vfd, p->type);
1090 ret=vfd->vidioc_qbuf(file, fh, p);
1097 struct v4l2_buffer *p=arg;
1098 if (!vfd->vidioc_dqbuf)
1100 ret = check_fmt (vfd, p->type);
1104 ret=vfd->vidioc_dqbuf(file, fh, p);
1109 case VIDIOC_OVERLAY:
1113 if (!vfd->vidioc_overlay)
1115 dbgarg (cmd, "value=%d\n",*i);
1116 ret=vfd->vidioc_overlay(file, fh, *i);
1121 struct v4l2_framebuffer *p=arg;
1122 if (!vfd->vidioc_g_fbuf)
1124 ret=vfd->vidioc_g_fbuf(file, fh, arg);
1126 dbgarg (cmd, "capability=%d, flags=%d, base=0x%08lx\n",
1127 p->capability,p->flags,
1128 (unsigned long)p->base);
1129 v4l_print_pix_fmt (vfd, &p->fmt);
1135 struct v4l2_framebuffer *p=arg;
1136 if (!vfd->vidioc_s_fbuf)
1139 dbgarg (cmd, "capability=%d, flags=%d, base=0x%08lx\n",
1140 p->capability,p->flags,(unsigned long)p->base);
1141 v4l_print_pix_fmt (vfd, &p->fmt);
1142 ret=vfd->vidioc_s_fbuf(file, fh, arg);
1146 case VIDIOC_STREAMON:
1148 enum v4l2_buf_type i = *(int *)arg;
1149 if (!vfd->vidioc_streamon)
1151 dbgarg(cmd, "type=%s\n", prt_names(i, v4l2_type_names));
1152 ret=vfd->vidioc_streamon(file, fh,i);
1155 case VIDIOC_STREAMOFF:
1157 enum v4l2_buf_type i = *(int *)arg;
1159 if (!vfd->vidioc_streamoff)
1161 dbgarg(cmd, "type=%s\n", prt_names(i, v4l2_type_names));
1162 ret=vfd->vidioc_streamoff(file, fh, i);
1165 /* ---------- tv norms ---------- */
1166 case VIDIOC_ENUMSTD:
1168 struct v4l2_standard *p = arg;
1169 v4l2_std_id id = vfd->tvnorms, curr_id = 0;
1170 unsigned int index = p->index, i, j = 0;
1171 const char *descr = "";
1173 /* Return norm array in a canonical way */
1174 for (i = 0; i <= index && id; i++) {
1175 /* last std value in the standards array is 0, so this
1176 while always ends there since (id & 0) == 0. */
1177 while ((id & standards[j].std) != standards[j].std)
1179 curr_id = standards[j].std;
1180 descr = standards[j].descr;
1184 if (curr_id != V4L2_STD_PAL &&
1185 curr_id != V4L2_STD_SECAM &&
1186 curr_id != V4L2_STD_NTSC)
1192 v4l2_video_std_construct(p, curr_id, descr);
1195 dbgarg(cmd, "index=%d, id=%Ld, name=%s, fps=%d/%d, "
1196 "framelines=%d\n", p->index,
1197 (unsigned long long)p->id, p->name,
1198 p->frameperiod.numerator,
1199 p->frameperiod.denominator,
1207 v4l2_std_id *id = arg;
1209 *id = vfd->current_norm;
1211 dbgarg (cmd, "value=%08Lx\n", (long long unsigned) *id);
1218 v4l2_std_id *id = arg,norm;
1220 dbgarg (cmd, "value=%08Lx\n", (long long unsigned) *id);
1222 norm = (*id) & vfd->tvnorms;
1223 if ( vfd->tvnorms && !norm) /* Check if std is supported */
1226 /* Calls the specific handler */
1227 if (vfd->vidioc_s_std)
1228 ret=vfd->vidioc_s_std(file, fh, &norm);
1232 /* Updates standard information */
1234 vfd->current_norm=norm;
1238 case VIDIOC_QUERYSTD:
1242 if (!vfd->vidioc_querystd)
1244 ret=vfd->vidioc_querystd(file, fh, arg);
1246 dbgarg (cmd, "detected std=%08Lx\n",
1247 (unsigned long long)*p);
1250 /* ------ input switching ---------- */
1251 /* FIXME: Inputs can be handled inside videodev2 */
1252 case VIDIOC_ENUMINPUT:
1254 struct v4l2_input *p=arg;
1257 if (!vfd->vidioc_enum_input)
1259 memset(p, 0, sizeof(*p));
1262 ret=vfd->vidioc_enum_input(file, fh, p);
1264 dbgarg (cmd, "index=%d, name=%s, type=%d, "
1266 "tuner=%d, std=%08Lx, status=%d\n",
1267 p->index,p->name,p->type,p->audioset,
1269 (unsigned long long)p->std,
1273 case VIDIOC_G_INPUT:
1275 unsigned int *i = arg;
1277 if (!vfd->vidioc_g_input)
1279 ret=vfd->vidioc_g_input(file, fh, i);
1281 dbgarg (cmd, "value=%d\n",*i);
1284 case VIDIOC_S_INPUT:
1286 unsigned int *i = arg;
1288 if (!vfd->vidioc_s_input)
1290 dbgarg (cmd, "value=%d\n",*i);
1291 ret=vfd->vidioc_s_input(file, fh, *i);
1295 /* ------ output switching ---------- */
1296 case VIDIOC_G_OUTPUT:
1298 unsigned int *i = arg;
1300 if (!vfd->vidioc_g_output)
1302 ret=vfd->vidioc_g_output(file, fh, i);
1304 dbgarg (cmd, "value=%d\n",*i);
1307 case VIDIOC_S_OUTPUT:
1309 unsigned int *i = arg;
1311 if (!vfd->vidioc_s_output)
1313 dbgarg (cmd, "value=%d\n",*i);
1314 ret=vfd->vidioc_s_output(file, fh, *i);
1318 /* --- controls ---------------------------------------------- */
1319 case VIDIOC_QUERYCTRL:
1321 struct v4l2_queryctrl *p=arg;
1323 if (!vfd->vidioc_queryctrl)
1325 ret=vfd->vidioc_queryctrl(file, fh, p);
1328 dbgarg (cmd, "id=%d, type=%d, name=%s, "
1330 " step=%d, default=%d, flags=0x%08x\n",
1331 p->id,p->type,p->name,p->minimum,
1332 p->maximum,p->step,p->default_value,
1338 struct v4l2_control *p = arg;
1340 if (!vfd->vidioc_g_ctrl)
1342 dbgarg(cmd, "Enum for index=%d\n", p->id);
1344 ret=vfd->vidioc_g_ctrl(file, fh, p);
1346 dbgarg2 ( "id=%d, value=%d\n", p->id, p->value);
1351 struct v4l2_control *p = arg;
1353 if (!vfd->vidioc_s_ctrl)
1355 dbgarg (cmd, "id=%d, value=%d\n", p->id, p->value);
1357 ret=vfd->vidioc_s_ctrl(file, fh, p);
1360 case VIDIOC_G_EXT_CTRLS:
1362 struct v4l2_ext_controls *p = arg;
1364 if (vfd->vidioc_g_ext_ctrls) {
1365 dbgarg(cmd, "count=%d\n", p->count);
1367 ret=vfd->vidioc_g_ext_ctrls(file, fh, p);
1371 case VIDIOC_S_EXT_CTRLS:
1373 struct v4l2_ext_controls *p = arg;
1375 if (vfd->vidioc_s_ext_ctrls) {
1376 dbgarg(cmd, "count=%d\n", p->count);
1378 ret=vfd->vidioc_s_ext_ctrls(file, fh, p);
1382 case VIDIOC_TRY_EXT_CTRLS:
1384 struct v4l2_ext_controls *p = arg;
1386 if (vfd->vidioc_try_ext_ctrls) {
1387 dbgarg(cmd, "count=%d\n", p->count);
1389 ret=vfd->vidioc_try_ext_ctrls(file, fh, p);
1393 case VIDIOC_QUERYMENU:
1395 struct v4l2_querymenu *p=arg;
1396 if (!vfd->vidioc_querymenu)
1398 ret=vfd->vidioc_querymenu(file, fh, p);
1400 dbgarg (cmd, "id=%d, index=%d, name=%s\n",
1401 p->id,p->index,p->name);
1404 /* --- audio ---------------------------------------------- */
1405 case VIDIOC_ENUMAUDIO:
1407 struct v4l2_audio *p=arg;
1409 if (!vfd->vidioc_enumaudio)
1411 dbgarg(cmd, "Enum for index=%d\n", p->index);
1412 ret=vfd->vidioc_enumaudio(file, fh, p);
1414 dbgarg2("index=%d, name=%s, capability=%d, "
1415 "mode=%d\n",p->index,p->name,
1416 p->capability, p->mode);
1419 case VIDIOC_G_AUDIO:
1421 struct v4l2_audio *p=arg;
1422 __u32 index=p->index;
1424 if (!vfd->vidioc_g_audio)
1427 memset(p,0,sizeof(*p));
1429 dbgarg(cmd, "Get for index=%d\n", p->index);
1430 ret=vfd->vidioc_g_audio(file, fh, p);
1432 dbgarg2("index=%d, name=%s, capability=%d, "
1433 "mode=%d\n",p->index,
1434 p->name,p->capability, p->mode);
1437 case VIDIOC_S_AUDIO:
1439 struct v4l2_audio *p=arg;
1441 if (!vfd->vidioc_s_audio)
1443 dbgarg(cmd, "index=%d, name=%s, capability=%d, "
1444 "mode=%d\n", p->index, p->name,
1445 p->capability, p->mode);
1446 ret=vfd->vidioc_s_audio(file, fh, p);
1449 case VIDIOC_ENUMAUDOUT:
1451 struct v4l2_audioout *p=arg;
1453 if (!vfd->vidioc_enumaudout)
1455 dbgarg(cmd, "Enum for index=%d\n", p->index);
1456 ret=vfd->vidioc_enumaudout(file, fh, p);
1458 dbgarg2("index=%d, name=%s, capability=%d, "
1459 "mode=%d\n", p->index, p->name,
1460 p->capability,p->mode);
1463 case VIDIOC_G_AUDOUT:
1465 struct v4l2_audioout *p=arg;
1467 if (!vfd->vidioc_g_audout)
1469 dbgarg(cmd, "Enum for index=%d\n", p->index);
1470 ret=vfd->vidioc_g_audout(file, fh, p);
1472 dbgarg2("index=%d, name=%s, capability=%d, "
1473 "mode=%d\n", p->index, p->name,
1474 p->capability,p->mode);
1477 case VIDIOC_S_AUDOUT:
1479 struct v4l2_audioout *p=arg;
1481 if (!vfd->vidioc_s_audout)
1483 dbgarg(cmd, "index=%d, name=%s, capability=%d, "
1484 "mode=%d\n", p->index, p->name,
1485 p->capability,p->mode);
1487 ret=vfd->vidioc_s_audout(file, fh, p);
1490 case VIDIOC_G_MODULATOR:
1492 struct v4l2_modulator *p=arg;
1493 if (!vfd->vidioc_g_modulator)
1495 ret=vfd->vidioc_g_modulator(file, fh, p);
1497 dbgarg(cmd, "index=%d, name=%s, "
1498 "capability=%d, rangelow=%d,"
1499 " rangehigh=%d, txsubchans=%d\n",
1500 p->index, p->name,p->capability,
1501 p->rangelow, p->rangehigh,
1505 case VIDIOC_S_MODULATOR:
1507 struct v4l2_modulator *p=arg;
1508 if (!vfd->vidioc_s_modulator)
1510 dbgarg(cmd, "index=%d, name=%s, capability=%d, "
1511 "rangelow=%d, rangehigh=%d, txsubchans=%d\n",
1512 p->index, p->name,p->capability,p->rangelow,
1513 p->rangehigh,p->txsubchans);
1514 ret=vfd->vidioc_s_modulator(file, fh, p);
1519 struct v4l2_crop *p=arg;
1520 if (!vfd->vidioc_g_crop)
1522 ret=vfd->vidioc_g_crop(file, fh, p);
1524 dbgarg(cmd, "type=%d\n", p->type);
1525 dbgrect(vfd, "", &p->c);
1531 struct v4l2_crop *p=arg;
1532 if (!vfd->vidioc_s_crop)
1534 dbgarg(cmd, "type=%d\n", p->type);
1535 dbgrect(vfd, "", &p->c);
1536 ret=vfd->vidioc_s_crop(file, fh, p);
1539 case VIDIOC_CROPCAP:
1541 struct v4l2_cropcap *p=arg;
1542 /*FIXME: Should also show v4l2_fract pixelaspect */
1543 if (!vfd->vidioc_cropcap)
1545 dbgarg(cmd, "type=%d\n", p->type);
1546 dbgrect(vfd, "bounds ", &p->bounds);
1547 dbgrect(vfd, "defrect ", &p->defrect);
1548 ret=vfd->vidioc_cropcap(file, fh, p);
1551 case VIDIOC_G_JPEGCOMP:
1553 struct v4l2_jpegcompression *p=arg;
1554 if (!vfd->vidioc_g_jpegcomp)
1556 ret=vfd->vidioc_g_jpegcomp(file, fh, p);
1558 dbgarg (cmd, "quality=%d, APPn=%d, "
1559 "APP_len=%d, COM_len=%d, "
1560 "jpeg_markers=%d\n",
1561 p->quality,p->APPn,p->APP_len,
1562 p->COM_len,p->jpeg_markers);
1565 case VIDIOC_S_JPEGCOMP:
1567 struct v4l2_jpegcompression *p=arg;
1568 if (!vfd->vidioc_g_jpegcomp)
1570 dbgarg (cmd, "quality=%d, APPn=%d, APP_len=%d, "
1571 "COM_len=%d, jpeg_markers=%d\n",
1572 p->quality,p->APPn,p->APP_len,
1573 p->COM_len,p->jpeg_markers);
1574 ret=vfd->vidioc_s_jpegcomp(file, fh, p);
1577 case VIDIOC_G_ENC_INDEX:
1579 struct v4l2_enc_idx *p=arg;
1581 if (!vfd->vidioc_g_enc_index)
1583 ret=vfd->vidioc_g_enc_index(file, fh, p);
1585 dbgarg (cmd, "entries=%d, entries_cap=%d\n",
1586 p->entries,p->entries_cap);
1589 case VIDIOC_ENCODER_CMD:
1591 struct v4l2_encoder_cmd *p=arg;
1593 if (!vfd->vidioc_encoder_cmd)
1595 ret=vfd->vidioc_encoder_cmd(file, fh, p);
1597 dbgarg (cmd, "cmd=%d, flags=%d\n",
1601 case VIDIOC_TRY_ENCODER_CMD:
1603 struct v4l2_encoder_cmd *p=arg;
1605 if (!vfd->vidioc_try_encoder_cmd)
1607 ret=vfd->vidioc_try_encoder_cmd(file, fh, p);
1609 dbgarg (cmd, "cmd=%d, flags=%d\n",
1615 struct v4l2_streamparm *p=arg;
1618 memset(p,0,sizeof(*p));
1621 if (vfd->vidioc_g_parm) {
1622 ret=vfd->vidioc_g_parm(file, fh, p);
1624 struct v4l2_standard s;
1626 if (p->type != V4L2_BUF_TYPE_VIDEO_CAPTURE)
1629 v4l2_video_std_construct(&s, vfd->current_norm,
1630 v4l2_norm_to_name(vfd->current_norm));
1632 p->parm.capture.timeperframe = s.frameperiod;
1636 dbgarg (cmd, "type=%d\n", p->type);
1641 struct v4l2_streamparm *p=arg;
1642 if (!vfd->vidioc_s_parm)
1644 dbgarg (cmd, "type=%d\n", p->type);
1645 ret=vfd->vidioc_s_parm(file, fh, p);
1648 case VIDIOC_G_TUNER:
1650 struct v4l2_tuner *p=arg;
1651 __u32 index=p->index;
1653 if (!vfd->vidioc_g_tuner)
1656 memset(p,0,sizeof(*p));
1659 ret=vfd->vidioc_g_tuner(file, fh, p);
1661 dbgarg (cmd, "index=%d, name=%s, type=%d, "
1662 "capability=%d, rangelow=%d, "
1663 "rangehigh=%d, signal=%d, afc=%d, "
1664 "rxsubchans=%d, audmode=%d\n",
1665 p->index, p->name, p->type,
1666 p->capability, p->rangelow,
1667 p->rangehigh, p->rxsubchans,
1668 p->audmode, p->signal, p->afc);
1671 case VIDIOC_S_TUNER:
1673 struct v4l2_tuner *p=arg;
1674 if (!vfd->vidioc_s_tuner)
1676 dbgarg (cmd, "index=%d, name=%s, type=%d, "
1677 "capability=%d, rangelow=%d, rangehigh=%d, "
1678 "signal=%d, afc=%d, rxsubchans=%d, "
1679 "audmode=%d\n",p->index, p->name, p->type,
1680 p->capability, p->rangelow,p->rangehigh,
1681 p->rxsubchans, p->audmode, p->signal,
1683 ret=vfd->vidioc_s_tuner(file, fh, p);
1686 case VIDIOC_G_FREQUENCY:
1688 struct v4l2_frequency *p = arg;
1690 if (!vfd->vidioc_g_frequency)
1693 memset(p->reserved, 0, sizeof(p->reserved));
1695 ret = vfd->vidioc_g_frequency(file, fh, p);
1697 dbgarg(cmd, "tuner=%d, type=%d, frequency=%d\n",
1698 p->tuner, p->type, p->frequency);
1701 case VIDIOC_S_FREQUENCY:
1703 struct v4l2_frequency *p=arg;
1704 if (!vfd->vidioc_s_frequency)
1706 dbgarg (cmd, "tuner=%d, type=%d, frequency=%d\n",
1707 p->tuner,p->type,p->frequency);
1708 ret=vfd->vidioc_s_frequency(file, fh, p);
1711 case VIDIOC_G_SLICED_VBI_CAP:
1713 struct v4l2_sliced_vbi_cap *p=arg;
1714 if (!vfd->vidioc_g_sliced_vbi_cap)
1716 ret=vfd->vidioc_g_sliced_vbi_cap(file, fh, p);
1718 dbgarg (cmd, "service_set=%d\n", p->service_set);
1721 case VIDIOC_LOG_STATUS:
1723 if (!vfd->vidioc_log_status)
1725 ret=vfd->vidioc_log_status(file, fh);
1728 #ifdef CONFIG_VIDEO_ADV_DEBUG
1729 case VIDIOC_DBG_G_REGISTER:
1731 struct v4l2_register *p=arg;
1732 if (!capable(CAP_SYS_ADMIN))
1734 else if (vfd->vidioc_g_register)
1735 ret=vfd->vidioc_g_register(file, fh, p);
1738 case VIDIOC_DBG_S_REGISTER:
1740 struct v4l2_register *p=arg;
1741 if (!capable(CAP_SYS_ADMIN))
1743 else if (vfd->vidioc_s_register)
1744 ret=vfd->vidioc_s_register(file, fh, p);
1748 case VIDIOC_G_CHIP_IDENT:
1750 struct v4l2_chip_ident *p=arg;
1751 if (!vfd->vidioc_g_chip_ident)
1753 ret=vfd->vidioc_g_chip_ident(file, fh, p);
1755 dbgarg (cmd, "chip_ident=%u, revision=0x%x\n", p->ident, p->revision);
1760 if (!vfd->vidioc_default)
1762 ret = vfd->vidioc_default(file, fh, cmd, arg);
1765 case VIDIOC_S_HW_FREQ_SEEK:
1767 struct v4l2_hw_freq_seek *p = arg;
1768 if (!vfd->vidioc_s_hw_freq_seek)
1771 "tuner=%d, type=%d, seek_upward=%d, wrap_around=%d\n",
1772 p->tuner, p->type, p->seek_upward, p->wrap_around);
1773 ret = vfd->vidioc_s_hw_freq_seek(file, fh, p);
1778 if (vfd->debug & V4L2_DEBUG_IOCTL_ARG) {
1780 printk("%s: err: on ", vfd->name);
1781 v4l_print_ioctl(vfd->name, cmd);
1789 int video_ioctl2 (struct inode *inode, struct file *file,
1790 unsigned int cmd, unsigned long arg)
1797 size_t ctrls_size = 0;
1798 void __user *user_ptr = NULL;
1800 #ifdef __OLD_VIDIOC_
1801 cmd = video_fix_command(cmd);
1803 is_ext_ctrl = (cmd == VIDIOC_S_EXT_CTRLS || cmd == VIDIOC_G_EXT_CTRLS ||
1804 cmd == VIDIOC_TRY_EXT_CTRLS);
1806 /* Copy arguments into temp kernel buffer */
1807 switch (_IOC_DIR(cmd)) {
1813 case (_IOC_WRITE | _IOC_READ):
1814 if (_IOC_SIZE(cmd) <= sizeof(sbuf)) {
1817 /* too big to allocate from stack */
1818 mbuf = kmalloc(_IOC_SIZE(cmd),GFP_KERNEL);
1825 if (_IOC_DIR(cmd) & _IOC_WRITE)
1826 if (copy_from_user(parg, (void __user *)arg, _IOC_SIZE(cmd)))
1832 struct v4l2_ext_controls *p = parg;
1834 /* In case of an error, tell the caller that it wasn't
1835 a specific control that caused it. */
1836 p->error_idx = p->count;
1837 user_ptr = (void __user *)p->controls;
1839 ctrls_size = sizeof(struct v4l2_ext_control) * p->count;
1840 /* Note: v4l2_ext_controls fits in sbuf[] so mbuf is still NULL. */
1841 mbuf = kmalloc(ctrls_size, GFP_KERNEL);
1846 if (copy_from_user(mbuf, user_ptr, ctrls_size))
1853 err = __video_do_ioctl(inode, file, cmd, parg);
1854 if (err == -ENOIOCTLCMD)
1857 struct v4l2_ext_controls *p = parg;
1859 p->controls = (void *)user_ptr;
1860 if (p->count && err == 0 && copy_to_user(user_ptr, mbuf, ctrls_size))
1868 /* Copy results into user buffer */
1869 switch (_IOC_DIR(cmd))
1872 case (_IOC_WRITE | _IOC_READ):
1873 if (copy_to_user((void __user *)arg, parg, _IOC_SIZE(cmd)))
1882 EXPORT_SYMBOL(video_ioctl2);
1884 static const struct file_operations video_fops;
1887 * video_register_device - register video4linux devices
1888 * @vfd: video device structure we want to register
1889 * @type: type of device to register
1890 * @nr: which device number (0 == /dev/video0, 1 == /dev/video1, ...
1893 * The registration code assigns minor numbers based on the type
1894 * requested. -ENFILE is returned in all the device slots for this
1895 * category are full. If not then the minor field is set and the
1896 * driver initialize function is called (if non %NULL).
1898 * Zero is returned on success.
1902 * %VFL_TYPE_GRABBER - A frame grabber
1904 * %VFL_TYPE_VTX - A teletext device
1906 * %VFL_TYPE_VBI - Vertical blank data (undecoded)
1908 * %VFL_TYPE_RADIO - A radio card
1911 int video_register_device(struct video_device *vfd, int type, int nr)
1921 case VFL_TYPE_GRABBER:
1922 base=MINOR_VFL_TYPE_GRABBER_MIN;
1923 end=MINOR_VFL_TYPE_GRABBER_MAX+1;
1924 name_base = "video";
1927 base=MINOR_VFL_TYPE_VTX_MIN;
1928 end=MINOR_VFL_TYPE_VTX_MAX+1;
1932 base=MINOR_VFL_TYPE_VBI_MIN;
1933 end=MINOR_VFL_TYPE_VBI_MAX+1;
1936 case VFL_TYPE_RADIO:
1937 base=MINOR_VFL_TYPE_RADIO_MIN;
1938 end=MINOR_VFL_TYPE_RADIO_MAX+1;
1939 name_base = "radio";
1942 printk(KERN_ERR "%s called with unknown type: %d\n",
1947 /* pick a minor number */
1948 mutex_lock(&videodev_lock);
1949 if (nr >= 0 && nr < end-base) {
1950 /* use the one the driver asked for */
1952 if (NULL != video_device[i]) {
1953 mutex_unlock(&videodev_lock);
1957 /* use first free */
1958 for(i=base;i<end;i++)
1959 if (NULL == video_device[i])
1962 mutex_unlock(&videodev_lock);
1966 video_device[i]=vfd;
1968 mutex_unlock(&videodev_lock);
1969 mutex_init(&vfd->lock);
1972 memset(&vfd->class_dev, 0x00, sizeof(vfd->class_dev));
1974 vfd->class_dev.parent = vfd->dev;
1975 vfd->class_dev.class = &video_class;
1976 vfd->class_dev.devt = MKDEV(VIDEO_MAJOR, vfd->minor);
1977 sprintf(vfd->class_dev.bus_id, "%s%d", name_base, i - base);
1978 ret = device_register(&vfd->class_dev);
1980 printk(KERN_ERR "%s: device_register failed\n",
1986 /* needed until all drivers are fixed */
1988 printk(KERN_WARNING "videodev: \"%s\" has no release callback. "
1989 "Please fix your driver for proper sysfs support, see "
1990 "http://lwn.net/Articles/36850/\n", vfd->name);
1995 mutex_lock(&videodev_lock);
1996 video_device[vfd->minor] = NULL;
1998 mutex_unlock(&videodev_lock);
2001 EXPORT_SYMBOL(video_register_device);
2004 * video_unregister_device - unregister a video4linux device
2005 * @vfd: the device to unregister
2007 * This unregisters the passed device and deassigns the minor
2008 * number. Future open calls will be met with errors.
2011 void video_unregister_device(struct video_device *vfd)
2013 mutex_lock(&videodev_lock);
2014 if(video_device[vfd->minor]!=vfd)
2015 panic("videodev: bad unregister");
2017 video_device[vfd->minor]=NULL;
2018 device_unregister(&vfd->class_dev);
2019 mutex_unlock(&videodev_lock);
2021 EXPORT_SYMBOL(video_unregister_device);
2024 * Video fs operations
2026 static const struct file_operations video_fops=
2028 .owner = THIS_MODULE,
2029 .llseek = no_llseek,
2034 * Initialise video for linux
2037 static int __init videodev_init(void)
2041 printk(KERN_INFO "Linux video capture interface: v2.00\n");
2042 if (register_chrdev(VIDEO_MAJOR, VIDEO_NAME, &video_fops)) {
2043 printk(KERN_WARNING "video_dev: unable to get major %d\n", VIDEO_MAJOR);
2047 ret = class_register(&video_class);
2049 unregister_chrdev(VIDEO_MAJOR, VIDEO_NAME);
2050 printk(KERN_WARNING "video_dev: class_register failed\n");
2057 static void __exit videodev_exit(void)
2059 class_unregister(&video_class);
2060 unregister_chrdev(VIDEO_MAJOR, VIDEO_NAME);
2063 module_init(videodev_init)
2064 module_exit(videodev_exit)
2066 MODULE_AUTHOR("Alan Cox, Mauro Carvalho Chehab <mchehab@infradead.org>");
2067 MODULE_DESCRIPTION("Device registrar for Video4Linux drivers v2");
2068 MODULE_LICENSE("GPL");